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

added GimpPaletteEntry typedef. 

2002-03-08  Michael Natterer  <mitch@gimp.org>

	* app/core/core-types.h: added GimpPaletteEntry typedef.

	* app/core/gimppalette.h: removed it here.

	* app/widgets/Makefile.am
	* app/widgets/widgets-types.h
	* app/widgets/gimpeditor.[ch]: new widget which is the base class
	for everything which is a vbox and has a button area at the
	bottom.

	* app/widgets/gimpcontainerview.[ch]: derived from GimpEditor now.

	* app/widgets/gimpdataeditor.[ch]: a GimpEditor subclass which is
	the base class for the new data editors below.

	* app/widgets/gimpbrushfactoryview.c
	* app/widgets/gimpbufferview.c
	* app/widgets/gimpchannellistview.c
	* app/widgets/gimpdatafactoryview.c
	* app/widgets/gimpdocumentview.c
	* app/widgets/gimpitemlistview.c
	* app/widgets/gimplayerlistview.c
	* app/widgets/gimpvectorslistview.c
	* themes/Default/gtkrc: chagec accordingly.

	* app/gui/Makefile.am
	* app/gui/brush-editor.[ch]
	* app/gui/gradient-editor.[ch]
	* app/gui/palette-editor.[ch]: removed...

	* app/widgets/gimpbrusheditor.[ch]
	* app/widgets/gimpgradienteditor.[ch]
	* app/widgets/gimppaletteeditor.[ch]: ...and added back as
	GimpDataEditor subclasses. Lots of cleanup and stuff...

	* app/gui/dialogs-constructors.[ch]
	* app/gui/dialogs.c
	* app/gui/gradient-editor-commands.c
	* app/gui/gui-types.h
	* app/gui/palette-select.c
	* app/tools/gimpcolorpickertool.c: changed accordingly.
This commit is contained in:
Michael Natterer 2002-03-08 00:27:45 +00:00 committed by Michael Natterer
parent e062b608ef
commit b0e05cda4a
50 changed files with 2856 additions and 6276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
ChangeLog
View File

@ -1,3 +1,47 @@
2002-03-08 Michael Natterer <mitch@gimp.org>
* app/core/core-types.h: added GimpPaletteEntry typedef.
* app/core/gimppalette.h: removed it here.
* app/widgets/Makefile.am
* app/widgets/widgets-types.h
* app/widgets/gimpeditor.[ch]: new widget which is the base class
for everything which is a vbox and has a button area at the
bottom.
* app/widgets/gimpcontainerview.[ch]: derived from GimpEditor now.
* app/widgets/gimpdataeditor.[ch]: a GimpEditor subclass which is
the base class for the new data editors below.
* app/widgets/gimpbrushfactoryview.c
* app/widgets/gimpbufferview.c
* app/widgets/gimpchannellistview.c
* app/widgets/gimpdatafactoryview.c
* app/widgets/gimpdocumentview.c
* app/widgets/gimpitemlistview.c
* app/widgets/gimplayerlistview.c
* app/widgets/gimpvectorslistview.c
* themes/Default/gtkrc: chagec accordingly.
* app/gui/Makefile.am
* app/gui/brush-editor.[ch]
* app/gui/gradient-editor.[ch]
* app/gui/palette-editor.[ch]: removed...
* app/widgets/gimpbrusheditor.[ch]
* app/widgets/gimpgradienteditor.[ch]
* app/widgets/gimppaletteeditor.[ch]: ...and added back as
GimpDataEditor subclasses. Lots of cleanup and stuff...
* app/gui/dialogs-constructors.[ch]
* app/gui/dialogs.c
* app/gui/gradient-editor-commands.c
* app/gui/gui-types.h
* app/gui/palette-select.c
* app/tools/gimpcolorpickertool.c: changed accordingly.
2002-03-07 Sven Neumann <sven@gimp.org>
* app/gui/splash.c: back to a still splash image.

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

@ -28,13 +28,15 @@
#include "core/gimpcontext.h"
#include "core/gimpgradient.h"
#include "widgets/gimpgradienteditor.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "color-notebook.h"
#include "gradient-editor.h"
#include "gradient-editor-commands.h"
#include "app_procs.h"
#include "libgimp/gimpintl.h"
@ -50,16 +52,16 @@ static void gradient_editor_right_color_changed (ColorNotebook *cnb,
gpointer data);
static GimpGradientSegment *
gradient_editor_save_selection (GradientEditor *editor);
static void gradient_editor_replace_selection (GradientEditor *editor,
gradient_editor_save_selection (GimpGradientEditor *editor);
static void gradient_editor_replace_selection (GimpGradientEditor *editor,
GimpGradientSegment *replace_seg);
static void gradient_editor_dialog_cancel_callback (GtkWidget *widget,
GradientEditor *editor);
GimpGradientEditor *editor);
static void gradient_editor_split_uniform_callback (GtkWidget *widget,
GradientEditor *editor);
GimpGradientEditor *editor);
static void gradient_editor_replicate_callback (GtkWidget *widget,
GradientEditor *editor);
GimpGradientEditor *editor);
/* public functionss */
@ -69,15 +71,15 @@ gradient_editor_left_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
editor->left_saved_dirty = GIMP_DATA (gradient)->dirty;
editor->left_saved_segments = gradient_editor_save_selection (editor);
@ -89,7 +91,7 @@ gradient_editor_left_color_cmd_callback (GtkWidget *widget,
editor->instant_update,
TRUE);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -97,16 +99,22 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpContext *user_context;
GimpGradientSegment *seg;
GimpRGB color;
gint i;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
i = (gint) action;
switch (i)
@ -133,8 +141,8 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
break;
case 2: /* Fetch from FG color */
gimp_context_get_foreground (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_foreground (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&color,
@ -143,8 +151,8 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
break;
case 3: /* Fetch from BG color */
gimp_context_get_background (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_background (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&color,
@ -161,9 +169,9 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
break;
}
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -171,9 +179,9 @@ gradient_editor_save_left_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -186,15 +194,15 @@ gradient_editor_right_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
editor->right_saved_dirty = GIMP_DATA (gradient)->dirty;
editor->right_saved_segments = gradient_editor_save_selection (editor);
@ -206,7 +214,7 @@ gradient_editor_right_color_cmd_callback (GtkWidget *widget,
editor->instant_update,
TRUE);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -214,16 +222,22 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpContext *user_context;
GimpGradientSegment *seg;
GimpRGB color;
gint i;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
i = (gint) action;
switch (i)
@ -250,8 +264,8 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
break;
case 2: /* Fetch from FG color */
gimp_context_get_foreground (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_foreground (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&editor->control_sel_l->left_color,
@ -260,8 +274,8 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
break;
case 3: /* Fetch from BG color */
gimp_context_get_background (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_background (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&editor->control_sel_l->left_color,
@ -278,9 +292,9 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
break;
}
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -288,9 +302,9 @@ gradient_editor_save_right_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -303,7 +317,7 @@ gradient_editor_blending_func_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegmentType type;
GimpGradientSegment *seg, *aseg;
@ -311,12 +325,12 @@ gradient_editor_blending_func_cmd_callback (GtkWidget *widget,
if (! GTK_CHECK_MENU_ITEM (widget)->active)
return;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
type = (GimpGradientSegmentType) action;
@ -333,7 +347,7 @@ gradient_editor_blending_func_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -341,7 +355,7 @@ gradient_editor_coloring_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegmentColor color;
GimpGradientSegment *seg, *aseg;
@ -349,12 +363,12 @@ gradient_editor_coloring_type_cmd_callback (GtkWidget *widget,
if (! GTK_CHECK_MENU_ITEM (widget)->active)
return;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
color = (GimpGradientSegmentColor) action;
@ -371,7 +385,7 @@ gradient_editor_coloring_type_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -379,19 +393,19 @@ gradient_editor_flip_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *oseg, *oaseg;
GimpGradientSegment *seg, *prev, *tmp;
GimpGradientSegment *lseg, *rseg;
gdouble left, right;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
left = editor->control_sel_l->left;
right = editor->control_sel_r->right;
@ -502,7 +516,8 @@ gradient_editor_flip_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -510,14 +525,14 @@ gradient_editor_replicate_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
GimpGradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -573,7 +588,7 @@ gradient_editor_replicate_cmd_callback (GtkWidget *widget,
/* Show! */
gtk_widget_show (dialog);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -581,16 +596,16 @@ gradient_editor_split_midpoint_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *seg, *lseg, *rseg;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
seg = editor->control_sel_l;
@ -605,7 +620,8 @@ gradient_editor_split_midpoint_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -613,14 +629,14 @@ gradient_editor_split_uniformly_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
GimpGradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -678,7 +694,7 @@ gradient_editor_split_uniformly_cmd_callback (GtkWidget *widget,
/* Show! */
gtk_widget_show (dialog);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -686,17 +702,17 @@ gradient_editor_delete_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *lseg, *rseg, *seg, *aseg, *next;
gdouble join;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
/* Remember segments to the left and to the right of the selection */
@ -769,7 +785,8 @@ gradient_editor_delete_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -777,16 +794,16 @@ gradient_editor_recenter_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *seg, *aseg;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
seg = editor->control_sel_l;
@ -801,7 +818,8 @@ gradient_editor_recenter_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -809,19 +827,19 @@ gradient_editor_redistribute_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *seg, *aseg;
gdouble left, right, seg_len;
gint num_segs;
gint i;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
/* Count number of segments in selection */
@ -864,7 +882,8 @@ gradient_editor_redistribute_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -872,9 +891,9 @@ gradient_editor_blend_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -885,9 +904,9 @@ gradient_editor_blend_color_cmd_callback (GtkWidget *widget,
&editor->control_sel_r->right_color,
TRUE, FALSE);
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA_EDITOR (editor)->data);
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -895,9 +914,9 @@ gradient_editor_blend_opacity_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -908,16 +927,17 @@ gradient_editor_blend_opacity_cmd_callback (GtkWidget *widget,
&editor->control_sel_r->right_color,
FALSE, TRUE);
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA_EDITOR (editor)->data);
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
gradient_editor_menu_update (GtkItemFactory *factory,
gpointer data)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpContext *user_context;
GimpGradientSegment *left_seg;
GimpGradientSegment *right_seg;
GimpRGB fg;
@ -927,7 +947,9 @@ gradient_editor_menu_update (GtkItemFactory *factory,
gboolean selection;
gboolean delete;
editor = (GradientEditor *) data;
editor = (GimpGradientEditor *) data;
user_context = gimp_get_user_context (the_gimp);
if (editor->control_sel_l->prev)
left_seg = editor->control_sel_l->prev;
@ -939,10 +961,8 @@ gradient_editor_menu_update (GtkItemFactory *factory,
else
right_seg = gimp_gradient_segment_get_first (editor->control_sel_r);
gimp_context_get_foreground (gimp_get_user_context (editor->context->gimp),
&fg);
gimp_context_get_background (gimp_get_user_context (editor->context->gimp),
&bg);
gimp_context_get_foreground (user_context, &fg);
gimp_context_get_background (user_context, &bg);
{
GimpGradientSegmentType type;
@ -1138,12 +1158,12 @@ gradient_editor_left_color_changed (ColorNotebook *cnb,
ColorNotebookState state,
gpointer data)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) data;
editor = (GimpGradientEditor *) data;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
switch (state)
{
@ -1156,7 +1176,7 @@ gradient_editor_left_color_changed (ColorNotebook *cnb,
gimp_gradient_segments_free (editor->left_saved_segments);
gimp_data_dirty (GIMP_DATA (gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
case COLOR_NOTEBOOK_UPDATE:
@ -1171,13 +1191,13 @@ gradient_editor_left_color_changed (ColorNotebook *cnb,
case COLOR_NOTEBOOK_CANCEL:
gradient_editor_replace_selection (editor, editor->left_saved_segments);
GIMP_DATA (gradient)->dirty = editor->left_saved_dirty;
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
}
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
static void
@ -1186,12 +1206,12 @@ gradient_editor_right_color_changed (ColorNotebook *cnb,
ColorNotebookState state,
gpointer data)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) data;
editor = (GimpGradientEditor *) data;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
switch (state)
{
@ -1213,22 +1233,22 @@ gradient_editor_right_color_changed (ColorNotebook *cnb,
gimp_gradient_segments_free (editor->right_saved_segments);
gimp_data_dirty (GIMP_DATA (gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
case COLOR_NOTEBOOK_CANCEL:
gradient_editor_replace_selection (editor, editor->right_saved_segments);
GIMP_DATA (gradient)->dirty = editor->right_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
}
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
static GimpGradientSegment *
gradient_editor_save_selection (GradientEditor *editor)
gradient_editor_save_selection (GimpGradientEditor *editor)
{
GimpGradientSegment *seg, *prev, *tmp;
GimpGradientSegment *oseg, *oaseg;
@ -1261,14 +1281,14 @@ gradient_editor_save_selection (GradientEditor *editor)
}
static void
gradient_editor_replace_selection (GradientEditor *editor,
gradient_editor_replace_selection (GimpGradientEditor *editor,
GimpGradientSegment *replace_seg)
{
GimpGradient *gradient;
GimpGradientSegment *lseg, *rseg;
GimpGradientSegment *replace_last;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
/* Remember left and right segments */
@ -1304,24 +1324,24 @@ gradient_editor_replace_selection (GradientEditor *editor,
}
static void
gradient_editor_dialog_cancel_callback (GtkWidget *widget,
GradientEditor *editor)
gradient_editor_dialog_cancel_callback (GtkWidget *widget,
GimpGradientEditor *editor)
{
gtk_widget_destroy (gtk_widget_get_toplevel (widget));
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
}
static void
gradient_editor_split_uniform_callback (GtkWidget *widget,
GradientEditor *editor)
gradient_editor_split_uniform_callback (GtkWidget *widget,
GimpGradientEditor *editor)
{
GimpGradient *gradient;
GimpGradientSegment *seg, *aseg, *lseg, *rseg, *lsel;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
gtk_widget_destroy (gtk_widget_get_toplevel (widget));
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
seg = editor->control_sel_l;
lsel = NULL;
@ -1345,12 +1365,13 @@ gradient_editor_split_uniform_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
static void
gradient_editor_replicate_callback (GtkWidget *widget,
GradientEditor *editor)
gradient_editor_replicate_callback (GtkWidget *widget,
GimpGradientEditor *editor)
{
GimpGradient *gradient;
gdouble sel_left, sel_right, sel_len;
@ -1361,10 +1382,10 @@ gradient_editor_replicate_callback (GtkWidget *widget,
GimpGradientSegment *lseg, *rseg;
gint i;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
gtk_widget_destroy (gtk_widget_get_toplevel (widget));
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
/* Remember original parameters */
sel_left = editor->control_sel_l->left;
@ -1463,5 +1484,6 @@ gradient_editor_replicate_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}

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

@ -246,6 +246,8 @@ typedef struct _GimpProgress GimpProgress;
typedef guint32 GimpTattoo;
typedef struct _GimpPaletteEntry GimpPaletteEntry;
/* EEK stuff */

2
app/core/gimppalette.h
View File

@ -34,8 +34,6 @@
#define GIMP_PALETTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PALETTE, GimpPaletteClass))
typedef struct _GimpPaletteEntry GimpPaletteEntry;
struct _GimpPaletteEntry
{
GimpRGB color;

205
app/dialogs/dialogs-constructors.c
View File

@ -37,10 +37,12 @@
#include "vectors/gimpvectors.h"
#include "widgets/gimpbrusheditor.h"
#include "widgets/gimpbrushfactoryview.h"
#include "widgets/gimpbufferview.h"
#include "widgets/gimpcontainerlistview.h"
#include "widgets/gimpcontainergridview.h"
#include "widgets/gimpdataeditor.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpimagedock.h"
@ -49,12 +51,13 @@
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockbook.h"
#include "widgets/gimpdocumentview.h"
#include "widgets/gimpgradienteditor.h"
#include "widgets/gimplistitem.h"
#include "widgets/gimppaletteeditor.h"
#include "widgets/gimppreview.h"
#include "widgets/gimpvectorslistview.h"
#include "about-dialog.h"
#include "brush-editor.h"
#include "brush-select.h"
#include "brushes-commands.h"
#include "buffers-commands.h"
@ -66,13 +69,11 @@
#include "dialogs-constructors.h"
#include "documents-commands.h"
#include "error-console-dialog.h"
#include "gradient-editor.h"
#include "gradient-select.h"
#include "gradients-commands.h"
#include "layers-commands.h"
#include "menus.h"
#include "module-browser.h"
#include "palette-editor.h"
#include "palette-select.h"
#include "palettes-commands.h"
#include "paths-dialog.h"
@ -281,121 +282,6 @@ dialogs_about_get (GimpDialogFactory *factory,
}
/* editors */
#ifdef __GNUC__
#warning: FIXME: remove EEKWrapper (make editors dockable)
#endif
typedef struct
{
GtkWidget *shell;
} EEKWrapper;
/* the brush editor */
static BrushEditor *brush_editor_dialog = NULL;
GtkWidget *
dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
if (! brush_editor_dialog)
{
brush_editor_dialog = brush_editor_new (context->gimp);
}
return ((EEKWrapper *) brush_editor_dialog)->shell;
}
void
dialogs_edit_brush_func (GimpData *data)
{
GimpBrush *brush;
brush = GIMP_BRUSH (data);
if (GIMP_IS_BRUSH_GENERATED (brush))
{
gimp_dialog_factory_dialog_raise (global_dialog_factory,
"gimp:brush-editor",
-1);
brush_editor_set_brush (brush_editor_dialog, brush);
}
else
{
g_message (_("This brush cannot be edited."));
}
}
/* the gradient editor */
static GradientEditor *gradient_editor_dialog = NULL;
GtkWidget *
dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
if (! gradient_editor_dialog)
{
gradient_editor_dialog = gradient_editor_new (context->gimp);
}
return ((EEKWrapper *) gradient_editor_dialog)->shell;
}
void
dialogs_edit_gradient_func (GimpData *data)
{
GimpGradient *gradient;
gradient = GIMP_GRADIENT (data);
gimp_dialog_factory_dialog_raise (global_dialog_factory,
"gimp:gradient-editor",
-1);
gradient_editor_set_gradient (gradient_editor_dialog, gradient);
}
/* the palette editor */
static PaletteEditor *palette_editor_dialog = NULL;
GtkWidget *
dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
if (! palette_editor_dialog)
{
palette_editor_dialog = palette_editor_new (context->gimp);
}
return ((EEKWrapper *) palette_editor_dialog)->shell;
}
void
dialogs_edit_palette_func (GimpData *data)
{
GimpPalette *palette;
palette = GIMP_PALETTE (data);
gimp_dialog_factory_dialog_raise (global_dialog_factory,
"gimp:palette-editor",
-1);
palette_editor_set_palette (palette_editor_dialog, palette);
}
/* docks */
GtkWidget *
@ -888,6 +774,89 @@ dialogs_indexed_palette_new (GimpDialogFactory *factory,
}
/* editors */
/* the brush editor */
static GimpDataEditor *brush_editor = NULL;
GtkWidget *
dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
brush_editor = gimp_brush_editor_new (context->gimp);
return dialogs_dockable_new (GTK_WIDGET (brush_editor),
"Brush Editor", "Brush Editor",
NULL, NULL);
}
void
dialogs_edit_brush_func (GimpData *data)
{
gimp_dialog_factory_dialog_raise (global_dock_factory,
"gimp:brush-editor",
-1);
gimp_data_editor_set_data (brush_editor, data);
}
/* the gradient editor */
static GimpDataEditor *gradient_editor = NULL;
GtkWidget *
dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
gradient_editor = gimp_gradient_editor_new (context->gimp);
return dialogs_dockable_new (GTK_WIDGET (gradient_editor),
"Gradient Editor", "Gradient Editor",
NULL, NULL);
}
void
dialogs_edit_gradient_func (GimpData *data)
{
gimp_dialog_factory_dialog_raise (global_dock_factory,
"gimp:gradient-editor",
-1);
gimp_data_editor_set_data (gradient_editor, data);
}
/* the palette editor */
static GimpDataEditor *palette_editor = NULL;
GtkWidget *
dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
palette_editor = gimp_palette_editor_new (context->gimp);
return dialogs_dockable_new (GTK_WIDGET (palette_editor),
"Palette Editor", "Palette Editor",
NULL, NULL);
}
void
dialogs_edit_palette_func (GimpData *data)
{
gimp_dialog_factory_dialog_raise (global_dock_factory,
"gimp:palette-editor",
-1);
gimp_data_editor_set_data (palette_editor, data);
}
/* misc dockables */
GtkWidget *

31
app/dialogs/dialogs-constructors.h
View File

@ -20,6 +20,8 @@
#define __DIALOGS_CONSTRUCTORS_H__
/* toplevel dialogs */
GtkWidget * dialogs_toolbox_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
@ -60,20 +62,8 @@ GtkWidget * dialogs_about_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_brush_func (GimpData *data);
GtkWidget * dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_gradient_func (GimpData *data);
GtkWidget * dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_palette_func (GimpData *data);
/* docks & dockables */
GtkWidget * dialogs_dock_new (GimpDialogFactory *factory,
GimpContext *context,
@ -143,6 +133,21 @@ GtkWidget * dialogs_document_history_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_brush_func (GimpData *data);
GtkWidget * dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_gradient_func (GimpData *data);
GtkWidget * dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_palette_func (GimpData *data);
GtkWidget * dialogs_error_console_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);

26
app/dialogs/dialogs.c
View File

@ -50,11 +50,7 @@ static const GimpDialogFactoryEntry toplevel_entries[] =
{ "gimp:undo-history-dialog", dialogs_undo_history_get, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp:display-filters-dialog", dialogs_display_filters_get, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp:tips-dialog", dialogs_tips_get, 32, TRUE, FALSE, FALSE, TRUE },
{ "gimp:about-dialog", dialogs_about_get, 32, TRUE, FALSE, FALSE, TRUE },
{ "gimp:brush-editor", dialogs_brush_editor_get, 32, TRUE, TRUE, TRUE, FALSE },
{ "gimp:gradient-editor", dialogs_gradient_editor_get, 32, TRUE, TRUE, TRUE, FALSE },
{ "gimp:palette-editor", dialogs_palette_editor_get, 32, TRUE, TRUE, TRUE, FALSE }
{ "gimp:about-dialog", dialogs_about_get, 32, TRUE, FALSE, FALSE, TRUE }
};
static const GimpDialogFactoryEntry dock_entries[] =
@ -83,7 +79,11 @@ static const GimpDialogFactoryEntry dock_entries[] =
{ "gimp:document-history", dialogs_document_history_new, 48, FALSE, FALSE, FALSE, TRUE },
{ "gimp:error-console", dialogs_error_console_get, 32, TRUE, FALSE, FALSE, TRUE }
{ "gimp:brush-editor", dialogs_brush_editor_get, 0, TRUE, FALSE, FALSE, TRUE },
{ "gimp:gradient-editor", dialogs_gradient_editor_get, 0, TRUE, FALSE, FALSE, TRUE },
{ "gimp:palette-editor", dialogs_palette_editor_get, 0, TRUE, FALSE, FALSE, TRUE },
{ "gimp:error-console", dialogs_error_console_get, 0, TRUE, FALSE, FALSE, TRUE }
};
@ -128,9 +128,15 @@ dialogs_init (Gimp *gimp)
void
dialogs_exit (Gimp *gimp)
{
g_object_unref (G_OBJECT (global_dialog_factory));
g_object_unref (G_OBJECT (global_dock_factory));
if (global_dialog_factory)
{
g_object_unref (G_OBJECT (global_dialog_factory));
global_dialog_factory = NULL;
}
global_dialog_factory = NULL;
global_dock_factory = NULL;
if (global_dock_factory)
{
g_object_unref (G_OBJECT (global_dock_factory));
global_dock_factory = NULL;
}
}

6
app/gui/Makefile.am
View File

@ -6,8 +6,6 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \
about-dialog.c \
about-dialog.h \
authors.h \
brush-editor.c \
brush-editor.h \
brush-select.c \
brush-select.h \
brushes-commands.c \
@ -56,8 +54,6 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \
file-open-dialog.h \
file-save-dialog.c \
file-save-dialog.h \
gradient-editor.c \
gradient-editor.h \
gradient-editor-commands.c \
gradient-editor-commands.h \
gradient-select.h \
@ -83,8 +79,6 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \
module-browser.h \
offset-dialog.c \
offset-dialog.h \
palette-editor.c \
palette-editor.h \
palette-import-dialog.c \
palette-import-dialog.h \
palette-select.c \

420
app/gui/brush-editor.c
View File

@ -1,420 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* brush-editor.c
* Copyright 1998 Jay Cox <jaycox@earthlink.net>
*
* 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 <string.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
#endif
#undef GTK_DISABLE_DEPRECATED
#include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "core/core-types.h"
#include "base/temp-buf.h"
#include "core/gimpbrushgenerated.h"
#include "brush-editor.h"
#include "libgimp/gimpintl.h"
struct _BrushEditor
{
GtkWidget *shell;
GtkWidget *frame;
GtkWidget *preview;
GtkWidget *scale_label;
GtkWidget *options_box;
GtkWidget *name;
GtkAdjustment *radius_data;
GtkAdjustment *hardness_data;
GtkAdjustment *angle_data;
GtkAdjustment *aspect_ratio_data;
/* Brush preview */
GtkWidget *brush_preview;
GimpBrushGenerated *brush;
gint scale;
};
static void brush_editor_close_callback (GtkWidget *widget,
gpointer data);
static void brush_editor_name_activate (GtkWidget *widget,
BrushEditor *brush_editor);
static gboolean brush_editor_name_focus_out (GtkWidget *widget,
GdkEventFocus *fevent,
BrushEditor *brush_editor);
static void brush_editor_update_brush (GtkAdjustment *adjustment,
BrushEditor *brush_editor);
static void brush_editor_preview_resize (GtkWidget *widget,
GtkAllocation *allocation,
BrushEditor *brush_editor);
static void brush_editor_clear_preview (BrushEditor *brush_editor);
static void brush_editor_brush_dirty (GimpBrush *brush,
BrushEditor *brush_editor);
static void brush_editor_brush_name_changed (GtkWidget *widget,
BrushEditor *brush_editor);
/* public functions */
BrushEditor *
brush_editor_new (Gimp *gimp)
{
BrushEditor *brush_editor;
GtkWidget *vbox;
GtkWidget *slider;
GtkWidget *table;
brush_editor = g_new0 (BrushEditor, 1);
brush_editor->shell =
gimp_dialog_new (_("Brush Editor"), "generated_brush_editor",
gimp_standard_help_func,
"dialogs/brush_editor.html",
GTK_WIN_POS_NONE,
FALSE, TRUE, FALSE,
"_delete_event_", brush_editor_close_callback,
brush_editor, NULL, NULL, TRUE, TRUE,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (brush_editor->shell), FALSE);
gtk_widget_hide (GTK_DIALOG (brush_editor->shell)->action_area);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (brush_editor->shell)->vbox),
vbox);
/* Brush's name */
brush_editor->name = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), brush_editor->name, FALSE, FALSE, 0);
gtk_widget_show (brush_editor->name);
g_signal_connect (G_OBJECT (brush_editor->name), "activate",
G_CALLBACK (brush_editor_name_activate),
brush_editor);
g_signal_connect (G_OBJECT (brush_editor->name), "focus_out_event",
G_CALLBACK (brush_editor_name_focus_out),
brush_editor);
/* brush's preview widget w/frame */
brush_editor->frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (brush_editor->frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), brush_editor->frame, TRUE, TRUE, 0);
gtk_widget_show (brush_editor->frame);
brush_editor->preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
gtk_preview_size (GTK_PREVIEW (brush_editor->preview), 125, 100);
/* Enable auto-resizing of the preview but ensure a minimal size */
gtk_widget_set_size_request (brush_editor->preview, 125, 100);
gtk_preview_set_expand (GTK_PREVIEW (brush_editor->preview), TRUE);
gtk_container_add (GTK_CONTAINER (brush_editor->frame), brush_editor->preview);
gtk_widget_show (brush_editor->preview);
g_signal_connect_after (G_OBJECT (brush_editor->frame), "size_allocate",
G_CALLBACK (brush_editor_preview_resize),
brush_editor);
/* table for sliders/labels */
brush_editor->scale_label = gtk_label_new ("-1:1");
gtk_box_pack_start (GTK_BOX (vbox), brush_editor->scale_label,
FALSE, FALSE, 0);
gtk_widget_show (brush_editor->scale_label);
brush_editor->scale = -1;
/* table for sliders/labels */
table = gtk_table_new (4, 2, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
/* brush radius scale */
brush_editor->radius_data =
GTK_ADJUSTMENT (gtk_adjustment_new (10.0, 0.0, 100.0, 0.1, 1.0, 0.0));
slider = gtk_hscale_new (brush_editor->radius_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->radius_data), "value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Radius:"), 1.0, 1.0,
slider, 1, FALSE);
/* brush hardness scale */
brush_editor->hardness_data =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1.0, 0.01, 0.01, 0.0));
slider = gtk_hscale_new (brush_editor->hardness_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->hardness_data), "value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Hardness:"), 1.0, 1.0,
slider, 1, FALSE);
/* brush aspect ratio scale */
brush_editor->aspect_ratio_data =
GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 1.0, 20.0, 0.1, 1.0, 0.0));
slider = gtk_hscale_new (brush_editor->aspect_ratio_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->aspect_ratio_data),"value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Aspect Ratio:"), 1.0, 1.0,
slider, 1, FALSE);
/* brush angle scale */
brush_editor->angle_data =
GTK_ADJUSTMENT (gtk_adjustment_new (00.0, 0.0, 180.0, 0.1, 1.0, 0.0));
slider = gtk_hscale_new (brush_editor->angle_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->angle_data), "value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("Angle:"), 1.0, 1.0,
slider, 1, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 3);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
gtk_widget_show (table);
gtk_widget_show (vbox);
gtk_widget_show (brush_editor->shell);
return brush_editor;
}
void
brush_editor_set_brush (BrushEditor *brush_editor,
GimpBrush *gbrush)
{
GimpBrushGenerated *brush = NULL;
g_return_if_fail (brush_editor != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (gbrush));
if (brush_editor->brush)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (brush_editor->brush),
brush_editor_brush_dirty,
brush_editor);
g_signal_handlers_disconnect_by_func (G_OBJECT (brush_editor->brush),
brush_editor_brush_name_changed,
brush_editor);
g_object_unref (G_OBJECT (brush_editor->brush));
brush_editor->brush = NULL;
}
brush = GIMP_BRUSH_GENERATED (gbrush);
g_signal_connect (G_OBJECT (brush), "invalidate_preview",
G_CALLBACK (brush_editor_brush_dirty),
brush_editor);
g_signal_connect (G_OBJECT (brush), "name_changed",
G_CALLBACK (brush_editor_brush_name_changed),
brush_editor);
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->radius_data),
gimp_brush_generated_get_radius (brush));
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->hardness_data),
gimp_brush_generated_get_hardness (brush));
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->angle_data),
gimp_brush_generated_get_angle (brush));
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->aspect_ratio_data),
gimp_brush_generated_get_aspect_ratio (brush));
gtk_entry_set_text (GTK_ENTRY (brush_editor->name),
gimp_object_get_name (GIMP_OBJECT (gbrush)));
brush_editor->brush = brush;
g_object_ref (G_OBJECT (brush_editor->brush));
brush_editor_brush_dirty (GIMP_BRUSH (brush), brush_editor);
}
/* private functions */
static void
brush_editor_close_callback (GtkWidget *widget,
gpointer data)
{
BrushEditor *brush_editor = (BrushEditor *) data;
if (GTK_WIDGET_VISIBLE (brush_editor->shell))
gtk_widget_hide (brush_editor->shell);
}
static void
brush_editor_name_activate (GtkWidget *widget,
BrushEditor *brush_editor)
{
const gchar *entry_text;
entry_text = gtk_entry_get_text (GTK_ENTRY (widget));
gimp_object_set_name (GIMP_OBJECT (brush_editor->brush), entry_text);
}
static gboolean
brush_editor_name_focus_out (GtkWidget *widget,
GdkEventFocus *fevent,
BrushEditor *brush_editor)
{
brush_editor_name_activate (widget, brush_editor);
return FALSE;
}
static void
brush_editor_update_brush (GtkAdjustment *adjustment,
BrushEditor *brush_editor)
{
if (brush_editor->brush &&
((brush_editor->radius_data->value
!= gimp_brush_generated_get_radius (brush_editor->brush))
|| (brush_editor->hardness_data->value
!= gimp_brush_generated_get_hardness (brush_editor->brush))
|| (brush_editor->aspect_ratio_data->value
!= gimp_brush_generated_get_aspect_ratio (brush_editor->brush))
|| (brush_editor->angle_data->value
!= gimp_brush_generated_get_angle (brush_editor->brush))))
{
gimp_brush_generated_freeze (brush_editor->brush);
gimp_brush_generated_set_radius (brush_editor->brush,
brush_editor->radius_data->value);
gimp_brush_generated_set_hardness (brush_editor->brush,
brush_editor->hardness_data->value);
gimp_brush_generated_set_aspect_ratio (brush_editor->brush,
brush_editor->aspect_ratio_data->value);
gimp_brush_generated_set_angle (brush_editor->brush,
brush_editor->angle_data->value);
gimp_brush_generated_thaw (brush_editor->brush);
}
}
static void
brush_editor_preview_resize (GtkWidget *widget,
GtkAllocation *allocation,
BrushEditor *brush_editor)
{
if (brush_editor->brush)
brush_editor_brush_dirty (GIMP_BRUSH (brush_editor->brush), brush_editor);
}
static void
brush_editor_clear_preview (BrushEditor *brush_editor)
{
guchar *buf;
gint i;
buf = g_new (guchar, brush_editor->preview->allocation.width);
/* Set the buffer to white */
memset (buf, 255, brush_editor->preview->allocation.width);
/* Set the image buffer to white */
for (i = 0; i < brush_editor->preview->allocation.height; i++)
gtk_preview_draw_row (GTK_PREVIEW (brush_editor->preview), buf, 0, i,
brush_editor->preview->allocation.width);
g_free (buf);
}
static void
brush_editor_brush_dirty (GimpBrush *brush,
BrushEditor *brush_editor)
{
gint x, y, width, yend, ystart, xo;
gint scale;
guchar *src, *buf;
brush_editor_clear_preview (brush_editor);
if (brush == NULL || brush->mask == NULL)
return;
scale = MAX (ceil (brush->mask->width/
(float) brush_editor->preview->allocation.width),
ceil (brush->mask->height/
(float) brush_editor->preview->allocation.height));
ystart = 0;
xo = brush_editor->preview->allocation.width / 2 - brush->mask->width / (2 * scale);
ystart = brush_editor->preview->allocation.height / 2 - brush->mask->height / (2 * scale);
yend = ystart + brush->mask->height / scale;
width = CLAMP (brush->mask->width/scale, 0, brush_editor->preview->allocation.width);
buf = g_new (guchar, width);
src = (guchar *) temp_buf_data (brush->mask);
for (y = ystart; y < yend; y++)
{
/* Invert the mask for display.
*/
for (x = 0; x < width; x++)
buf[x] = 255 - src[x * scale];
gtk_preview_draw_row (GTK_PREVIEW (brush_editor->preview), buf,
xo, y, width);
src += brush->mask->width * scale;
}
g_free (buf);
if (brush_editor->scale != scale)
{
gchar str[255];
brush_editor->scale = scale;
g_snprintf (str, sizeof (str), "%d:1", scale);
gtk_label_set_text (GTK_LABEL (brush_editor->scale_label), str);
}
gtk_widget_queue_draw (brush_editor->preview);
}
static void
brush_editor_brush_name_changed (GtkWidget *widget,
BrushEditor *brush_editor)
{
gtk_entry_set_text (GTK_ENTRY (brush_editor->name),
gimp_object_get_name (GIMP_OBJECT (brush_editor->brush)));
}

36
app/gui/brush-editor.h
View File

@ -1,36 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* brush-editor.h
* Copyright 1998 Jay Cox <jaycox@earthlink.net>
*
* 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 __BRUSH_EDITOR_H__
#define __BRUSH_EDITOR_H__
typedef struct _BrushEditor BrushEditor;
BrushEditor * brush_editor_new (Gimp *gimp);
void brush_editor_set_brush (BrushEditor *brush_editor,
GimpBrush *brush);
void brush_editor_free (BrushEditor *brush_editor);
#endif /* __BRUSH_EDITOR_H__ */

205
app/gui/dialogs-constructors.c
View File

@ -37,10 +37,12 @@
#include "vectors/gimpvectors.h"
#include "widgets/gimpbrusheditor.h"
#include "widgets/gimpbrushfactoryview.h"
#include "widgets/gimpbufferview.h"
#include "widgets/gimpcontainerlistview.h"
#include "widgets/gimpcontainergridview.h"
#include "widgets/gimpdataeditor.h"
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpimagedock.h"
@ -49,12 +51,13 @@
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockbook.h"
#include "widgets/gimpdocumentview.h"
#include "widgets/gimpgradienteditor.h"
#include "widgets/gimplistitem.h"
#include "widgets/gimppaletteeditor.h"
#include "widgets/gimppreview.h"
#include "widgets/gimpvectorslistview.h"
#include "about-dialog.h"
#include "brush-editor.h"
#include "brush-select.h"
#include "brushes-commands.h"
#include "buffers-commands.h"
@ -66,13 +69,11 @@
#include "dialogs-constructors.h"
#include "documents-commands.h"
#include "error-console-dialog.h"
#include "gradient-editor.h"
#include "gradient-select.h"
#include "gradients-commands.h"
#include "layers-commands.h"
#include "menus.h"
#include "module-browser.h"
#include "palette-editor.h"
#include "palette-select.h"
#include "palettes-commands.h"
#include "paths-dialog.h"
@ -281,121 +282,6 @@ dialogs_about_get (GimpDialogFactory *factory,
}
/* editors */
#ifdef __GNUC__
#warning: FIXME: remove EEKWrapper (make editors dockable)
#endif
typedef struct
{
GtkWidget *shell;
} EEKWrapper;
/* the brush editor */
static BrushEditor *brush_editor_dialog = NULL;
GtkWidget *
dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
if (! brush_editor_dialog)
{
brush_editor_dialog = brush_editor_new (context->gimp);
}
return ((EEKWrapper *) brush_editor_dialog)->shell;
}
void
dialogs_edit_brush_func (GimpData *data)
{
GimpBrush *brush;
brush = GIMP_BRUSH (data);
if (GIMP_IS_BRUSH_GENERATED (brush))
{
gimp_dialog_factory_dialog_raise (global_dialog_factory,
"gimp:brush-editor",
-1);
brush_editor_set_brush (brush_editor_dialog, brush);
}
else
{
g_message (_("This brush cannot be edited."));
}
}
/* the gradient editor */
static GradientEditor *gradient_editor_dialog = NULL;
GtkWidget *
dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
if (! gradient_editor_dialog)
{
gradient_editor_dialog = gradient_editor_new (context->gimp);
}
return ((EEKWrapper *) gradient_editor_dialog)->shell;
}
void
dialogs_edit_gradient_func (GimpData *data)
{
GimpGradient *gradient;
gradient = GIMP_GRADIENT (data);
gimp_dialog_factory_dialog_raise (global_dialog_factory,
"gimp:gradient-editor",
-1);
gradient_editor_set_gradient (gradient_editor_dialog, gradient);
}
/* the palette editor */
static PaletteEditor *palette_editor_dialog = NULL;
GtkWidget *
dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
if (! palette_editor_dialog)
{
palette_editor_dialog = palette_editor_new (context->gimp);
}
return ((EEKWrapper *) palette_editor_dialog)->shell;
}
void
dialogs_edit_palette_func (GimpData *data)
{
GimpPalette *palette;
palette = GIMP_PALETTE (data);
gimp_dialog_factory_dialog_raise (global_dialog_factory,
"gimp:palette-editor",
-1);
palette_editor_set_palette (palette_editor_dialog, palette);
}
/* docks */
GtkWidget *
@ -888,6 +774,89 @@ dialogs_indexed_palette_new (GimpDialogFactory *factory,
}
/* editors */
/* the brush editor */
static GimpDataEditor *brush_editor = NULL;
GtkWidget *
dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
brush_editor = gimp_brush_editor_new (context->gimp);
return dialogs_dockable_new (GTK_WIDGET (brush_editor),
"Brush Editor", "Brush Editor",
NULL, NULL);
}
void
dialogs_edit_brush_func (GimpData *data)
{
gimp_dialog_factory_dialog_raise (global_dock_factory,
"gimp:brush-editor",
-1);
gimp_data_editor_set_data (brush_editor, data);
}
/* the gradient editor */
static GimpDataEditor *gradient_editor = NULL;
GtkWidget *
dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
gradient_editor = gimp_gradient_editor_new (context->gimp);
return dialogs_dockable_new (GTK_WIDGET (gradient_editor),
"Gradient Editor", "Gradient Editor",
NULL, NULL);
}
void
dialogs_edit_gradient_func (GimpData *data)
{
gimp_dialog_factory_dialog_raise (global_dock_factory,
"gimp:gradient-editor",
-1);
gimp_data_editor_set_data (gradient_editor, data);
}
/* the palette editor */
static GimpDataEditor *palette_editor = NULL;
GtkWidget *
dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
palette_editor = gimp_palette_editor_new (context->gimp);
return dialogs_dockable_new (GTK_WIDGET (palette_editor),
"Palette Editor", "Palette Editor",
NULL, NULL);
}
void
dialogs_edit_palette_func (GimpData *data)
{
gimp_dialog_factory_dialog_raise (global_dock_factory,
"gimp:palette-editor",
-1);
gimp_data_editor_set_data (palette_editor, data);
}
/* misc dockables */
GtkWidget *

31
app/gui/dialogs-constructors.h
View File

@ -20,6 +20,8 @@
#define __DIALOGS_CONSTRUCTORS_H__
/* toplevel dialogs */
GtkWidget * dialogs_toolbox_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
@ -60,20 +62,8 @@ GtkWidget * dialogs_about_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_brush_func (GimpData *data);
GtkWidget * dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_gradient_func (GimpData *data);
GtkWidget * dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_palette_func (GimpData *data);
/* docks & dockables */
GtkWidget * dialogs_dock_new (GimpDialogFactory *factory,
GimpContext *context,
@ -143,6 +133,21 @@ GtkWidget * dialogs_document_history_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
GtkWidget * dialogs_brush_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_brush_func (GimpData *data);
GtkWidget * dialogs_gradient_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_gradient_func (GimpData *data);
GtkWidget * dialogs_palette_editor_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);
void dialogs_edit_palette_func (GimpData *data);
GtkWidget * dialogs_error_console_get (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size);

26
app/gui/dialogs.c
View File

@ -50,11 +50,7 @@ static const GimpDialogFactoryEntry toplevel_entries[] =
{ "gimp:undo-history-dialog", dialogs_undo_history_get, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp:display-filters-dialog", dialogs_display_filters_get, 32, FALSE, FALSE, FALSE, TRUE },
{ "gimp:tips-dialog", dialogs_tips_get, 32, TRUE, FALSE, FALSE, TRUE },
{ "gimp:about-dialog", dialogs_about_get, 32, TRUE, FALSE, FALSE, TRUE },
{ "gimp:brush-editor", dialogs_brush_editor_get, 32, TRUE, TRUE, TRUE, FALSE },
{ "gimp:gradient-editor", dialogs_gradient_editor_get, 32, TRUE, TRUE, TRUE, FALSE },
{ "gimp:palette-editor", dialogs_palette_editor_get, 32, TRUE, TRUE, TRUE, FALSE }
{ "gimp:about-dialog", dialogs_about_get, 32, TRUE, FALSE, FALSE, TRUE }
};
static const GimpDialogFactoryEntry dock_entries[] =
@ -83,7 +79,11 @@ static const GimpDialogFactoryEntry dock_entries[] =
{ "gimp:document-history", dialogs_document_history_new, 48, FALSE, FALSE, FALSE, TRUE },
{ "gimp:error-console", dialogs_error_console_get, 32, TRUE, FALSE, FALSE, TRUE }
{ "gimp:brush-editor", dialogs_brush_editor_get, 0, TRUE, FALSE, FALSE, TRUE },
{ "gimp:gradient-editor", dialogs_gradient_editor_get, 0, TRUE, FALSE, FALSE, TRUE },
{ "gimp:palette-editor", dialogs_palette_editor_get, 0, TRUE, FALSE, FALSE, TRUE },
{ "gimp:error-console", dialogs_error_console_get, 0, TRUE, FALSE, FALSE, TRUE }
};
@ -128,9 +128,15 @@ dialogs_init (Gimp *gimp)
void
dialogs_exit (Gimp *gimp)
{
g_object_unref (G_OBJECT (global_dialog_factory));
g_object_unref (G_OBJECT (global_dock_factory));
if (global_dialog_factory)
{
g_object_unref (G_OBJECT (global_dialog_factory));
global_dialog_factory = NULL;
}
global_dialog_factory = NULL;
global_dock_factory = NULL;
if (global_dock_factory)
{
g_object_unref (G_OBJECT (global_dock_factory));
global_dock_factory = NULL;
}
}

272
app/gui/gradient-editor-commands.c
View File

@ -28,13 +28,15 @@
#include "core/gimpcontext.h"
#include "core/gimpgradient.h"
#include "widgets/gimpgradienteditor.h"
#include "widgets/gimpitemfactory.h"
#include "widgets/gimpwidgets-utils.h"
#include "color-notebook.h"
#include "gradient-editor.h"
#include "gradient-editor-commands.h"
#include "app_procs.h"
#include "libgimp/gimpintl.h"
@ -50,16 +52,16 @@ static void gradient_editor_right_color_changed (ColorNotebook *cnb,
gpointer data);
static GimpGradientSegment *
gradient_editor_save_selection (GradientEditor *editor);
static void gradient_editor_replace_selection (GradientEditor *editor,
gradient_editor_save_selection (GimpGradientEditor *editor);
static void gradient_editor_replace_selection (GimpGradientEditor *editor,
GimpGradientSegment *replace_seg);
static void gradient_editor_dialog_cancel_callback (GtkWidget *widget,
GradientEditor *editor);
GimpGradientEditor *editor);
static void gradient_editor_split_uniform_callback (GtkWidget *widget,
GradientEditor *editor);
GimpGradientEditor *editor);
static void gradient_editor_replicate_callback (GtkWidget *widget,
GradientEditor *editor);
GimpGradientEditor *editor);
/* public functionss */
@ -69,15 +71,15 @@ gradient_editor_left_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
editor->left_saved_dirty = GIMP_DATA (gradient)->dirty;
editor->left_saved_segments = gradient_editor_save_selection (editor);
@ -89,7 +91,7 @@ gradient_editor_left_color_cmd_callback (GtkWidget *widget,
editor->instant_update,
TRUE);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -97,16 +99,22 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpContext *user_context;
GimpGradientSegment *seg;
GimpRGB color;
gint i;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
i = (gint) action;
switch (i)
@ -133,8 +141,8 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
break;
case 2: /* Fetch from FG color */
gimp_context_get_foreground (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_foreground (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&color,
@ -143,8 +151,8 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
break;
case 3: /* Fetch from BG color */
gimp_context_get_background (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_background (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&color,
@ -161,9 +169,9 @@ gradient_editor_load_left_cmd_callback (GtkWidget *widget,
break;
}
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -171,9 +179,9 @@ gradient_editor_save_left_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -186,15 +194,15 @@ gradient_editor_right_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
editor->right_saved_dirty = GIMP_DATA (gradient)->dirty;
editor->right_saved_segments = gradient_editor_save_selection (editor);
@ -206,7 +214,7 @@ gradient_editor_right_color_cmd_callback (GtkWidget *widget,
editor->instant_update,
TRUE);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -214,16 +222,22 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpContext *user_context;
GimpGradientSegment *seg;
GimpRGB color;
gint i;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
user_context = gimp_get_user_context (the_gimp);
i = (gint) action;
switch (i)
@ -250,8 +264,8 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
break;
case 2: /* Fetch from FG color */
gimp_context_get_foreground (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_foreground (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&editor->control_sel_l->left_color,
@ -260,8 +274,8 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
break;
case 3: /* Fetch from BG color */
gimp_context_get_background (gimp_get_user_context (editor->context->gimp),
&color);
gimp_context_get_background (user_context, &color);
gimp_gradient_segments_blend_endpoints (editor->control_sel_l,
editor->control_sel_r,
&editor->control_sel_l->left_color,
@ -278,9 +292,9 @@ gradient_editor_load_right_cmd_callback (GtkWidget *widget,
break;
}
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -288,9 +302,9 @@ gradient_editor_save_right_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -303,7 +317,7 @@ gradient_editor_blending_func_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegmentType type;
GimpGradientSegment *seg, *aseg;
@ -311,12 +325,12 @@ gradient_editor_blending_func_cmd_callback (GtkWidget *widget,
if (! GTK_CHECK_MENU_ITEM (widget)->active)
return;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
type = (GimpGradientSegmentType) action;
@ -333,7 +347,7 @@ gradient_editor_blending_func_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -341,7 +355,7 @@ gradient_editor_coloring_type_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegmentColor color;
GimpGradientSegment *seg, *aseg;
@ -349,12 +363,12 @@ gradient_editor_coloring_type_cmd_callback (GtkWidget *widget,
if (! GTK_CHECK_MENU_ITEM (widget)->active)
return;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
color = (GimpGradientSegmentColor) action;
@ -371,7 +385,7 @@ gradient_editor_coloring_type_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -379,19 +393,19 @@ gradient_editor_flip_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *oseg, *oaseg;
GimpGradientSegment *seg, *prev, *tmp;
GimpGradientSegment *lseg, *rseg;
gdouble left, right;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
left = editor->control_sel_l->left;
right = editor->control_sel_r->right;
@ -502,7 +516,8 @@ gradient_editor_flip_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -510,14 +525,14 @@ gradient_editor_replicate_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
GimpGradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -573,7 +588,7 @@ gradient_editor_replicate_cmd_callback (GtkWidget *widget,
/* Show! */
gtk_widget_show (dialog);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -581,16 +596,16 @@ gradient_editor_split_midpoint_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *seg, *lseg, *rseg;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
seg = editor->control_sel_l;
@ -605,7 +620,8 @@ gradient_editor_split_midpoint_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -613,14 +629,14 @@ gradient_editor_split_uniformly_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
GimpGradientEditor *editor;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -678,7 +694,7 @@ gradient_editor_split_uniformly_cmd_callback (GtkWidget *widget,
/* Show! */
gtk_widget_show (dialog);
gtk_widget_set_sensitive (editor->shell, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
}
void
@ -686,17 +702,17 @@ gradient_editor_delete_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *lseg, *rseg, *seg, *aseg, *next;
gdouble join;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
/* Remember segments to the left and to the right of the selection */
@ -769,7 +785,8 @@ gradient_editor_delete_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -777,16 +794,16 @@ gradient_editor_recenter_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *seg, *aseg;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
seg = editor->control_sel_l;
@ -801,7 +818,8 @@ gradient_editor_recenter_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -809,19 +827,19 @@ gradient_editor_redistribute_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpGradient *gradient;
GimpGradientSegment *seg, *aseg;
gdouble left, right, seg_len;
gint num_segs;
gint i;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
/* Count number of segments in selection */
@ -864,7 +882,8 @@ gradient_editor_redistribute_cmd_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
void
@ -872,9 +891,9 @@ gradient_editor_blend_color_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -885,9 +904,9 @@ gradient_editor_blend_color_cmd_callback (GtkWidget *widget,
&editor->control_sel_r->right_color,
TRUE, FALSE);
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA_EDITOR (editor)->data);
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
@ -895,9 +914,9 @@ gradient_editor_blend_opacity_cmd_callback (GtkWidget *widget,
gpointer data,
guint action)
{
GradientEditor *editor;
GimpGradientEditor *editor;
editor = (GradientEditor *) gimp_widget_get_callback_context (widget);
editor = (GimpGradientEditor *) gimp_widget_get_callback_context (widget);
if (! editor)
return;
@ -908,16 +927,17 @@ gradient_editor_blend_opacity_cmd_callback (GtkWidget *widget,
&editor->control_sel_r->right_color,
FALSE, TRUE);
gimp_data_dirty (GIMP_DATA (gimp_context_get_gradient (editor->context)));
gimp_data_dirty (GIMP_DATA_EDITOR (editor)->data);
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
void
gradient_editor_menu_update (GtkItemFactory *factory,
gpointer data)
{
GradientEditor *editor;
GimpGradientEditor *editor;
GimpContext *user_context;
GimpGradientSegment *left_seg;
GimpGradientSegment *right_seg;
GimpRGB fg;
@ -927,7 +947,9 @@ gradient_editor_menu_update (GtkItemFactory *factory,
gboolean selection;
gboolean delete;
editor = (GradientEditor *) data;
editor = (GimpGradientEditor *) data;
user_context = gimp_get_user_context (the_gimp);
if (editor->control_sel_l->prev)
left_seg = editor->control_sel_l->prev;
@ -939,10 +961,8 @@ gradient_editor_menu_update (GtkItemFactory *factory,
else
right_seg = gimp_gradient_segment_get_first (editor->control_sel_r);
gimp_context_get_foreground (gimp_get_user_context (editor->context->gimp),
&fg);
gimp_context_get_background (gimp_get_user_context (editor->context->gimp),
&bg);
gimp_context_get_foreground (user_context, &fg);
gimp_context_get_background (user_context, &bg);
{
GimpGradientSegmentType type;
@ -1138,12 +1158,12 @@ gradient_editor_left_color_changed (ColorNotebook *cnb,
ColorNotebookState state,
gpointer data)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) data;
editor = (GimpGradientEditor *) data;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
switch (state)
{
@ -1156,7 +1176,7 @@ gradient_editor_left_color_changed (ColorNotebook *cnb,
gimp_gradient_segments_free (editor->left_saved_segments);
gimp_data_dirty (GIMP_DATA (gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
case COLOR_NOTEBOOK_UPDATE:
@ -1171,13 +1191,13 @@ gradient_editor_left_color_changed (ColorNotebook *cnb,
case COLOR_NOTEBOOK_CANCEL:
gradient_editor_replace_selection (editor, editor->left_saved_segments);
GIMP_DATA (gradient)->dirty = editor->left_saved_dirty;
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
}
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
static void
@ -1186,12 +1206,12 @@ gradient_editor_right_color_changed (ColorNotebook *cnb,
ColorNotebookState state,
gpointer data)
{
GradientEditor *editor;
GimpGradient *gradient;
GimpGradientEditor *editor;
GimpGradient *gradient;
editor = (GradientEditor *) data;
editor = (GimpGradientEditor *) data;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
switch (state)
{
@ -1213,22 +1233,22 @@ gradient_editor_right_color_changed (ColorNotebook *cnb,
gimp_gradient_segments_free (editor->right_saved_segments);
gimp_data_dirty (GIMP_DATA (gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
case COLOR_NOTEBOOK_CANCEL:
gradient_editor_replace_selection (editor, editor->right_saved_segments);
GIMP_DATA (gradient)->dirty = editor->right_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
break;
}
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
gimp_gradient_editor_update (editor, GRAD_UPDATE_GRADIENT);
}
static GimpGradientSegment *
gradient_editor_save_selection (GradientEditor *editor)
gradient_editor_save_selection (GimpGradientEditor *editor)
{
GimpGradientSegment *seg, *prev, *tmp;
GimpGradientSegment *oseg, *oaseg;
@ -1261,14 +1281,14 @@ gradient_editor_save_selection (GradientEditor *editor)
}
static void
gradient_editor_replace_selection (GradientEditor *editor,
gradient_editor_replace_selection (GimpGradientEditor *editor,
GimpGradientSegment *replace_seg)
{
GimpGradient *gradient;
GimpGradientSegment *lseg, *rseg;
GimpGradientSegment *replace_last;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
/* Remember left and right segments */
@ -1304,24 +1324,24 @@ gradient_editor_replace_selection (GradientEditor *editor,
}
static void
gradient_editor_dialog_cancel_callback (GtkWidget *widget,
GradientEditor *editor)
gradient_editor_dialog_cancel_callback (GtkWidget *widget,
GimpGradientEditor *editor)
{
gtk_widget_destroy (gtk_widget_get_toplevel (widget));
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
}
static void
gradient_editor_split_uniform_callback (GtkWidget *widget,
GradientEditor *editor)
gradient_editor_split_uniform_callback (GtkWidget *widget,
GimpGradientEditor *editor)
{
GimpGradient *gradient;
GimpGradientSegment *seg, *aseg, *lseg, *rseg, *lsel;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
gtk_widget_destroy (gtk_widget_get_toplevel (widget));
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
seg = editor->control_sel_l;
lsel = NULL;
@ -1345,12 +1365,13 @@ gradient_editor_split_uniform_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
static void
gradient_editor_replicate_callback (GtkWidget *widget,
GradientEditor *editor)
gradient_editor_replicate_callback (GtkWidget *widget,
GimpGradientEditor *editor)
{
GimpGradient *gradient;
gdouble sel_left, sel_right, sel_len;
@ -1361,10 +1382,10 @@ gradient_editor_replicate_callback (GtkWidget *widget,
GimpGradientSegment *lseg, *rseg;
gint i;
gradient = gimp_context_get_gradient (editor->context);
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
gtk_widget_destroy (gtk_widget_get_toplevel (widget));
gtk_widget_set_sensitive (editor->shell, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
/* Remember original parameters */
sel_left = editor->control_sel_l->left;
@ -1463,5 +1484,6 @@ gradient_editor_replicate_callback (GtkWidget *widget,
gimp_data_dirty (GIMP_DATA (gradient));
gradient_editor_update (editor, GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
gimp_gradient_editor_update (editor,
GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}

2081
app/gui/gradient-editor.c
View File

File diff suppressed because it is too large Load Diff

111
app/gui/gradient-editor.h
View File

@ -1,111 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Gradient editor module copyight (C) 1996-1997 Federico Mena Quintero
* federico@nuclecu.unam.mx
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GRADIENT_EDITOR_H__
#define __GRADIENT_EDITOR_H__
#define GRAD_NUM_COLORS 10
typedef enum
{
GRAD_DRAG_NONE = 0,
GRAD_DRAG_LEFT,
GRAD_DRAG_MIDDLE,
GRAD_DRAG_ALL
} GradientEditorDragMode;
typedef enum
{
GRAD_UPDATE_GRADIENT = 1 << 0,
GRAD_UPDATE_PREVIEW = 1 << 1,
GRAD_UPDATE_CONTROL = 1 << 2,
GRAD_RESET_CONTROL = 1 << 3
} GradientEditorUpdateMask;
struct _GradientEditor
{
GtkWidget *shell;
GtkWidget *name;
GtkWidget *hint_label;
GtkWidget *scrollbar;
GtkWidget *preview;
GtkWidget *control;
GimpContext *context;
/* Zoom and scrollbar */
guint zoom_factor;
GtkObject *scroll_data;
/* Instant update */
gboolean instant_update;
/* Gradient preview */
guchar *preview_rows[2]; /* For caching redraw info */
gint preview_last_x;
gboolean preview_button_down;
/* Gradient control */
GdkPixmap *control_pixmap;
GimpGradientSegment *control_drag_segment; /* Segment which is being dragged */
GimpGradientSegment *control_sel_l; /* Left segment of selection */
GimpGradientSegment *control_sel_r; /* Right segment of selection */
GradientEditorDragMode control_drag_mode; /* What is being dragged? */
guint32 control_click_time; /* Time when mouse was pressed */
gboolean control_compress; /* Compressing/expanding handles */
gint control_last_x; /* Last mouse position when dragging */
gdouble control_last_gx; /* Last position (wrt gradient) when dragging */
gdouble control_orig_pos; /* Original click position when dragging */
/* Split uniformly dialog */
gint split_parts;
/* Replicate dialog */
gint replicate_times;
/* Saved colors */
GimpRGB saved_colors[GRAD_NUM_COLORS];
/* Color dialogs */
GimpGradientSegment *left_saved_segments;
gboolean left_saved_dirty;
GimpGradientSegment *right_saved_segments;
gboolean right_saved_dirty;
};
GradientEditor * gradient_editor_new (Gimp *gimp);
void gradient_editor_set_gradient (GradientEditor *gradient_editor,
GimpGradient *gradient);
void gradient_editor_free (GradientEditor *gradient_editor);
void gradient_editor_update (GradientEditor *gradient_editor,
GradientEditorUpdateMask flags);
#endif /* __GRADIENT_EDITOR_H__ */

1
app/gui/gui-types.h
View File

@ -24,7 +24,6 @@
typedef struct _ColorNotebook ColorNotebook;
typedef struct _GradientEditor GradientEditor;
typedef struct _InfoDialog InfoDialog;
typedef struct _NavigationDialog NavigationDialog;

1258
app/gui/palette-editor.c
View File

File diff suppressed because it is too large Load Diff

45
app/gui/palette-editor.h
View File

@ -1,45 +0,0 @@
/* 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 __PALETTE_EDITOR_H__
#define __PALETTE_EDITOR_H__
typedef enum
{
GIMP_UPDATE_COLOR_STATE_NEW,
GIMP_UPDATE_COLOR_STATE_UPDATE_NEW,
GIMP_UPDATE_COLOR_STATE_UPDATE
} GimpUpdateColorState;
typedef struct _PaletteEditor PaletteEditor;
PaletteEditor * palette_editor_new (Gimp *gimp);
void palette_editor_set_palette (PaletteEditor *palette_editor,
GimpPalette *palette);
void palette_editor_free (PaletteEditor *palette_editor);
void palette_editor_update_color (GimpContext *context,
const GimpRGB *color,
GimpUpdateColorState state);
#endif /* __PALETTE_EDITOR_H__ */

2
app/gui/palette-select.c
View File

@ -35,9 +35,9 @@
#include "widgets/gimpdatafactoryview.h"
#include "widgets/gimpdnd.h"
#include "widgets/gimppaletteeditor.h"
#include "dialogs-constructors.h"
#include "palette-editor.h"
#include "palette-select.h"
#include "libgimp/gimpintl.h"

23
app/tools/gimpcolorpickertool.c
View File

@ -33,11 +33,12 @@
#include "core/gimpimage-pick-color.h"
#include "core/gimptoolinfo.h"
#include "display/gimpdisplay.h"
#include "widgets/gimppaletteeditor.h"
#include "gui/color-area.h"
#include "gui/info-dialog.h"
#include "gui/palette-editor.h"
#include "display/gimpdisplay.h"
#include "gimpdrawtool.h"
#include "gimpcolorpickertool.h"
@ -551,16 +552,18 @@ gimp_color_picker_tool_pick_color (GimpImage *gimage,
if (update_active)
{
palette_editor_update_color (gimp_get_user_context (gimage->gimp),
&color,
update_state);
GimpContext *user_context;
user_context = gimp_get_user_context (gimage->gimp);
#if 0
gimp_palette_editor_update_color (user_context, &color, update_state);
#endif
if (active_color == FOREGROUND)
gimp_context_set_foreground (gimp_get_user_context (gimage->gimp),
&color);
gimp_context_set_foreground (user_context, &color);
else if (active_color == BACKGROUND)
gimp_context_set_background (gimp_get_user_context (gimage->gimp),
&color);
gimp_context_set_background (user_context, &color);
}
return retval;

10
app/widgets/Makefile.am
View File

@ -4,6 +4,8 @@ noinst_LIBRARIES = libappwidgets.a
libappwidgets_a_SOURCES = @STRIP_BEGIN@ \
widgets-types.h \
gimpbrusheditor.c \
gimpbrusheditor.h \
gimpbrushfactoryview.c \
gimpbrushfactoryview.h \
gimpbrushpreview.c \
@ -36,6 +38,8 @@ libappwidgets_a_SOURCES = @STRIP_BEGIN@ \
gimpcontainerview-utils.h \
gimpcursor.c \
gimpcursor.h \
gimpdataeditor.c \
gimpdataeditor.h \
gimpdatafactoryview.c \
gimpdatafactoryview.h \
gimpdeviceinfo.c \
@ -60,10 +64,14 @@ libappwidgets_a_SOURCES = @STRIP_BEGIN@ \
gimpdrawablelistview.h \
gimpdrawablepreview.c \
gimpdrawablepreview.h \
gimpeditor.c \
gimpeditor.h \
gimpfontselection.c \
gimpfontselection.h \
gimpfontselection-dialog.c \
gimpfontselection-dialog.h \
gimpgradienteditor.c \
gimpgradienteditor.h \
gimpgradientpreview.c \
gimpgradientpreview.h \
gimphistogramview.c \
@ -90,6 +98,8 @@ libappwidgets_a_SOURCES = @STRIP_BEGIN@ \
gimpmenuitem.h \
gimpnavigationpreview.c \
gimpnavigationpreview.h \
gimppaletteeditor.c \
gimppaletteeditor.h \
gimppalettepreview.c \
gimppalettepreview.h \
gimppatternpreview.c \

558
app/widgets/gimpbrusheditor.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* brush-editor.c
* gimpbrusheditor.c
* Copyright 1998 Jay Cox <jaycox@earthlink.net>
*
* This program is free software; you can redistribute it and/or modify
@ -33,353 +33,329 @@
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "core/core-types.h"
#include "widgets-types.h"
#include "base/temp-buf.h"
#include "core/gimpbrushgenerated.h"
#include "brush-editor.h"
#include "gimpbrusheditor.h"
#include "libgimp/gimpintl.h"
struct _BrushEditor
/* local function prototypes */
static void gimp_brush_editor_class_init (GimpBrushEditorClass *klass);
static void gimp_brush_editor_init (GimpBrushEditor *editor);
static void gimp_brush_editor_set_data (GimpDataEditor *editor,
GimpData *data);
static void gimp_brush_editor_update_brush (GtkAdjustment *adjustment,
GimpBrushEditor *editor);
static void gimp_brush_editor_preview_resize (GtkWidget *widget,
GtkAllocation *allocation,
GimpBrushEditor *editor);
static void gimp_brush_editor_clear_preview (GimpBrushEditor *editor);
static void gimp_brush_editor_brush_dirty (GimpBrush *brush,
GimpBrushEditor *editor);
static GimpDataEditorClass *parent_class = NULL;
GType
gimp_brush_editor_get_type (void)
{
GtkWidget *shell;
GtkWidget *frame;
GtkWidget *preview;
GtkWidget *scale_label;
GtkWidget *options_box;
GtkWidget *name;
GtkAdjustment *radius_data;
GtkAdjustment *hardness_data;
GtkAdjustment *angle_data;
GtkAdjustment *aspect_ratio_data;
static GType type = 0;
/* Brush preview */
GtkWidget *brush_preview;
GimpBrushGenerated *brush;
gint scale;
};
if (! type)
{
static const GTypeInfo info =
{
sizeof (GimpBrushEditorClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_brush_editor_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpBrushEditor),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_brush_editor_init,
};
type = g_type_register_static (GIMP_TYPE_DATA_EDITOR,
"GimpBrushEditor",
&info, 0);
}
static void brush_editor_close_callback (GtkWidget *widget,
gpointer data);
static void brush_editor_name_activate (GtkWidget *widget,
BrushEditor *brush_editor);
static gboolean brush_editor_name_focus_out (GtkWidget *widget,
GdkEventFocus *fevent,
BrushEditor *brush_editor);
static void brush_editor_update_brush (GtkAdjustment *adjustment,
BrushEditor *brush_editor);
static void brush_editor_preview_resize (GtkWidget *widget,
GtkAllocation *allocation,
BrushEditor *brush_editor);
return type;
}
static void brush_editor_clear_preview (BrushEditor *brush_editor);
static void brush_editor_brush_dirty (GimpBrush *brush,
BrushEditor *brush_editor);
static void brush_editor_brush_name_changed (GtkWidget *widget,
BrushEditor *brush_editor);
static void
gimp_brush_editor_class_init (GimpBrushEditorClass *klass)
{
GimpDataEditorClass *editor_class;
editor_class = GIMP_DATA_EDITOR_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
editor_class->set_data = gimp_brush_editor_set_data;
}
static void
gimp_brush_editor_init (GimpBrushEditor *editor)
{
/* brush's preview widget w/frame */
editor->frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (editor->frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (editor), editor->frame,
TRUE, TRUE, 0);
gtk_widget_show (editor->frame);
editor->preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
gtk_preview_size (GTK_PREVIEW (editor->preview), 125, 100);
/* Enable auto-resizing of the preview but ensure a minimal size */
gtk_widget_set_size_request (editor->preview, 125, 100);
gtk_preview_set_expand (GTK_PREVIEW (editor->preview), TRUE);
gtk_container_add (GTK_CONTAINER (editor->frame), editor->preview);
gtk_widget_show (editor->preview);
g_signal_connect_after (G_OBJECT (editor->frame), "size_allocate",
G_CALLBACK (gimp_brush_editor_preview_resize),
editor);
/* table for sliders/labels */
editor->scale_label = gtk_label_new ("-1:1");
gtk_box_pack_start (GTK_BOX (editor), editor->scale_label, FALSE, FALSE, 0);
gtk_widget_show (editor->scale_label);
editor->scale = -1;
/* table for sliders/labels */
editor->options_table = gtk_table_new (4, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (editor->options_table), 2);
gtk_table_set_col_spacings (GTK_TABLE (editor->options_table), 2);
gtk_box_pack_start (GTK_BOX (editor), editor->options_table, FALSE, FALSE, 0);
gtk_widget_show (editor->options_table);
/* brush radius scale */
editor->radius_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (editor->options_table),
0, 0,
_("Radius:"), -1, 50,
0.0, 1.0, 100.0, 0.1, 1.0, 1,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (G_OBJECT (editor->radius_data), "value_changed",
G_CALLBACK (gimp_brush_editor_update_brush),
editor);
/* brush hardness scale */
editor->hardness_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (editor->options_table),
0, 1,
_("Hardness:"), -1, 50,
0.0, 0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (G_OBJECT (editor->hardness_data), "value_changed",
G_CALLBACK (gimp_brush_editor_update_brush),
editor);
/* brush aspect ratio scale */
editor->aspect_ratio_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (editor->options_table),
0, 2,
_("Aspect Ratio:"), -1, 50,
0.0, 1.0, 20.0, 0.1, 1.0, 1,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (G_OBJECT (editor->aspect_ratio_data),"value_changed",
G_CALLBACK (gimp_brush_editor_update_brush),
editor);
/* brush angle scale */
editor->angle_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (editor->options_table),
0, 3,
_("Angle:"), -1, 50,
0.0, 0.0, 180.0, 0.1, 1.0, 1,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (G_OBJECT (editor->angle_data), "value_changed",
G_CALLBACK (gimp_brush_editor_update_brush),
editor);
}
static void
gimp_brush_editor_set_data (GimpDataEditor *editor,
GimpData *data)
{
GimpBrushEditor *brush_editor;
brush_editor = GIMP_BRUSH_EDITOR (editor);
if (editor->data)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (editor->data),
gimp_brush_editor_brush_dirty,
editor);
}
GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data);
if (editor->data)
{
gdouble radius = 0.0;
gdouble hardness = 0.0;
gdouble angle = 0.0;
gdouble ratio = 0.0;
g_signal_connect (G_OBJECT (editor->data), "invalidate_preview",
G_CALLBACK (gimp_brush_editor_brush_dirty),
editor);
if (GIMP_IS_BRUSH_GENERATED (editor->data))
{
GimpBrushGenerated *brush;
brush = GIMP_BRUSH_GENERATED (editor->data);
radius = gimp_brush_generated_get_radius (brush);
hardness = gimp_brush_generated_get_hardness (brush);
angle = gimp_brush_generated_get_angle (brush);
ratio = gimp_brush_generated_get_aspect_ratio (brush);
gtk_widget_set_sensitive (brush_editor->options_table, TRUE);
}
else
{
gtk_widget_set_sensitive (brush_editor->options_table, FALSE);
}
gtk_adjustment_set_value (brush_editor->radius_data, radius);
gtk_adjustment_set_value (brush_editor->hardness_data, hardness);
gtk_adjustment_set_value (brush_editor->angle_data, angle);
gtk_adjustment_set_value (brush_editor->aspect_ratio_data, ratio);
gimp_brush_editor_brush_dirty (GIMP_BRUSH (editor->data), brush_editor);
}
}
/* public functions */
BrushEditor *
brush_editor_new (Gimp *gimp)
GimpDataEditor *
gimp_brush_editor_new (Gimp *gimp)
{
BrushEditor *brush_editor;
GtkWidget *vbox;
GtkWidget *slider;
GtkWidget *table;
GimpBrushEditor *brush_editor;
brush_editor = g_new0 (BrushEditor, 1);
brush_editor = g_object_new (GIMP_TYPE_BRUSH_EDITOR, NULL);
brush_editor->shell =
gimp_dialog_new (_("Brush Editor"), "generated_brush_editor",
gimp_standard_help_func,
"dialogs/brush_editor.html",
GTK_WIN_POS_NONE,
FALSE, TRUE, FALSE,
gimp_data_editor_construct (GIMP_DATA_EDITOR (brush_editor),
gimp,
GIMP_TYPE_BRUSH);
"_delete_event_", brush_editor_close_callback,
brush_editor, NULL, NULL, TRUE, TRUE,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (brush_editor->shell), FALSE);
gtk_widget_hide (GTK_DIALOG (brush_editor->shell)->action_area);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (brush_editor->shell)->vbox),
vbox);
/* Brush's name */
brush_editor->name = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), brush_editor->name, FALSE, FALSE, 0);
gtk_widget_show (brush_editor->name);
g_signal_connect (G_OBJECT (brush_editor->name), "activate",
G_CALLBACK (brush_editor_name_activate),
brush_editor);
g_signal_connect (G_OBJECT (brush_editor->name), "focus_out_event",
G_CALLBACK (brush_editor_name_focus_out),
brush_editor);
/* brush's preview widget w/frame */
brush_editor->frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (brush_editor->frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), brush_editor->frame, TRUE, TRUE, 0);
gtk_widget_show (brush_editor->frame);
brush_editor->preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
gtk_preview_size (GTK_PREVIEW (brush_editor->preview), 125, 100);
/* Enable auto-resizing of the preview but ensure a minimal size */
gtk_widget_set_size_request (brush_editor->preview, 125, 100);
gtk_preview_set_expand (GTK_PREVIEW (brush_editor->preview), TRUE);
gtk_container_add (GTK_CONTAINER (brush_editor->frame), brush_editor->preview);
gtk_widget_show (brush_editor->preview);
g_signal_connect_after (G_OBJECT (brush_editor->frame), "size_allocate",
G_CALLBACK (brush_editor_preview_resize),
brush_editor);
/* table for sliders/labels */
brush_editor->scale_label = gtk_label_new ("-1:1");
gtk_box_pack_start (GTK_BOX (vbox), brush_editor->scale_label,
FALSE, FALSE, 0);
gtk_widget_show (brush_editor->scale_label);
brush_editor->scale = -1;
/* table for sliders/labels */
table = gtk_table_new (4, 2, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
/* brush radius scale */
brush_editor->radius_data =
GTK_ADJUSTMENT (gtk_adjustment_new (10.0, 0.0, 100.0, 0.1, 1.0, 0.0));
slider = gtk_hscale_new (brush_editor->radius_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->radius_data), "value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Radius:"), 1.0, 1.0,
slider, 1, FALSE);
/* brush hardness scale */
brush_editor->hardness_data =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1.0, 0.01, 0.01, 0.0));
slider = gtk_hscale_new (brush_editor->hardness_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->hardness_data), "value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Hardness:"), 1.0, 1.0,
slider, 1, FALSE);
/* brush aspect ratio scale */
brush_editor->aspect_ratio_data =
GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 1.0, 20.0, 0.1, 1.0, 0.0));
slider = gtk_hscale_new (brush_editor->aspect_ratio_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->aspect_ratio_data),"value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Aspect Ratio:"), 1.0, 1.0,
slider, 1, FALSE);
/* brush angle scale */
brush_editor->angle_data =
GTK_ADJUSTMENT (gtk_adjustment_new (00.0, 0.0, 180.0, 0.1, 1.0, 0.0));
slider = gtk_hscale_new (brush_editor->angle_data);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
g_signal_connect (G_OBJECT (brush_editor->angle_data), "value_changed",
G_CALLBACK (brush_editor_update_brush),
brush_editor);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("Angle:"), 1.0, 1.0,
slider, 1, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 3);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
gtk_widget_show (table);
gtk_widget_show (vbox);
gtk_widget_show (brush_editor->shell);
return brush_editor;
}
void
brush_editor_set_brush (BrushEditor *brush_editor,
GimpBrush *gbrush)
{
GimpBrushGenerated *brush = NULL;
g_return_if_fail (brush_editor != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (gbrush));
if (brush_editor->brush)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (brush_editor->brush),
brush_editor_brush_dirty,
brush_editor);
g_signal_handlers_disconnect_by_func (G_OBJECT (brush_editor->brush),
brush_editor_brush_name_changed,
brush_editor);
g_object_unref (G_OBJECT (brush_editor->brush));
brush_editor->brush = NULL;
}
brush = GIMP_BRUSH_GENERATED (gbrush);
g_signal_connect (G_OBJECT (brush), "invalidate_preview",
G_CALLBACK (brush_editor_brush_dirty),
brush_editor);
g_signal_connect (G_OBJECT (brush), "name_changed",
G_CALLBACK (brush_editor_brush_name_changed),
brush_editor);
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->radius_data),
gimp_brush_generated_get_radius (brush));
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->hardness_data),
gimp_brush_generated_get_hardness (brush));
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->angle_data),
gimp_brush_generated_get_angle (brush));
gtk_adjustment_set_value (GTK_ADJUSTMENT (brush_editor->aspect_ratio_data),
gimp_brush_generated_get_aspect_ratio (brush));
gtk_entry_set_text (GTK_ENTRY (brush_editor->name),
gimp_object_get_name (GIMP_OBJECT (gbrush)));
brush_editor->brush = brush;
g_object_ref (G_OBJECT (brush_editor->brush));
brush_editor_brush_dirty (GIMP_BRUSH (brush), brush_editor);
return GIMP_DATA_EDITOR (brush_editor);
}
/* private functions */
static void
brush_editor_close_callback (GtkWidget *widget,
gpointer data)
gimp_brush_editor_update_brush (GtkAdjustment *adjustment,
GimpBrushEditor *editor)
{
BrushEditor *brush_editor = (BrushEditor *) data;
GimpBrushGenerated *brush = NULL;
if (GTK_WIDGET_VISIBLE (brush_editor->shell))
gtk_widget_hide (brush_editor->shell);
}
if (GIMP_IS_BRUSH_GENERATED (GIMP_DATA_EDITOR (editor)->data))
brush = GIMP_BRUSH_GENERATED (GIMP_DATA_EDITOR (editor)->data);
static void
brush_editor_name_activate (GtkWidget *widget,
BrushEditor *brush_editor)
{
const gchar *entry_text;
entry_text = gtk_entry_get_text (GTK_ENTRY (widget));
gimp_object_set_name (GIMP_OBJECT (brush_editor->brush), entry_text);
}
static gboolean
brush_editor_name_focus_out (GtkWidget *widget,
GdkEventFocus *fevent,
BrushEditor *brush_editor)
{
brush_editor_name_activate (widget, brush_editor);
return FALSE;
}
static void
brush_editor_update_brush (GtkAdjustment *adjustment,
BrushEditor *brush_editor)
{
if (brush_editor->brush &&
((brush_editor->radius_data->value
!= gimp_brush_generated_get_radius (brush_editor->brush))
|| (brush_editor->hardness_data->value
!= gimp_brush_generated_get_hardness (brush_editor->brush))
|| (brush_editor->aspect_ratio_data->value
!= gimp_brush_generated_get_aspect_ratio (brush_editor->brush))
|| (brush_editor->angle_data->value
!= gimp_brush_generated_get_angle (brush_editor->brush))))
if (brush &&
((editor->radius_data->value
!= gimp_brush_generated_get_radius (brush))
|| (editor->hardness_data->value
!= gimp_brush_generated_get_hardness (brush))
|| (editor->aspect_ratio_data->value
!= gimp_brush_generated_get_aspect_ratio (brush))
|| (editor->angle_data->value
!= gimp_brush_generated_get_angle (brush))))
{
gimp_brush_generated_freeze (brush_editor->brush);
gimp_brush_generated_set_radius (brush_editor->brush,
brush_editor->radius_data->value);
gimp_brush_generated_set_hardness (brush_editor->brush,
brush_editor->hardness_data->value);
gimp_brush_generated_set_aspect_ratio (brush_editor->brush,
brush_editor->aspect_ratio_data->value);
gimp_brush_generated_set_angle (brush_editor->brush,
brush_editor->angle_data->value);
gimp_brush_generated_thaw (brush_editor->brush);
gimp_brush_generated_freeze (brush);
gimp_brush_generated_set_radius (brush,
editor->radius_data->value);
gimp_brush_generated_set_hardness (brush,
editor->hardness_data->value);
gimp_brush_generated_set_aspect_ratio (brush,
editor->aspect_ratio_data->value);
gimp_brush_generated_set_angle (brush,
editor->angle_data->value);
gimp_brush_generated_thaw (brush);
}
}
static void
brush_editor_preview_resize (GtkWidget *widget,
GtkAllocation *allocation,
BrushEditor *brush_editor)
gimp_brush_editor_preview_resize (GtkWidget *widget,
GtkAllocation *allocation,
GimpBrushEditor *editor)
{
if (brush_editor->brush)
brush_editor_brush_dirty (GIMP_BRUSH (brush_editor->brush), brush_editor);
if (GIMP_DATA_EDITOR (editor)->data)
gimp_brush_editor_brush_dirty (GIMP_BRUSH (GIMP_DATA_EDITOR (editor)->data),
editor);
}
static void
brush_editor_clear_preview (BrushEditor *brush_editor)
gimp_brush_editor_clear_preview (GimpBrushEditor *editor)
{
guchar *buf;
gint i;
buf = g_new (guchar, brush_editor->preview->allocation.width);
buf = g_new (guchar, editor->preview->allocation.width);
/* Set the buffer to white */
memset (buf, 255, brush_editor->preview->allocation.width);
memset (buf, 255, editor->preview->allocation.width);
/* Set the image buffer to white */
for (i = 0; i < brush_editor->preview->allocation.height; i++)
gtk_preview_draw_row (GTK_PREVIEW (brush_editor->preview), buf, 0, i,
brush_editor->preview->allocation.width);
for (i = 0; i < editor->preview->allocation.height; i++)
gtk_preview_draw_row (GTK_PREVIEW (editor->preview), buf, 0, i,
editor->preview->allocation.width);
g_free (buf);
}
static void
brush_editor_brush_dirty (GimpBrush *brush,
BrushEditor *brush_editor)
gimp_brush_editor_brush_dirty (GimpBrush *brush,
GimpBrushEditor *editor)
{
gint x, y, width, yend, ystart, xo;
gint scale;
guchar *src, *buf;
brush_editor_clear_preview (brush_editor);
gimp_brush_editor_clear_preview (editor);
if (brush == NULL || brush->mask == NULL)
if (! (brush && brush->mask))
return;
scale = MAX (ceil (brush->mask->width/
(float) brush_editor->preview->allocation.width),
(float) editor->preview->allocation.width),
ceil (brush->mask->height/
(float) brush_editor->preview->allocation.height));
(float) editor->preview->allocation.height));
ystart = 0;
xo = brush_editor->preview->allocation.width / 2 - brush->mask->width / (2 * scale);
ystart = brush_editor->preview->allocation.height / 2 - brush->mask->height / (2 * scale);
xo = editor->preview->allocation.width / 2 - brush->mask->width / (2 * scale);
ystart = editor->preview->allocation.height / 2 - brush->mask->height / (2 * scale);
yend = ystart + brush->mask->height / scale;
width = CLAMP (brush->mask->width/scale, 0, brush_editor->preview->allocation.width);
width = CLAMP (brush->mask->width/scale, 0, editor->preview->allocation.width);
buf = g_new (guchar, width);
src = (guchar *) temp_buf_data (brush->mask);
@ -391,7 +367,7 @@ brush_editor_brush_dirty (GimpBrush *brush,
for (x = 0; x < width; x++)
buf[x] = 255 - src[x * scale];
gtk_preview_draw_row (GTK_PREVIEW (brush_editor->preview), buf,
gtk_preview_draw_row (GTK_PREVIEW (editor->preview), buf,
xo, y, width);
src += brush->mask->width * scale;
@ -399,22 +375,14 @@ brush_editor_brush_dirty (GimpBrush *brush,
g_free (buf);
if (brush_editor->scale != scale)
if (editor->scale != scale)
{
gchar str[255];
brush_editor->scale = scale;
editor->scale = scale;
g_snprintf (str, sizeof (str), "%d:1", scale);
gtk_label_set_text (GTK_LABEL (brush_editor->scale_label), str);
gtk_label_set_text (GTK_LABEL (editor->scale_label), str);
}
gtk_widget_queue_draw (brush_editor->preview);
}
static void
brush_editor_brush_name_changed (GtkWidget *widget,
BrushEditor *brush_editor)
{
gtk_entry_set_text (GTK_ENTRY (brush_editor->name),
gimp_object_get_name (GIMP_OBJECT (brush_editor->brush)));
gtk_widget_queue_draw (editor->preview);
}

52
app/widgets/gimpbrusheditor.h
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* brush-editor.h
* gimpbrusheditor.h
* Copyright 1998 Jay Cox <jaycox@earthlink.net>
*
* This program is free software; you can redistribute it and/or modify
@ -19,18 +19,50 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __BRUSH_EDITOR_H__
#define __BRUSH_EDITOR_H__
#ifndef __GIMP_BRUSH_EDITOR_H__
#define __GIMP_BRUSH_EDITOR_H__
typedef struct _BrushEditor BrushEditor;
#include "gimpdataeditor.h"
BrushEditor * brush_editor_new (Gimp *gimp);
void brush_editor_set_brush (BrushEditor *brush_editor,
GimpBrush *brush);
void brush_editor_free (BrushEditor *brush_editor);
#define GIMP_TYPE_BRUSH_EDITOR (gimp_brush_editor_get_type ())
#define GIMP_BRUSH_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BRUSH_EDITOR, GimpBrushEditor))
#define GIMP_BRUSH_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_EDITOR, GimpBrushEditorClass))
#define GIMP_IS_BRUSH_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BRUSH_EDITOR))
#define GIMP_IS_BRUSH_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_EDITOR))
#define GIMP_BRUSH_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_BRUSH_EDITOR, GimpBrushEditorClass))
#endif /* __BRUSH_EDITOR_H__ */
typedef struct _GimpBrushEditorClass GimpBrushEditorClass;
struct _GimpBrushEditor
{
GimpDataEditor parent_instance;
GtkWidget *frame;
GtkWidget *preview;
GtkWidget *scale_label;
GtkWidget *options_table;
GtkAdjustment *radius_data;
GtkAdjustment *hardness_data;
GtkAdjustment *angle_data;
GtkAdjustment *aspect_ratio_data;
/* Brush preview */
GtkWidget *brush_preview;
GimpBrushGenerated *brush;
gint scale;
};
struct _GimpBrushEditorClass
{
GimpDataEditorClass parent_class;
};
GimpDataEditor * gimp_brush_editor_new (Gimp *gimp);
#endif /* __GIMP_BRUSH_EDITOR_H__ */

6
app/widgets/gimpbrushfactoryview.c
View File

@ -107,7 +107,6 @@ gimp_brush_factory_view_init (GimpBrushFactoryView *view)
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
gtk_box_pack_end (GTK_BOX (view), table, FALSE, FALSE, 0);
gtk_widget_show (table);
view->spacing_adjustment =
@ -186,6 +185,11 @@ gimp_brush_factory_view_new (GimpViewType view_type,
editor = GIMP_CONTAINER_EDITOR (factory_view);
/* eek */
gtk_box_pack_end (GTK_BOX (editor->view),
factory_view->spacing_scale->parent,
FALSE, FALSE, 0);
factory_view->spacing_changed_handler_id =
gimp_container_add_handler (editor->view->container, "spacing_changed",
G_CALLBACK (gimp_brush_factory_view_spacing_changed),

48
app/widgets/gimpbufferview.c
View File

@ -144,36 +144,36 @@ gimp_buffer_view_new (GimpViewType view_type,
editor = GIMP_CONTAINER_EDITOR (buffer_view);
buffer_view->paste_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_PASTE,
_("Paste"), NULL,
G_CALLBACK (gimp_buffer_view_paste_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_PASTE,
_("Paste"), NULL,
G_CALLBACK (gimp_buffer_view_paste_clicked),
NULL,
editor);
buffer_view->paste_into_button =
gimp_container_view_add_button (editor->view,
GIMP_STOCK_PASTE_INTO,
_("Paste Into"), NULL,
G_CALLBACK (gimp_buffer_view_paste_into_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GIMP_STOCK_PASTE_INTO,
_("Paste Into"), NULL,
G_CALLBACK (gimp_buffer_view_paste_into_clicked),
NULL,
editor);
buffer_view->paste_as_new_button =
gimp_container_view_add_button (editor->view,
GIMP_STOCK_PASTE_AS_NEW,
_("Paste as New"), NULL,
G_CALLBACK (gimp_buffer_view_paste_as_new_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GIMP_STOCK_PASTE_AS_NEW,
_("Paste as New"), NULL,
G_CALLBACK (gimp_buffer_view_paste_as_new_clicked),
NULL,
editor);
buffer_view->delete_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_buffer_view_delete_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_buffer_view_delete_clicked),
NULL,
editor);
/* set button sensitivity */
if (GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item)

22
app/widgets/gimpchannellistview.c
View File

@ -169,17 +169,17 @@ gimp_channel_list_view_init (GimpChannelListView *view)
/* To Selection button */
view->toselection_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_SELECTION_REPLACE,
_("Channel to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_channel_list_view_toselection_clicked),
G_CALLBACK (gimp_channel_list_view_toselection_extended_clicked),
view);
gimp_editor_add_button (GIMP_EDITOR (container_view),
GIMP_STOCK_SELECTION_REPLACE,
_("Channel to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_channel_list_view_toselection_clicked),
G_CALLBACK (gimp_channel_list_view_toselection_extended_clicked),
view);
gtk_box_reorder_child (GTK_BOX (container_view->button_box),
gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (container_view)->button_box),
view->toselection_button, 5);
gimp_container_view_enable_dnd (container_view,
@ -259,7 +259,7 @@ gimp_channel_list_view_select_item (GimpContainerView *view,
floating_sel = (gimp_image_floating_sel (item_view->gimage) != NULL);
gtk_widget_set_sensitive (view->button_box, !floating_sel);
gtk_widget_set_sensitive (GIMP_EDITOR (view)->button_box, ! floating_sel);
}
gtk_widget_set_sensitive (list_view->toselection_button, item != NULL);

22
app/widgets/gimpchanneltreeview.c
View File

@ -169,17 +169,17 @@ gimp_channel_list_view_init (GimpChannelListView *view)
/* To Selection button */
view->toselection_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_SELECTION_REPLACE,
_("Channel to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_channel_list_view_toselection_clicked),
G_CALLBACK (gimp_channel_list_view_toselection_extended_clicked),
view);
gimp_editor_add_button (GIMP_EDITOR (container_view),
GIMP_STOCK_SELECTION_REPLACE,
_("Channel to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_channel_list_view_toselection_clicked),
G_CALLBACK (gimp_channel_list_view_toselection_extended_clicked),
view);
gtk_box_reorder_child (GTK_BOX (container_view->button_box),
gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (container_view)->button_box),
view->toselection_button, 5);
gimp_container_view_enable_dnd (container_view,
@ -259,7 +259,7 @@ gimp_channel_list_view_select_item (GimpContainerView *view,
floating_sel = (gimp_image_floating_sel (item_view->gimage) != NULL);
gtk_widget_set_sensitive (view->button_box, !floating_sel);
gtk_widget_set_sensitive (GIMP_EDITOR (view)->button_box, ! floating_sel);
}
gtk_widget_set_sensitive (list_view->toselection_button, item != NULL);

99
app/widgets/gimpcontainerview.c
View File

@ -50,8 +50,6 @@ static void gimp_container_view_class_init (GimpContainerViewClass *klass);
static void gimp_container_view_init (GimpContainerView *panel);
static void gimp_container_view_destroy (GtkObject *object);
static void gimp_container_view_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_container_view_real_set_container (GimpContainerView *view,
GimpContainer *container);
@ -85,7 +83,7 @@ static void gimp_container_view_button_viewable_dropped (GtkWidget *widget,
static guint view_signals[LAST_SIGNAL] = { 0 };
static GtkVBoxClass *parent_class = NULL;
static GimpEditorClass *parent_class = NULL;
GType
@ -108,7 +106,7 @@ gimp_container_view_get_type (void)
(GInstanceInitFunc) gimp_container_view_init,
};
view_type = g_type_register_static (GTK_TYPE_VBOX,
view_type = g_type_register_static (GIMP_TYPE_EDITOR,
"GimpContainerView",
&view_info, 0);
}
@ -120,10 +118,8 @@ static void
gimp_container_view_class_init (GimpContainerViewClass *klass)
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
object_class = GTK_OBJECT_CLASS (klass);
widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
@ -162,8 +158,6 @@ gimp_container_view_class_init (GimpContainerViewClass *klass)
object_class->destroy = gimp_container_view_destroy;
widget_class->style_set = gimp_container_view_style_set;
klass->select_item = NULL;
klass->activate_item = NULL;
klass->context_item = NULL;
@ -174,22 +168,6 @@ gimp_container_view_class_init (GimpContainerViewClass *klass)
klass->reorder_item = NULL;
klass->clear_items = gimp_container_view_real_clear_items;
klass->set_preview_size = NULL;
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("content_spacing",
NULL, NULL,
0,
G_MAXINT,
0,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("button_spacing",
NULL, NULL,
0,
G_MAXINT,
0,
G_PARAM_READABLE));
}
static void
@ -205,7 +183,6 @@ gimp_container_view_init (GimpContainerView *view)
view->get_name_func = NULL;
view->button_box = NULL;
view->dnd_widget = NULL;
}
@ -232,32 +209,6 @@ gimp_container_view_destroy (GtkObject *object)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
gimp_container_view_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpContainerView *view;
gint content_spacing;
gint button_spacing;
view = GIMP_CONTAINER_VIEW (widget);
gtk_widget_style_get (widget,
"content_spacing", &content_spacing,
"button_spacing", &button_spacing,
NULL);
gtk_box_set_spacing (GTK_BOX (widget), content_spacing);
if (view->button_box)
{
gtk_box_set_spacing (GTK_BOX (view->button_box), button_spacing);
}
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
}
void
gimp_container_view_set_container (GimpContainerView *view,
GimpContainer *container)
@ -468,52 +419,6 @@ gimp_container_view_set_name_func (GimpContainerView *view,
}
}
GtkWidget *
gimp_container_view_add_button (GimpContainerView *view,
const gchar *stock_id,
const gchar *tooltip,
const gchar *help_data,
GCallback callback,
GCallback extended_callback,
gpointer callback_data)
{
GtkWidget *button;
GtkWidget *image;
g_return_val_if_fail (GIMP_IS_CONTAINER_VIEW (view), NULL);
g_return_val_if_fail (stock_id != NULL, NULL);
if (! view->button_box)
{
view->button_box = gtk_hbox_new (TRUE, 2);
gtk_box_pack_end (GTK_BOX (view), view->button_box, FALSE, FALSE, 0);
gtk_widget_show (view->button_box);
}
button = gimp_button_new ();
gtk_box_pack_start (GTK_BOX (view->button_box), button, TRUE, TRUE, 0);
gtk_widget_show (button);
if (tooltip || help_data)
gimp_help_set_help_data (button, tooltip, help_data);
if (callback)
g_signal_connect (G_OBJECT (button), "clicked",
callback,
callback_data);
if (extended_callback)
g_signal_connect (G_OBJECT (button), "extended_clicked",
extended_callback,
callback_data);
image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_show (image);
return button;
}
void
gimp_container_view_enable_dnd (GimpContainerView *view,
GtkButton *button,

15
app/widgets/gimpcontainerview.h
View File

@ -23,7 +23,7 @@
#define __GIMP_CONTAINER_VIEW_H__
#include <gtk/gtkvbox.h>
#include "gimpeditor.h"
#define GIMP_TYPE_CONTAINER_VIEW (gimp_container_view_get_type ())
@ -38,7 +38,7 @@ typedef struct _GimpContainerViewClass GimpContainerViewClass;
struct _GimpContainerView
{
GtkVBox parent_instance;
GimpEditor parent_instance;
GimpContainer *container;
GimpContext *context;
@ -50,15 +50,13 @@ struct _GimpContainerView
GimpItemGetNameFunc get_name_func;
GtkWidget *button_box;
/* initialized by subclass */
GtkWidget *dnd_widget;
};
struct _GimpContainerViewClass
{
GtkVBoxClass parent_class;
GimpEditorClass parent_class;
/* signals */
void (* select_item) (GimpContainerView *view,
@ -100,13 +98,6 @@ void gimp_container_view_set_preview_size (GimpContainerView *view,
void gimp_container_view_set_name_func (GimpContainerView *view,
GimpItemGetNameFunc get_name_func);
GtkWidget * gimp_container_view_add_button (GimpContainerView *editor,
const gchar *stock_id,
const gchar *tooltip,
const gchar *help_data,
GCallback callback,
GCallback extended_callback,
gpointer callback_data);
void gimp_container_view_enable_dnd (GimpContainerView *editor,
GtkButton *button,
GType children_type);

282
app/widgets/gimpdataeditor.c Normal file
View File

@ -0,0 +1,282 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdataeditor.c
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
*
* 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 <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpdata.h"
#include "gimpdataeditor.h"
#include "libgimp/gimpintl.h"
static void gimp_data_editor_class_init (GimpDataEditorClass *klass);
static void gimp_data_editor_init (GimpDataEditor *view);
static void gimp_data_editor_dispose (GObject *object);
static void gimp_data_editor_real_set_data (GimpDataEditor *editor,
GimpData *data);
static void gimp_data_editor_name_activate (GtkWidget *widget,
GimpDataEditor *editor);
static gboolean gimp_data_editor_name_focus_out (GtkWidget *widget,
GdkEvent *event,
GimpDataEditor *editor);
static void gimp_data_editor_data_name_changed (GimpObject *object,
GimpDataEditor *editor);
static void gimp_data_editor_save_clicked (GtkWidget *widget,
GimpDataEditor *editor);
static void gimp_data_editor_revert_clicked (GtkWidget *widget,
GimpDataEditor *editor);
static GimpEditorClass *parent_class = NULL;
GType
gimp_data_editor_get_type (void)
{
static GType view_type = 0;
if (! view_type)
{
static const GTypeInfo view_info =
{
sizeof (GimpDataEditorClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_data_editor_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpDataEditor),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_data_editor_init,
};
view_type = g_type_register_static (GIMP_TYPE_EDITOR,
"GimpDataEditor",
&view_info, 0);
}
return view_type;
}
static void
gimp_data_editor_class_init (GimpDataEditorClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->dispose = gimp_data_editor_dispose;
klass->set_data = gimp_data_editor_real_set_data;
}
static void
gimp_data_editor_init (GimpDataEditor *editor)
{
editor->data_type = G_TYPE_NONE;
editor->data = NULL;
editor->name_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (editor), editor->name_entry,
FALSE, FALSE, 0);
gtk_widget_show (editor->name_entry);
g_signal_connect (G_OBJECT (editor->name_entry), "activate",
G_CALLBACK (gimp_data_editor_name_activate),
editor);
g_signal_connect (G_OBJECT (editor->name_entry), "focus_out_event",
G_CALLBACK (gimp_data_editor_name_focus_out),
editor);
editor->save_button =
gimp_editor_add_button (GIMP_EDITOR (editor),
GTK_STOCK_SAVE,
_("Save"), NULL,
G_CALLBACK (gimp_data_editor_save_clicked),
NULL,
editor);
editor->revert_button =
gimp_editor_add_button (GIMP_EDITOR (editor),
GTK_STOCK_REVERT_TO_SAVED,
_("Revert"), NULL,
G_CALLBACK (gimp_data_editor_revert_clicked),
NULL,
editor);
}
static void
gimp_data_editor_dispose (GObject *object)
{
GimpDataEditor *editor;
editor = GIMP_DATA_EDITOR (object);
if (editor->data)
gimp_data_editor_set_data (editor, NULL);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_data_editor_real_set_data (GimpDataEditor *editor,
GimpData *data)
{
const gchar *name = NULL;
if (editor->data)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (editor->data),
gimp_data_editor_data_name_changed,
editor);
g_object_unref (G_OBJECT (editor->data));
}
editor->data = data;
if (editor->data)
{
g_object_ref (G_OBJECT (editor->data));
g_signal_connect (G_OBJECT (editor->data), "name_changed",
G_CALLBACK (gimp_data_editor_data_name_changed),
editor);
name = gimp_object_get_name (GIMP_OBJECT (editor->data));
}
gtk_entry_set_text (GTK_ENTRY (editor->name_entry), name);
}
gboolean
gimp_data_editor_construct (GimpDataEditor *editor,
Gimp *gimp,
GType data_type)
{
GimpData *data;
g_return_val_if_fail (GIMP_IS_DATA_EDITOR (editor), FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (g_type_is_a (data_type, GIMP_TYPE_DATA), FALSE);
editor->gimp = gimp;
editor->data_type = data_type;
data = (GimpData *)
gimp_context_get_by_type (gimp_get_user_context (gimp), data_type);
gimp_data_editor_set_data (editor, data);
return TRUE;
}
void
gimp_data_editor_set_data (GimpDataEditor *editor,
GimpData *data)
{
g_return_if_fail (GIMP_IS_DATA_EDITOR (editor));
g_return_if_fail (! data || GIMP_IS_DATA (data));
g_return_if_fail (g_type_is_a (G_TYPE_FROM_INSTANCE (data),
editor->data_type));
if (editor->data != data)
{
GIMP_DATA_EDITOR_GET_CLASS (editor)->set_data (editor, data);
}
}
GimpData *
gimp_data_editor_get_data (GimpDataEditor *editor)
{
g_return_val_if_fail (GIMP_IS_DATA_EDITOR (editor), NULL);
return editor->data;
}
/* private functions */
static void
gimp_data_editor_name_activate (GtkWidget *widget,
GimpDataEditor *editor)
{
if (editor->data)
{
const gchar *entry_text;
entry_text = gtk_entry_get_text (GTK_ENTRY (widget));
gimp_object_set_name (GIMP_OBJECT (editor->data), entry_text);
}
}
static gboolean
gimp_data_editor_name_focus_out (GtkWidget *widget,
GdkEvent *event,
GimpDataEditor *editor)
{
gimp_data_editor_name_activate (widget, editor);
return FALSE;
}
static void
gimp_data_editor_data_name_changed (GimpObject *object,
GimpDataEditor *editor)
{
gtk_entry_set_text (GTK_ENTRY (editor->name_entry),
gimp_object_get_name (object));
}
static void
gimp_data_editor_save_clicked (GtkWidget *widget,
GimpDataEditor *editor)
{
/* TODO */
g_print ("Save clicked\n");
}
static void
gimp_data_editor_revert_clicked (GtkWidget *widget,
GimpDataEditor *editor)
{
/* TODO */
g_print ("Revert clicked\n");
}

76
app/widgets/gimpdataeditor.h Normal file
View File

@ -0,0 +1,76 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdataeditor.h
* Copyright (C) 2002 Michael Natterer <mitch@gimp.org>
*
* 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_EDITOR_H__
#define __GIMP_DATA_EDITOR_H__
#include "gimpeditor.h"
#define GIMP_TYPE_DATA_EDITOR (gimp_data_editor_get_type ())
#define GIMP_DATA_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DATA_EDITOR, GimpDataEditor))
#define GIMP_DATA_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA_EDITOR, GimpDataEditorClass))
#define GIMP_IS_DATA_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DATA_EDITOR))
#define GIMP_IS_DATA_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA_EDITOR))
#define GIMP_DATA_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DATA_EDITOR, GimpDataEditorClass))
typedef struct _GimpDataEditorClass GimpDataEditorClass;
struct _GimpDataEditor
{
GimpEditor parent_instance;
Gimp *gimp;
GType data_type;
GimpData *data;
GtkWidget *name_entry;
GtkWidget *save_button;
GtkWidget *revert_button;
};
struct _GimpDataEditorClass
{
GimpEditorClass parent_class;
/* virtual functions */
void (* set_data) (GimpDataEditor *editor,
GimpData *data);
};
GType gimp_data_editor_get_type (void) G_GNUC_CONST;
gboolean gimp_data_editor_construct (GimpDataEditor *editor,
Gimp *gimp,
GType data_type);
void gimp_data_editor_set_data (GimpDataEditor *editor,
GimpData *data);
GimpData * gimp_data_editor_get_data (GimpDataEditor *editor);
#endif /* __GIMP_DATA_EDITOR_H__ */

60
app/widgets/gimpdatafactoryview.c
View File

@ -190,44 +190,44 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
editor = GIMP_CONTAINER_EDITOR (factory_view);
factory_view->new_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_NEW,
_("New"), NULL,
G_CALLBACK (gimp_data_factory_view_new_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_NEW,
_("New"), NULL,
G_CALLBACK (gimp_data_factory_view_new_clicked),
NULL,
editor);
factory_view->duplicate_button =
gimp_container_view_add_button (editor->view,
GIMP_STOCK_DUPLICATE,
_("Duplicate"), NULL,
G_CALLBACK (gimp_data_factory_view_duplicate_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GIMP_STOCK_DUPLICATE,
_("Duplicate"), NULL,
G_CALLBACK (gimp_data_factory_view_duplicate_clicked),
NULL,
editor);
factory_view->edit_button =
gimp_container_view_add_button (editor->view,
GIMP_STOCK_EDIT,
_("Edit"), NULL,
G_CALLBACK (gimp_data_factory_view_edit_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GIMP_STOCK_EDIT,
_("Edit"), NULL,
G_CALLBACK (gimp_data_factory_view_edit_clicked),
NULL,
editor);
factory_view->delete_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_data_factory_view_delete_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_data_factory_view_delete_clicked),
NULL,
editor);
factory_view->refresh_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_REFRESH,
_("Refresh"), NULL,
G_CALLBACK (gimp_data_factory_view_refresh_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_REFRESH,
_("Refresh"), NULL,
G_CALLBACK (gimp_data_factory_view_refresh_clicked),
NULL,
editor);
/* set button sensitivity */
if (GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item)

44
app/widgets/gimpdocumentview.c
View File

@ -151,32 +151,32 @@ gimp_document_view_new (GimpViewType view_type,
editor = GIMP_CONTAINER_EDITOR (document_view);
document_view->open_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_OPEN,
_("Open the selected entry\n"
"<Shift> Raise window if already open\n"
"<Ctrl> Open image dialog"),
NULL,
G_CALLBACK (gimp_document_view_open_clicked),
G_CALLBACK (gimp_document_view_open_extended_clicked),
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_OPEN,
_("Open the selected entry\n"
"<Shift> Raise window if already open\n"
"<Ctrl> Open image dialog"),
NULL,
G_CALLBACK (gimp_document_view_open_clicked),
G_CALLBACK (gimp_document_view_open_extended_clicked),
editor);
document_view->delete_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_DELETE,
_("Remove selected entry"), NULL,
G_CALLBACK (gimp_document_view_delete_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_DELETE,
_("Remove selected entry"), NULL,
G_CALLBACK (gimp_document_view_delete_clicked),
NULL,
editor);
document_view->refresh_button =
gimp_container_view_add_button (editor->view,
GTK_STOCK_REFRESH,
_("Refresh (check files for existence)"),
NULL,
G_CALLBACK (gimp_document_view_refresh_clicked),
NULL,
editor);
gimp_editor_add_button (GIMP_EDITOR (editor->view),
GTK_STOCK_REFRESH,
_("Refresh (check files for existence)"),
NULL,
G_CALLBACK (gimp_document_view_refresh_clicked),
NULL,
editor);
/* set button sensitivity */
if (GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item)

175
app/widgets/gimpeditor.c Normal file
View File

@ -0,0 +1,175 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpeditor.c
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
*
* 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 <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "gimpeditor.h"
#include "gimpdnd.h"
static void gimp_editor_class_init (GimpEditorClass *klass);
static void gimp_editor_init (GimpEditor *panel);
static void gimp_editor_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static GtkVBoxClass *parent_class = NULL;
GType
gimp_editor_get_type (void)
{
static GType type = 0;
if (! type)
{
static const GTypeInfo info =
{
sizeof (GimpEditorClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_editor_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpEditor),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_editor_init,
};
type = g_type_register_static (GTK_TYPE_VBOX,
"GimpEditor",
&info, 0);
}
return type;
}
static void
gimp_editor_class_init (GimpEditorClass *klass)
{
GtkWidgetClass *widget_class;
widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
widget_class->style_set = gimp_editor_style_set;
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("content_spacing",
NULL, NULL,
0,
G_MAXINT,
0,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("button_spacing",
NULL, NULL,
0,
G_MAXINT,
0,
G_PARAM_READABLE));
}
static void
gimp_editor_init (GimpEditor *editor)
{
}
static void
gimp_editor_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpEditor *editor;
gint content_spacing;
gint button_spacing;
editor = GIMP_EDITOR (widget);
gtk_widget_style_get (widget,
"content_spacing", &content_spacing,
"button_spacing", &button_spacing,
NULL);
gtk_box_set_spacing (GTK_BOX (widget), content_spacing);
if (editor->button_box)
{
gtk_box_set_spacing (GTK_BOX (editor->button_box), button_spacing);
}
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
}
GtkWidget *
gimp_editor_add_button (GimpEditor *editor,
const gchar *stock_id,
const gchar *tooltip,
const gchar *help_data,
GCallback callback,
GCallback extended_callback,
gpointer callback_data)
{
GtkWidget *button;
GtkWidget *image;
g_return_val_if_fail (GIMP_IS_EDITOR (editor), NULL);
g_return_val_if_fail (stock_id != NULL, NULL);
if (! editor->button_box)
{
editor->button_box = gtk_hbox_new (TRUE, 2);
gtk_box_pack_end (GTK_BOX (editor), editor->button_box, FALSE, FALSE, 0);
gtk_widget_show (editor->button_box);
}
button = gimp_button_new ();
gtk_box_pack_start (GTK_BOX (editor->button_box), button, TRUE, TRUE, 0);
gtk_widget_show (button);
if (tooltip || help_data)
gimp_help_set_help_data (button, tooltip, help_data);
if (callback)
g_signal_connect (G_OBJECT (button), "clicked",
callback,
callback_data);
if (extended_callback)
g_signal_connect (G_OBJECT (button), "extended_clicked",
extended_callback,
callback_data);
image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_show (image);
return button;
}

63
app/widgets/gimpeditor.h Normal file
View File

@ -0,0 +1,63 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpeditor.h
* Copyright (C) 2002 Michael Natterer <mitch@gimp.org>
*
* 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_EDITOR_H__
#define __GIMP_EDITOR_H__
#include <gtk/gtkvbox.h>
#define GIMP_TYPE_EDITOR (gimp_editor_get_type ())
#define GIMP_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_EDITOR, GimpEditor))
#define GIMP_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_EDITOR, GimpEditorClass))
#define GIMP_IS_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_EDITOR))
#define GIMP_IS_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_EDITOR))
#define GIMP_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_EDITOR, GimpEditorClass))
typedef struct _GimpEditorClass GimpEditorClass;
struct _GimpEditor
{
GtkVBox parent_instance;
GtkWidget *button_box;
};
struct _GimpEditorClass
{
GtkVBoxClass parent_class;
};
GType gimp_editor_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_editor_add_button (GimpEditor *editor,
const gchar *stock_id,
const gchar *tooltip,
const gchar *help_data,
GCallback callback,
GCallback extended_callback,
gpointer callback_data);
#endif /* __GIMP_EDITOR_H__ */

920
app/widgets/gimpgradienteditor.c
View File

File diff suppressed because it is too large Load Diff

50
app/widgets/gimpgradienteditor.h
View File

@ -19,8 +19,11 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GRADIENT_EDITOR_H__
#define __GRADIENT_EDITOR_H__
#ifndef __GIMP_GRADIENT_EDITOR_H__
#define __GIMP_GRADIENT_EDITOR_H__
#include "gimpdataeditor.h"
#define GRAD_NUM_COLORS 10
@ -43,19 +46,27 @@ typedef enum
} GradientEditorUpdateMask;
struct _GradientEditor
#define GIMP_TYPE_GRADIENT_EDITOR (gimp_gradient_editor_get_type ())
#define GIMP_GRADIENT_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_GRADIENT_EDITOR, GimpGradientEditor))
#define GIMP_GRADIENT_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GRADIENT_EDITOR, GimpGradientEditorClass))
#define GIMP_IS_GRADIENT_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_GRADIENT_EDITOR))
#define GIMP_IS_GRADIENT_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GRADIENT_EDITOR))
#define GIMP_GRADIENT_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_GRADIENT_EDITOR, GimpGradientEditorClass))
typedef struct _GimpGradientEditorClass GimpGradientEditorClass;
struct _GimpGradientEditor
{
GtkWidget *shell;
GimpDataEditor parent_instance;
GtkWidget *name;
GtkWidget *hint_label;
GtkWidget *hint_label1;
GtkWidget *hint_label2;
GtkWidget *hint_label3;
GtkWidget *scrollbar;
GtkWidget *preview;
GtkWidget *control;
GimpContext *context;
/* Zoom and scrollbar */
guint zoom_factor;
GtkObject *scroll_data;
@ -97,15 +108,16 @@ struct _GradientEditor
gboolean right_saved_dirty;
};
GradientEditor * gradient_editor_new (Gimp *gimp);
void gradient_editor_set_gradient (GradientEditor *gradient_editor,
GimpGradient *gradient);
void gradient_editor_free (GradientEditor *gradient_editor);
void gradient_editor_update (GradientEditor *gradient_editor,
GradientEditorUpdateMask flags);
struct _GimpGradientEditorClass
{
GimpDataEditorClass parent_class;
};
#endif /* __GRADIENT_EDITOR_H__ */
GimpDataEditor * gimp_gradient_editor_new (Gimp *gimp);
void gimp_gradient_editor_update (GimpGradientEditor *editor,
GradientEditorUpdateMask flags);
#endif /* __GIMP_GRADIENT_EDITOR_H__ */

86
app/widgets/gimpitemlistview.c
View File

@ -178,63 +178,63 @@ gimp_item_list_view_class_init (GimpItemListViewClass *klass)
static void
gimp_item_list_view_init (GimpItemListView *view)
{
GimpContainerView *container_view;
GimpEditor *editor;
container_view = GIMP_CONTAINER_VIEW (view);
editor = GIMP_EDITOR (view);
view->gimage = NULL;
view->item_type = G_TYPE_NONE;
view->signal_name = NULL;
view->gimage = NULL;
view->item_type = G_TYPE_NONE;
view->signal_name = NULL;
view->new_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_NEW,
_("New"), NULL,
G_CALLBACK (gimp_item_list_view_new_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GTK_STOCK_NEW,
_("New"), NULL,
G_CALLBACK (gimp_item_list_view_new_clicked),
NULL,
view);
view->raise_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_GO_UP,
_("Raise\n"
"<Shift> To Top"), NULL,
G_CALLBACK (gimp_item_list_view_raise_clicked),
G_CALLBACK (gimp_item_list_view_raise_extended_clicked),
view);
gimp_editor_add_button (editor,
GTK_STOCK_GO_UP,
_("Raise\n"
"<Shift> To Top"), NULL,
G_CALLBACK (gimp_item_list_view_raise_clicked),
G_CALLBACK (gimp_item_list_view_raise_extended_clicked),
view);
view->lower_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_GO_DOWN,
_("Lower\n"
"<Shift> To Bottom"), NULL,
G_CALLBACK (gimp_item_list_view_lower_clicked),
G_CALLBACK (gimp_item_list_view_lower_extended_clicked),
view);
gimp_editor_add_button (editor,
GTK_STOCK_GO_DOWN,
_("Lower\n"
"<Shift> To Bottom"), NULL,
G_CALLBACK (gimp_item_list_view_lower_clicked),
G_CALLBACK (gimp_item_list_view_lower_extended_clicked),
view);
view->duplicate_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_DUPLICATE,
_("Duplicate"), NULL,
G_CALLBACK (gimp_item_list_view_duplicate_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GIMP_STOCK_DUPLICATE,
_("Duplicate"), NULL,
G_CALLBACK (gimp_item_list_view_duplicate_clicked),
NULL,
view);
view->edit_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_EDIT,
_("Edit"), NULL,
G_CALLBACK (gimp_item_list_view_edit_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GIMP_STOCK_EDIT,
_("Edit"), NULL,
G_CALLBACK (gimp_item_list_view_edit_clicked),
NULL,
view);
view->delete_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_item_list_view_delete_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_item_list_view_delete_clicked),
NULL,
view);
gtk_widget_set_sensitive (view->new_button, FALSE);
gtk_widget_set_sensitive (view->raise_button, FALSE);

86
app/widgets/gimpitemtreeview.c
View File

@ -178,63 +178,63 @@ gimp_item_list_view_class_init (GimpItemListViewClass *klass)
static void
gimp_item_list_view_init (GimpItemListView *view)
{
GimpContainerView *container_view;
GimpEditor *editor;
container_view = GIMP_CONTAINER_VIEW (view);
editor = GIMP_EDITOR (view);
view->gimage = NULL;
view->item_type = G_TYPE_NONE;
view->signal_name = NULL;
view->gimage = NULL;
view->item_type = G_TYPE_NONE;
view->signal_name = NULL;
view->new_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_NEW,
_("New"), NULL,
G_CALLBACK (gimp_item_list_view_new_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GTK_STOCK_NEW,
_("New"), NULL,
G_CALLBACK (gimp_item_list_view_new_clicked),
NULL,
view);
view->raise_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_GO_UP,
_("Raise\n"
"<Shift> To Top"), NULL,
G_CALLBACK (gimp_item_list_view_raise_clicked),
G_CALLBACK (gimp_item_list_view_raise_extended_clicked),
view);
gimp_editor_add_button (editor,
GTK_STOCK_GO_UP,
_("Raise\n"
"<Shift> To Top"), NULL,
G_CALLBACK (gimp_item_list_view_raise_clicked),
G_CALLBACK (gimp_item_list_view_raise_extended_clicked),
view);
view->lower_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_GO_DOWN,
_("Lower\n"
"<Shift> To Bottom"), NULL,
G_CALLBACK (gimp_item_list_view_lower_clicked),
G_CALLBACK (gimp_item_list_view_lower_extended_clicked),
view);
gimp_editor_add_button (editor,
GTK_STOCK_GO_DOWN,
_("Lower\n"
"<Shift> To Bottom"), NULL,
G_CALLBACK (gimp_item_list_view_lower_clicked),
G_CALLBACK (gimp_item_list_view_lower_extended_clicked),
view);
view->duplicate_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_DUPLICATE,
_("Duplicate"), NULL,
G_CALLBACK (gimp_item_list_view_duplicate_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GIMP_STOCK_DUPLICATE,
_("Duplicate"), NULL,
G_CALLBACK (gimp_item_list_view_duplicate_clicked),
NULL,
view);
view->edit_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_EDIT,
_("Edit"), NULL,
G_CALLBACK (gimp_item_list_view_edit_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GIMP_STOCK_EDIT,
_("Edit"), NULL,
G_CALLBACK (gimp_item_list_view_edit_clicked),
NULL,
view);
view->delete_button =
gimp_container_view_add_button (container_view,
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_item_list_view_delete_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GTK_STOCK_DELETE,
_("Delete"), NULL,
G_CALLBACK (gimp_item_list_view_delete_clicked),
NULL,
view);
gtk_widget_set_sensitive (view->new_button, FALSE);
gtk_widget_set_sensitive (view->raise_button, FALSE);

14
app/widgets/gimplayerlistview.c
View File

@ -204,14 +204,14 @@ gimp_layer_list_view_init (GimpLayerListView *view)
/* Anchor button */
view->anchor_button =
gimp_container_view_add_button (GIMP_CONTAINER_VIEW (view),
GIMP_STOCK_ANCHOR,
_("Anchor"), NULL,
G_CALLBACK (gimp_layer_list_view_anchor_clicked),
NULL,
view);
gimp_editor_add_button (GIMP_EDITOR (view),
GIMP_STOCK_ANCHOR,
_("Anchor"), NULL,
G_CALLBACK (gimp_layer_list_view_anchor_clicked),
NULL,
view);
gtk_box_reorder_child (GTK_BOX (GIMP_CONTAINER_VIEW (view)->button_box),
gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (view)->button_box),
view->anchor_button, 5);
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (view),

14
app/widgets/gimplayertreeview.c
View File

@ -204,14 +204,14 @@ gimp_layer_list_view_init (GimpLayerListView *view)
/* Anchor button */
view->anchor_button =
gimp_container_view_add_button (GIMP_CONTAINER_VIEW (view),
GIMP_STOCK_ANCHOR,
_("Anchor"), NULL,
G_CALLBACK (gimp_layer_list_view_anchor_clicked),
NULL,
view);
gimp_editor_add_button (GIMP_EDITOR (view),
GIMP_STOCK_ANCHOR,
_("Anchor"), NULL,
G_CALLBACK (gimp_layer_list_view_anchor_clicked),
NULL,
view);
gtk_box_reorder_child (GTK_BOX (GIMP_CONTAINER_VIEW (view)->button_box),
gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (view)->button_box),
view->anchor_button, 5);
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (view),

1144
app/widgets/gimppaletteeditor.c
View File

File diff suppressed because it is too large Load Diff

63
app/widgets/gimppaletteeditor.h
View File

@ -16,8 +16,13 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __PALETTE_EDITOR_H__
#define __PALETTE_EDITOR_H__
#ifndef __GIMP_PALETTE_EDITOR_H__
#define __GIMP_PALETTE_EDITOR_H__
#include "gimpdataeditor.h"
#include "gui/gui-types.h" /* FIXME */
typedef enum
@ -28,18 +33,54 @@ typedef enum
} GimpUpdateColorState;
typedef struct _PaletteEditor PaletteEditor;
#define GIMP_TYPE_PALETTE_EDITOR (gimp_palette_editor_get_type ())
#define GIMP_PALETTE_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PALETTE_EDITOR, GimpPaletteEditor))
#define GIMP_PALETTE_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PALETTE_EDITOR, GimpPaletteEditorClass))
#define GIMP_IS_PALETTE_EDITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PALETTE_EDITOR))
#define GIMP_IS_PALETTE_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PALETTE_EDITOR))
#define GIMP_PALETTE_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PALETTE_EDITOR, GimpPaletteEditorClass))
PaletteEditor * palette_editor_new (Gimp *gimp);
typedef struct _GimpPaletteEditorClass GimpPaletteEditorClass;
void palette_editor_set_palette (PaletteEditor *palette_editor,
GimpPalette *palette);
void palette_editor_free (PaletteEditor *palette_editor);
struct _GimpPaletteEditor
{
GimpDataEditor parent_instance;
void palette_editor_update_color (GimpContext *context,
const GimpRGB *color,
GimpUpdateColorState state);
GtkWidget *color_area;
GtkWidget *scrolled_window;
GtkWidget *color_name;
GtkWidget *popup_menu;
GtkWidget *delete_menu_item;
GtkWidget *edit_menu_item;
ColorNotebook *color_notebook;
gboolean color_notebook_active;
GimpPaletteEntry *color;
GimpPaletteEntry *dnd_color;
guint entry_sig_id;
gfloat zoom_factor; /* range from 0.1 to 4.0 */
gint col_width;
gint last_width;
gint columns;
gboolean freeze_update;
gboolean columns_valid;
};
struct _GimpPaletteEditorClass
{
GimpDataEditorClass parent_class;
};
#endif /* __PALETTE_EDITOR_H__ */
GimpDataEditor * gimp_palette_editor_new (Gimp *gimp);
void gimp_palette_editor_update_color (GimpContext *context,
const GimpRGB *color,
GimpUpdateColorState state);
#endif /* __GIMP_PALETTE_EDITOR_H__ */

42
app/widgets/gimpvectorslistview.c
View File

@ -121,40 +121,40 @@ gimp_vectors_list_view_class_init (GimpVectorsListViewClass *klass)
static void
gimp_vectors_list_view_init (GimpVectorsListView *view)
{
GimpContainerView *container_view;
GimpEditor *editor;
container_view = GIMP_CONTAINER_VIEW (view);
editor = GIMP_EDITOR (view);
/* To Selection button */
view->toselection_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_SELECTION_REPLACE,
_("Path to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_vectors_list_view_toselection_clicked),
G_CALLBACK (gimp_vectors_list_view_toselection_extended_clicked),
view);
gimp_editor_add_button (editor,
GIMP_STOCK_SELECTION_REPLACE,
_("Path to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_vectors_list_view_toselection_clicked),
G_CALLBACK (gimp_vectors_list_view_toselection_extended_clicked),
view);
view->stroke_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_PATH_STROKE,
_("Stroke Path"), NULL,
G_CALLBACK (gimp_vectors_list_view_stroke_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GIMP_STOCK_PATH_STROKE,
_("Stroke Path"), NULL,
G_CALLBACK (gimp_vectors_list_view_stroke_clicked),
NULL,
view);
gtk_box_reorder_child (GTK_BOX (container_view->button_box),
gtk_box_reorder_child (GTK_BOX (editor->button_box),
view->toselection_button, 5);
gtk_box_reorder_child (GTK_BOX (container_view->button_box),
gtk_box_reorder_child (GTK_BOX (editor->button_box),
view->stroke_button, 6);
gimp_container_view_enable_dnd (container_view,
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor),
GTK_BUTTON (view->toselection_button),
GIMP_TYPE_VECTORS);
gimp_container_view_enable_dnd (container_view,
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor),
GTK_BUTTON (view->stroke_button),
GIMP_TYPE_VECTORS);

42
app/widgets/gimpvectorstreeview.c
View File

@ -121,40 +121,40 @@ gimp_vectors_list_view_class_init (GimpVectorsListViewClass *klass)
static void
gimp_vectors_list_view_init (GimpVectorsListView *view)
{
GimpContainerView *container_view;
GimpEditor *editor;
container_view = GIMP_CONTAINER_VIEW (view);
editor = GIMP_EDITOR (view);
/* To Selection button */
view->toselection_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_SELECTION_REPLACE,
_("Path to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_vectors_list_view_toselection_clicked),
G_CALLBACK (gimp_vectors_list_view_toselection_extended_clicked),
view);
gimp_editor_add_button (editor,
GIMP_STOCK_SELECTION_REPLACE,
_("Path to Selection\n"
"<Shift> Add\n"
"<Ctrl> Subtract\n"
"<Shift><Ctrl> Intersect"), NULL,
G_CALLBACK (gimp_vectors_list_view_toselection_clicked),
G_CALLBACK (gimp_vectors_list_view_toselection_extended_clicked),
view);
view->stroke_button =
gimp_container_view_add_button (container_view,
GIMP_STOCK_PATH_STROKE,
_("Stroke Path"), NULL,
G_CALLBACK (gimp_vectors_list_view_stroke_clicked),
NULL,
view);
gimp_editor_add_button (editor,
GIMP_STOCK_PATH_STROKE,
_("Stroke Path"), NULL,
G_CALLBACK (gimp_vectors_list_view_stroke_clicked),
NULL,
view);
gtk_box_reorder_child (GTK_BOX (container_view->button_box),
gtk_box_reorder_child (GTK_BOX (editor->button_box),
view->toselection_button, 5);
gtk_box_reorder_child (GTK_BOX (container_view->button_box),
gtk_box_reorder_child (GTK_BOX (editor->button_box),
view->stroke_button, 6);
gimp_container_view_enable_dnd (container_view,
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor),
GTK_BUTTON (view->toselection_button),
GIMP_TYPE_VECTORS);
gimp_container_view_enable_dnd (container_view,
gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor),
GTK_BUTTON (view->stroke_button),
GIMP_TYPE_VECTORS);

6
app/widgets/widgets-types.h
View File

@ -152,6 +152,12 @@ typedef struct _GimpContainerMenuImpl GimpContainerMenuImpl;
typedef struct _GimpMenuItem GimpMenuItem;
typedef struct _GimpEditor GimpEditor;
typedef struct _GimpDataEditor GimpDataEditor;
typedef struct _GimpBrushEditor GimpBrushEditor;
typedef struct _GimpGradientEditor GimpGradientEditor;
typedef struct _GimpPaletteEditor GimpPaletteEditor;
typedef struct _GimpContainerView GimpContainerView;
typedef struct _GimpContainerListView GimpContainerListView;
typedef struct _GimpContainerGridView GimpContainerGridView;

16
po/ChangeLog
View File

@ -1,3 +1,7 @@
2002-03-08 Michael Natterer <mitch@gimp.org>
* POTFILES.in: updated.
2002-03-07 Ole Laursen <olau@hardworking.dk>
* da.po: Updated Danish translation.
@ -13,7 +17,7 @@
2002-03-06 Kjartan Maraas <kmaraas@gnome.org>
* no.po: Updated Norwegian (bokmål) translation.
2002-03-06 Vincent van Adrighem <V.vanAdrighem@dirck.mine.nu>
* nl.po: Massive translation-update (copy-paste from gimp-1-2).
@ -33,7 +37,7 @@
2002-02-28 Sven Neumann <sven@gimp.org>
* POTFILES.in: added missing files.
* de.po: updated german translation.
2002-02-25 Sven Neumann <sven@gimp.org>
@ -43,16 +47,16 @@
2002-02-22 Sven Neumann <sven@gimp.org>
* po/Makefile.in.in: changed by glib-gettextize and intltoolize.
* po/po2tbl.sed.in
* po/update.pl
* po/update.sh: removed, we use intltool now
* README.tools: mention intltool-update.
* po/POTFILES.in: added data/misc/gimp.desktop.in.in
* po/de.po: updated german translation.cvs
* po/de.po: updated german translation.
2002-02-22 Michael Natterer <mitch@gimp.org>

6
po/POTFILES.in
View File

@ -53,7 +53,6 @@ app/file/file-open.c
app/file/file-save.c
app/gui/about-dialog.c
app/gui/brush-editor.c
app/gui/brush-select.c
app/gui/channels-commands.c
app/gui/color-area.c
@ -70,7 +69,6 @@ app/gui/file-commands.c
app/gui/file-new-dialog.c
app/gui/file-open-dialog.c
app/gui/file-save-dialog.c
app/gui/gradient-editor.c
app/gui/gradient-editor-commands.c
app/gui/gradient-select.c
app/gui/gradients-commands.c
@ -83,7 +81,6 @@ app/gui/layers-commands.c
app/gui/menus.c
app/gui/module-browser.c
app/gui/offset-dialog.c
app/gui/palette-editor.c
app/gui/palette-import-dialog.c
app/gui/palette-select.c
app/gui/palettes-commands.c
@ -161,6 +158,7 @@ app/tools/selection_options.c
app/tools/tool_options.c
app/tools/transform_options.c
app/widgets/gimpbrusheditor.c
app/widgets/gimpbrushfactoryview.c
app/widgets/gimpbufferview.c
app/widgets/gimpchannellistview.c
@ -170,10 +168,12 @@ app/widgets/gimpdatafactoryview.c
app/widgets/gimpdocumentview.c
app/widgets/gimpdrawablelistview.c
app/widgets/gimpfontselection-dialog.c
app/widgets/gimpgradienteditor.c
app/widgets/gimpimagedock.c
app/widgets/gimpitemfactory.c
app/widgets/gimpitemlistview.c
app/widgets/gimplayerlistview.c
app/widgets/gimppaletteeditor.c
app/widgets/gimpvectorslistview.c
app/widgets/gimpwidgets-constructors.c
app/widgets/gimpwidgets-utils.c

12
themes/Default/gtkrc
View File

@ -99,13 +99,11 @@ class "GtkHScale" style "gimp-hscale-style"
style "gimp-dock-style"
{
GimpDock::separator_height = 6
GimpDockbook::tab_border = 0
GimpDockable::content_border = 2
GimpContainerView::content_spacing = 2
GimpContainerView::button_spacing = 2
GimpContainerEditor::content_spacing = 2
GimpContainerEditor::button_spacing = 2
GimpDock::separator_height = 6
GimpDockbook::tab_border = 0
GimpDockable::content_border = 2
GimpEditor::content_spacing = 2
GimpEditor::button_spacing = 2
}
widget "*Gimp*Dock*" style "gimp-dock-style"