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

Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning) 

2001-07-24  Michael Natterer  <mitch@gimp.org>

	Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)

	* configure.in: require glib/gtk+ >= 1.3.7, commented out the
	gtkxmhtml stuff.

	From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
	to hack or use GIMP HEAD.

	Beware, it crashes randomly :)

	* app/core/Makefile.am
	* app/core/gimpmarshal.list: new file plus rules to generate
	gimpmarshal.[ch] from it.

	* app/core/*
	* app/tools/*
	* app/widgets/*
	* libgimpwidgets/*: started to use the glib object system. All
	core/ objects are still gtk objects however. All signals are
	created using g_signal_new(). There are many gtk+ artefacts left.
	Finally, we will _not_ use the gtk_signal_foo() wrappers and
	friends any more.

	* app/colormaps.c
	* app/devices.[ch]
	* app/disp_callbacks.c
	* app/errorconsole.c
	* app/file-save.[ch]
	* app/interface.c
	* app/module_db.c
	* app/nav_window.c
	* app/ops_buttons.c
	* app/scroll.c
	* app/user_install.c
	* app/gui/about-dialog.c
	* app/gui/brush-editor.c
	* app/gui/brushes-commands.c
	* app/gui/color-notebook.c
	* app/gui/colormap-dialog.c
	* app/gui/dialogs-commands.c
	* app/gui/dialogs-constructors.c
	* app/gui/file-commands.c
	* app/gui/file-dialog-utils.c
	* app/gui/file-new-dialog.c
	* app/gui/file-open-dialog.[ch]
	* app/gui/file-save-dialog.c
	* app/gui/gradient-editor.c
	* app/gui/gradients-commands.c
	* app/gui/image-commands.c
	* app/gui/info-dialog.[ch]
	* app/gui/layer-select.c
	* app/gui/layers-commands.c
	* app/gui/menus.c
	* app/gui/offset-dialog.c
	* app/gui/palette-editor.c
	* app/gui/palettes-commands.c
	* app/gui/patterns-commands.c
	* app/gui/preferences-dialog.c
	* app/gui/resize-dialog.[ch]
	* app/gui/splash.c
	* app/gui/tips-dialog.c
	* app/gui/tool-options-dialog.c
	* app/gui/toolbox.c
	* app/gui/tools-commands.c
	* libgimp/gimpbrushmenu.c
	* libgimp/gimpmenu.c
	* libgimp/gimppatternmenu.c
	* libgimp/gimpui.c
	* libgimpbase/gimpenv.c: tons and tons of changes like "const
	gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
	and currently disables), lots of s/gtk_signal/g_signal/,
	removal/replacement of deprecated stuff,
	s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
	while I was on it, zillions of warnings left...

	* modules/Makefile.am: disabled the water color selector
	temporarily (XInput issues).

	* plug-ins/Makefile.am
	* plug-ins/common/.cvsignore
	* plug-ins/common/Makefile.am
	* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
	which did not build (including Script-Fu). They are trivial to
	fix.
This commit is contained in:
Michael Natterer 2001-07-24 21:27:11 +00:00 committed by Michael Natterer
parent ae51fe616b
commit 06b16890ba
407 changed files with 8435 additions and 7268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
ChangeLog
View File

@ -1,3 +1,90 @@
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-23 Sven Neumann <sven@gimp.org>
* plug-ins/common/winclipboard.c

8
app/actions/dialogs-commands.c
View File

@ -39,7 +39,7 @@ dialogs_create_toplevel_cmd_callback (GtkWidget *widget,
{
if (action)
{
gchar *identifier;
const gchar *identifier;
identifier = g_quark_to_string ((GQuark) action);
@ -55,7 +55,7 @@ dialogs_create_dockable_cmd_callback (GtkWidget *widget,
{
if (action)
{
gchar *identifier;
const gchar *identifier;
identifier = g_quark_to_string ((GQuark) action);
@ -75,8 +75,8 @@ dialogs_add_tab_cmd_callback (GtkWidget *widget,
if (dockbook && action)
{
GtkWidget *dockable;
gchar *identifier;
GtkWidget *dockable;
const gchar *identifier;
identifier = g_quark_to_string ((GQuark) action);

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

@ -152,8 +152,8 @@ file_save_cmd_callback (GtkWidget *widget,
}
else
{
gchar *raw_filename;
gint status;
const gchar *raw_filename;
gint status;
raw_filename = g_basename (filename);

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

@ -96,7 +96,7 @@ gradients_menu_set_sensitivity (GimpContainerEditor *editor)
menus_set_sensitive ("<Gradients>/" menu, (condition) != 0)
SET_SENSITIVE ("Duplicate Gradient",
gradient && GIMP_DATA_CLASS (GTK_OBJECT (gradient)->klass)->duplicate);
gradient && GIMP_DATA_GET_CLASS (gradient)->duplicate);
SET_SENSITIVE ("Edit Gradient...",
gradient && GIMP_DATA_FACTORY_VIEW (editor)->data_edit_func);
SET_SENSITIVE ("Delete Gradient...",
@ -162,7 +162,7 @@ gradients_save_as_pov_ok_callback (GtkWidget *widget,
GimpGradient *gradient)
{
GtkFileSelection *filesel;
gchar *filename;
const gchar *filename;
FILE *file;
GimpGradientSegment *seg;

8
app/actions/image-commands.c
View File

@ -196,7 +196,7 @@ image_resize_cmd_callback (GtkWidget *widget,
image_resize->gimage = gimage;
image_resize->resize = resize_widget_new (ResizeWidget,
ResizeImage,
GTK_OBJECT (gimage),
G_OBJECT (gimage),
"destroy",
gimage->width,
gimage->height,
@ -204,7 +204,7 @@ image_resize_cmd_callback (GtkWidget *widget,
gimage->yresolution,
gimage->unit,
gdisp->dot_for_dot,
image_resize_callback,
G_CALLBACK (image_resize_callback),
NULL,
image_resize);
@ -233,7 +233,7 @@ image_scale_cmd_callback (GtkWidget *widget,
image_scale->gimage = gimage;
image_scale->resize = resize_widget_new (ScaleWidget,
ResizeImage,
GTK_OBJECT (gimage),
G_OBJECT (gimage),
"destroy",
gimage->width,
gimage->height,
@ -241,7 +241,7 @@ image_scale_cmd_callback (GtkWidget *widget,
gimage->yresolution,
gimage->unit,
gdisp->dot_for_dot,
image_scale_callback,
G_CALLBACK (image_scale_callback),
NULL,
image_scale);

2
app/actions/layers-commands.c
View File

@ -640,8 +640,6 @@ layers_new_layer_query (GimpImage *gimage)
/* The size sizeentry */
adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2);
gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton),
GTK_SHADOW_NONE);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_widget_set_usize (spinbutton, 75, 0);

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

@ -113,7 +113,7 @@ palettes_menu_set_sensitivity (GimpContainerEditor *editor)
menus_set_sensitive ("<Palettes>/" menu, (condition) != 0)
SET_SENSITIVE ("Duplicate Palette",
palette && GIMP_DATA_CLASS (GTK_OBJECT (palette)->klass)->duplicate);
palette && GIMP_DATA_GET_CLASS (palette)->duplicate);
SET_SENSITIVE ("Edit Palette...",
palette && GIMP_DATA_FACTORY_VIEW (editor)->data_edit_func);
SET_SENSITIVE ("Delete Palette...",

2
app/actions/tools-commands.c
View File

@ -109,7 +109,7 @@ tools_select_cmd_callback (GtkWidget *widget,
/* Complete the initialisation by doing the same stuff
* tools_initialize() does after it did what tools_select() does
*/
if (GIMP_TOOL_CLASS (GTK_OBJECT (active_tool)->klass)->initialize)
if (GIMP_TOOL_GET_CLASS (active_tool)->initialize)
{
gimp_tool_initialize (active_tool, gdisp);

8
app/base/color-balance.h
View File

@ -32,10 +32,10 @@ typedef enum
#define GIMP_TYPE_COLOR_BALANCE_TOOL (gimp_color_balance_tool_get_type ())
#define GIMP_COLOR_BALANCE_TOOL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_COLOR_BALANCE_TOOL, GimpColorBalanceTool))
#define GIMP_IS_COLOR_BALANCE_TOOL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_COLOR_BALANCE_TOOL))
#define GIMP_COLOR_BALANCE_TOOL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_BALANCE_TOOL, GimpColorBalanceToolClass))
#define GIMP_IS_COLOR_BALANCE_TOOL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_BALANCE_TOOL))
#define GIMP_COLOR_BALANCE_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_BALANCE_TOOL, GimpColorBalanceTool))
#define GIMP_IS_COLOR_BALANCE_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_BALANCE_TOOL))
#define GIMP_COLOR_BALANCE_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_BALANCE_TOOL, GimpColorBalanceToolClass))
#define GIMP_IS_COLOR_BALANCE_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_BALANCE_TOOL))
typedef struct _GimpColorBalanceTool GimpColorBalanceTool;

84
app/base/curves.c
View File

@ -695,14 +695,16 @@ curves_dialog_new (void)
gtk_box_pack_start (GTK_BOX (channel_hbox), label, FALSE, FALSE, 0);
cd->channel_menu = gimp_option_menu_new2
(FALSE, curves_channel_callback,
cd, (gpointer) cd->channel,
(FALSE,
G_CALLBACK (curves_channel_callback),
cd,
GINT_TO_POINTER (cd->channel),
_("Value"), (gpointer) GIMP_HISTOGRAM_VALUE, &channel_items[0],
_("Red"), (gpointer) GIMP_HISTOGRAM_RED, &channel_items[1],
_("Green"), (gpointer) GIMP_HISTOGRAM_GREEN, &channel_items[2],
_("Blue"), (gpointer) GIMP_HISTOGRAM_BLUE, &channel_items[3],
_("Alpha"), (gpointer) GIMP_HISTOGRAM_ALPHA, &channel_items[4],
_("Value"), GINT_TO_POINTER (GIMP_HISTOGRAM_VALUE), &channel_items[0],
_("Red"), GINT_TO_POINTER (GIMP_HISTOGRAM_RED), &channel_items[1],
_("Green"), GINT_TO_POINTER (GIMP_HISTOGRAM_GREEN), &channel_items[2],
_("Blue"), GINT_TO_POINTER (GIMP_HISTOGRAM_BLUE), &channel_items[3],
_("Alpha"), GINT_TO_POINTER (GIMP_HISTOGRAM_ALPHA), &channel_items[4],
NULL);
@ -729,9 +731,9 @@ curves_dialog_new (void)
gtk_widget_set_events (cd->yrange, RANGE_MASK);
gtk_container_add (GTK_CONTAINER (frame), cd->yrange);
gtk_signal_connect (GTK_OBJECT (cd->yrange), "event",
GTK_SIGNAL_FUNC (curves_yrange_events),
cd);
g_signal_connect (G_OBJECT (cd->yrange), "event",
G_CALLBACK (curves_yrange_events),
cd);
gtk_widget_show (cd->yrange);
gtk_widget_show (frame);
@ -750,9 +752,9 @@ curves_dialog_new (void)
gtk_widget_set_events (cd->graph, GRAPH_MASK);
gtk_container_add (GTK_CONTAINER (frame), cd->graph);
gtk_signal_connect (GTK_OBJECT (cd->graph), "event",
GTK_SIGNAL_FUNC (curves_graph_events),
cd);
g_signal_connect (G_OBJECT (cd->graph), "event",
G_CALLBACK (curves_graph_events),
cd);
gtk_widget_show (cd->graph);
gtk_widget_show (frame);
@ -768,9 +770,9 @@ curves_dialog_new (void)
gtk_widget_set_events (cd->xrange, RANGE_MASK);
gtk_container_add (GTK_CONTAINER (frame), cd->xrange);
gtk_signal_connect (GTK_OBJECT (cd->xrange), "event",
GTK_SIGNAL_FUNC (curves_xrange_events),
cd);
g_signal_connect (G_OBJECT (cd->xrange), "event",
G_CALLBACK (curves_xrange_events),
cd);
gtk_widget_show (cd->xrange);
gtk_widget_show (frame);
@ -802,9 +804,9 @@ curves_dialog_new (void)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), cd->preview);
gtk_box_pack_end (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (curves_preview_update),
cd);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (curves_preview_update),
cd);
gtk_widget_show (toggle);
gtk_widget_show (hbox);
@ -818,19 +820,21 @@ curves_dialog_new (void)
button = gtk_button_new_with_label (_("Load"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (curves_load_callback),
cd->shell);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (curves_load_callback),
cd->shell);
button = gtk_button_new_with_label (_("Save"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (curves_save_callback),
cd->shell);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (curves_save_callback),
cd->shell);
gtk_widget_show (hbbox);
gtk_widget_show (vbox);
@ -1754,19 +1758,21 @@ file_dialog_create (GtkWidget *parent)
gtk_container_set_border_width (GTK_CONTAINER (file_dlg), 2);
gtk_container_set_border_width (GTK_CONTAINER (GTK_FILE_SELECTION (file_dlg)->button_area), 2);
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_dlg)->cancel_button),
"clicked", GTK_SIGNAL_FUNC (file_dialog_cancel_callback),
NULL);
gtk_signal_connect (GTK_OBJECT (file_dlg), "delete_event",
GTK_SIGNAL_FUNC (file_dialog_cancel_callback),
NULL);
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_dlg)->ok_button),
"clicked", GTK_SIGNAL_FUNC (file_dialog_ok_callback),
NULL);
g_signal_connect (G_OBJECT (GTK_FILE_SELECTION (file_dlg)->cancel_button),
"clicked",
G_CALLBACK (file_dialog_cancel_callback),
NULL);
g_signal_connect (G_OBJECT (file_dlg), "delete_event",
G_CALLBACK (file_dialog_cancel_callback),
NULL);
g_signal_connect (G_OBJECT (GTK_FILE_SELECTION (file_dlg)->ok_button),
"clicked",
G_CALLBACK (file_dialog_ok_callback),
NULL);
gtk_signal_connect (GTK_OBJECT (parent), "unmap",
GTK_SIGNAL_FUNC (file_dialog_cancel_callback),
NULL);
g_signal_connect (G_OBJECT (parent), "unmap",
G_CALLBACK (file_dialog_cancel_callback),
NULL);
temp = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "curves" G_DIR_SEPARATOR_S,
gimp_directory ());
@ -1780,8 +1786,8 @@ static void
file_dialog_ok_callback (GtkWidget *widget,
gpointer data)
{
FILE *f;
gchar *filename;
FILE *f;
const gchar *filename;
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_dlg));

8
app/base/curves.h
View File

@ -28,10 +28,10 @@
#define GIMP_TYPE_CURVES_TOOL (gimp_curves_tool_get_type ())
#define GIMP_CURVES_TOOL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CURVES_TOOL, GimpCurvesTool))
#define GIMP_IS_CURVES_TOOL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CURVES_TOOL))
#define GIMP_CURVES_TOOL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CURVES_TOOL, GimpCurvesToolClass))
#define GIMP_IS_CURVES_TOOL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CURVES_TOOL))
#define GIMP_CURVES_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CURVES_TOOL, GimpCurvesTool))
#define GIMP_IS_CURVES_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CURVES_TOOL))
#define GIMP_CURVES_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CURVES_TOOL, GimpCurvesToolClass))
#define GIMP_IS_CURVES_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CURVES_TOOL))
typedef struct _GimpCurvesTool GimpCurvesTool;

8
app/base/hue-saturation.h
View File

@ -36,10 +36,10 @@ typedef enum
#define GIMP_TYPE_HUE_SATURATION_TOOL (gimp_hue_saturation_tool_get_type ())
#define GIMP_HUE_SATURATION_TOOL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_HUE_SATURATION_TOOL, GimpHueSaturationTool))
#define GIMP_IS_HUE_SATURATION_TOOL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_HUE_SATURATION_TOOL))
#define GIMP_HUE_SATURATION_TOOL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_HUE_SATURATION_TOOL, GimpHueSaturationToolClass))
#define GIMP_IS_HUE_SATURATION_TOOL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_HUE_SATURATION_TOOL))
#define GIMP_HUE_SATURATION_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_HUE_SATURATION_TOOL, GimpHueSaturationTool))
#define GIMP_IS_HUE_SATURATION_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_HUE_SATURATION_TOOL))
#define GIMP_HUE_SATURATION_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_HUE_SATURATION_TOOL, GimpHueSaturationToolClass))
#define GIMP_IS_HUE_SATURATION_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_HUE_SATURATION_TOOL))
typedef struct _GimpHueSaturationTool GimpHueSaturationTool;

8
app/base/threshold.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_THRESHOLD_TOOL (gimp_threshold_tool_get_type ())
#define GIMP_THRESHOLD_TOOL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_THRESHOLD_TOOL, GimpThresholdTool))
#define GIMP_IS_THRESHOLD_TOOL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_THRESHOLD_TOOL))
#define GIMP_THRESHOLD_TOOL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_THRESHOLD_TOOL, GimpThresholdToolClass))
#define GIMP_IS_THRESHOLD_TOOL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_THRESHOLD_TOOL))
#define GIMP_THRESHOLD_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_THRESHOLD_TOOL, GimpThresholdTool))
#define GIMP_IS_THRESHOLD_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_THRESHOLD_TOOL))
#define GIMP_THRESHOLD_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_THRESHOLD_TOOL, GimpThresholdToolClass))
#define GIMP_IS_THRESHOLD_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_THRESHOLD_TOOL))
typedef struct _GimpThresholdTool GimpThresholdTool;

1
app/colormaps.c
View File

@ -74,7 +74,6 @@ get_standard_colormaps (void)
g_visual = gdk_rgb_get_visual ();
g_cmap = gdk_rgb_get_cmap ();
gtk_widget_set_default_visual (g_visual);
gtk_widget_set_default_colormap (g_cmap);
set_app_colors ();

1
app/core/.cvsignore
View File

@ -4,3 +4,4 @@ Makefile.in
.libs
*.lo
libappcore.la
stamp-gimpmarshal.h

64
app/core/Makefile.am
View File

@ -1,8 +1,21 @@
## Process this file with automake to produce Makefile.in
AM_CPPFLAGS = @STRIP_BEGIN@ \
-DG_LOG_DOMAIN=\"Gimp-Core\" \
@GIMP_THREAD_FLAGS@ \
@GIMP_MP_FLAGS@ \
@STRIP_END@
INCLUDES = @STRIP_BEGIN@ \
-I$(top_srcdir) \
-I$(top_srcdir)/app \
$(GTK_CFLAGS) \
-I$(includedir) \
@STRIP_END@
noinst_LIBRARIES = libappcore.a
libappcore_a_SOURCES = @STRIP_BEGIN@ \
libappcore_a_sources = @STRIP_BEGIN@ \
core-types.h \
gimp.c \
gimp.h \
@ -72,8 +85,6 @@ libappcore_a_SOURCES = @STRIP_BEGIN@ \
gimplayermask.h \
gimplist.c \
gimplist.h \
gimpmarshal.c \
gimpmarshal.h \
gimpobject.c \
gimpobject.h \
gimppattern.c \
@ -103,21 +114,44 @@ libappcore_a_SOURCES = @STRIP_BEGIN@ \
gimpviewable.h \
@STRIP_END@
libappcore_a_built_sources = @STRIP_BEGIN@ \
stamp-gimpmarshal.h \
gimpmarshal.c \
gimpmarshal.h \
@STRIP_END@
libappcore_a_extra_sources = @STRIP_BEGIN@ \
gimpmarshal.list \
@STRIP_END@
libappcore_a_SOURCES = $(libappcore_a_built_sources) $(libappcore_a_sources)
EXTRS_DIST = \
makefile.msc
makefile.msc \
$(libappcore_a_extra_sources)
AM_CPPFLAGS = @STRIP_BEGIN@ \
-DG_LOG_DOMAIN=\"Gimp-Core\" \
@GIMP_THREAD_FLAGS@ \
@GIMP_MP_FLAGS@ \
@STRIP_END@
#
# rules to generate built sources
#
# setup autogeneration dependancies
gen_sources = xgen-gmh xgen-gmc
CLEANFILES += $(gen_sources)
INCLUDES = @STRIP_BEGIN@ \
-I$(top_srcdir) \
-I$(top_srcdir)/app \
$(GTK_CFLAGS) \
-I$(includedir) \
@STRIP_END@
$(srcdir)/stamp-gimpmarshal.h: gimpmarshal.list gimpmarshal.h
echo "#ifndef __GIMP_MARSHAL_H__" > xgen-gmh \
&& echo "#define __GIMP_MARSHAL_H__" >> xgen-gmh \
&& glib-genmarshal --nostdinc --prefix=gimp_cclosure_marshal $(srcdir)/gimpmarshal.list --header >> xgen-gmh \
&& echo "#endif /* __GIMP_MARSHAL_H__ */" >> xgen-gmh \
&& (cmp -s xgen-gmh $(srcdir)/gimpmarshal.h || cp xgen-gmh $(srcdir)/gimpmarshal.h) \
&& rm -f xgen-gmh xgen-gmh~ \
&& echo timestamp > $@
$(srcdir)/gimpmarshal.c: $(srcdir)/stamp-gimpmarshal.h
echo "#include <glib.h>" > xgen-gmc \
&& echo "#include <glib-object.h>" >> xgen-gmc \
&& echo "#include \"gimpmarshal.h\"" >> xgen-gmc \
&& glib-genmarshal --nostdinc --prefix=gimp_cclosure_marshal $(srcdir)/gimpmarshal.list --body >> xgen-gmc \
&& cp xgen-gmc $(srcdir)/gimpmarshal.c \
&& rm -f xgen-gmc xgen-gmc~
.PHONY: files

37
app/core/gimp-transform-region.c
View File

@ -136,14 +136,16 @@ static void gimp_transform_tool_draw (GimpDrawTool *draw_too
static TranInfo old_trans_info;
InfoDialog *transform_info = NULL;
static gboolean transform_info_inited = FALSE;
static GimpDrawToolClass *parent_class = NULL;
static guint gimp_transform_tool_signals[LAST_SIGNAL] = { 0 };
static GimpDrawToolClass *parent_class = NULL;
static guint gimp_transform_tool_signals[LAST_SIGNAL] = { 0 };
GtkType
GType
gimp_transform_tool_get_type (void)
{
static GtkType tool_type = 0;
static GType tool_type = 0;
if (! tool_type)
{
@ -176,21 +178,18 @@ gimp_transform_tool_class_init (GimpTransformToolClass *klass)
tool_class = (GimpToolClass *) klass;
draw_class = (GimpDrawToolClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DRAW_TOOL);
parent_class = g_type_class_peek_parent (klass);
gimp_transform_tool_signals[TRANSFORM] =
gtk_signal_new ("transform",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpTransformToolClass,
transform),
gimp_marshal_POINTER__POINTER_INT,
GTK_TYPE_POINTER, 2,
GTK_TYPE_POINTER,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_transform_tool_signals,
LAST_SIGNAL);
g_signal_new ("transform",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpTransformToolClass, transform),
NULL, NULL,
gimp_cclosure_marshal_POINTER__POINTER_INT,
G_TYPE_POINTER, 2,
G_TYPE_POINTER,
G_TYPE_INT);
object_class->destroy = gimp_transform_tool_destroy;
@ -452,7 +451,7 @@ gimp_transform_tool_button_press (GimpTool *tool,
if (transform_info && !transform_info_inited)
{
GtkType tool_type;
GType tool_type;
tool_type =
gimp_context_get_tool (gimp_get_user_context (gdisp->gimage->gimp))->tool_type;
@ -611,7 +610,7 @@ gimp_transform_tool_doit (GimpTransformTool *gt_tool,
/* create and initialize the transform_undo structure */
tu = g_new0 (TransformUndo, 1);
tu->tool_ID = tool->ID;
tu->tool_type = GTK_OBJECT (tool)->klass->type;
tu->tool_type = G_TYPE_FROM_INSTANCE (tool);
for (i = 0; i < TRAN_INFO_SIZE; i++)
tu->trans_info[i] = old_trans_info[i];

7
app/core/gimp.c
View File

@ -97,7 +97,7 @@ gimp_class_init (GimpClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_OBJECT);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_destroy;
}
@ -258,6 +258,11 @@ gimp_new (void)
{
Gimp *gimp;
/* EEK */
g_type_class_ref (GIMP_TYPE_CONTEXT);
g_type_class_ref (GIMP_TYPE_CONTAINER);
g_type_class_ref (GIMP_TYPE_IMAGE);
gimp = gtk_type_new (GIMP_TYPE_GIMP);
return gimp;

8
app/core/gimp.h
View File

@ -30,10 +30,10 @@ typedef void (* GimpUnsetBusyFunc) (Gimp *gimp);
#define GIMP_TYPE_GIMP (gimp_get_type ())
#define GIMP(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_GIMP, Gimp))
#define GIMP_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GIMP, GimpClass))
#define GIMP_IS_GIMP(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_GIMP))
#define GIMP_IS_GIMP_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GIMP))
#define GIMP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_GIMP, Gimp))
#define GIMP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GIMP, GimpClass))
#define GIMP_IS_GIMP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_GIMP))
#define GIMP_IS_GIMP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GIMP))
typedef struct _GimpClass GimpClass;

31
app/core/gimpbrush-load.c
View File

@ -82,10 +82,10 @@ static guint brush_signals[LAST_SIGNAL] = { 0 };
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_brush_get_type (void)
{
static GtkType type = 0;
static GType type = 0;
if (! type)
{
@ -117,18 +117,16 @@ gimp_brush_class_init (GimpBrushClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
brush_signals[SPACING_CHANGED] =
gtk_signal_new ("spacing_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpBrushClass,
spacing_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, brush_signals, LAST_SIGNAL);
g_signal_new ("spacing_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpBrushClass, spacing_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->destroy = gimp_brush_destroy;
@ -386,7 +384,6 @@ gimp_brush_get_pixmap (const GimpBrush *brush)
gint
gimp_brush_get_spacing (const GimpBrush *brush)
{
g_return_val_if_fail (brush != NULL, 0);
g_return_val_if_fail (GIMP_IS_BRUSH (brush), 0);
return brush->spacing;
@ -396,7 +393,6 @@ void
gimp_brush_set_spacing (GimpBrush *brush,
gint spacing)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
if (brush->spacing != spacing)
@ -410,10 +406,9 @@ gimp_brush_set_spacing (GimpBrush *brush,
void
gimp_brush_spacing_changed (GimpBrush *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
gtk_signal_emit (GTK_OBJECT (brush), brush_signals[SPACING_CHANGED]);
g_signal_emit (G_OBJECT (brush), brush_signals[SPACING_CHANGED], 0);
}
GimpBrush *
@ -490,7 +485,7 @@ gimp_brush_load_brush (gint fd,
g_message (_("GIMP brush file appears to be truncated: \"%s\"."),
filename);
g_free (name);
gtk_object_unref (GTK_OBJECT (brush));
g_object_unref (G_OBJECT (brush));
return NULL;
}
break;
@ -509,7 +504,7 @@ gimp_brush_load_brush (gint fd,
g_message (_("GIMP brush file appears to be truncated: \"%s\"."),
filename);
g_free (name);
gtk_object_unref (GTK_OBJECT (brush));
g_object_unref (G_OBJECT (brush));
return NULL;
}
}

31
app/core/gimpbrush.c
View File

@ -82,10 +82,10 @@ static guint brush_signals[LAST_SIGNAL] = { 0 };
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_brush_get_type (void)
{
static GtkType type = 0;
static GType type = 0;
if (! type)
{
@ -117,18 +117,16 @@ gimp_brush_class_init (GimpBrushClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
brush_signals[SPACING_CHANGED] =
gtk_signal_new ("spacing_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpBrushClass,
spacing_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, brush_signals, LAST_SIGNAL);
g_signal_new ("spacing_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpBrushClass, spacing_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->destroy = gimp_brush_destroy;
@ -386,7 +384,6 @@ gimp_brush_get_pixmap (const GimpBrush *brush)
gint
gimp_brush_get_spacing (const GimpBrush *brush)
{
g_return_val_if_fail (brush != NULL, 0);
g_return_val_if_fail (GIMP_IS_BRUSH (brush), 0);
return brush->spacing;
@ -396,7 +393,6 @@ void
gimp_brush_set_spacing (GimpBrush *brush,
gint spacing)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
if (brush->spacing != spacing)
@ -410,10 +406,9 @@ gimp_brush_set_spacing (GimpBrush *brush,
void
gimp_brush_spacing_changed (GimpBrush *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH (brush));
gtk_signal_emit (GTK_OBJECT (brush), brush_signals[SPACING_CHANGED]);
g_signal_emit (G_OBJECT (brush), brush_signals[SPACING_CHANGED], 0);
}
GimpBrush *
@ -490,7 +485,7 @@ gimp_brush_load_brush (gint fd,
g_message (_("GIMP brush file appears to be truncated: \"%s\"."),
filename);
g_free (name);
gtk_object_unref (GTK_OBJECT (brush));
g_object_unref (G_OBJECT (brush));
return NULL;
}
break;
@ -509,7 +504,7 @@ gimp_brush_load_brush (gint fd,
g_message (_("GIMP brush file appears to be truncated: \"%s\"."),
filename);
g_free (name);
gtk_object_unref (GTK_OBJECT (brush));
g_object_unref (G_OBJECT (brush));
return NULL;
}
}

11
app/core/gimpbrush.h
View File

@ -31,10 +31,11 @@
#define GIMP_TYPE_BRUSH (gimp_brush_get_type ())
#define GIMP_BRUSH(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH, GimpBrush))
#define GIMP_BRUSH_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH, GimpBrushClass))
#define GIMP_IS_BRUSH(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_BRUSH))
#define GIMP_IS_BRUSH_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH))
#define GIMP_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BRUSH, GimpBrush))
#define GIMP_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH, GimpBrushClass))
#define GIMP_IS_BRUSH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BRUSH))
#define GIMP_IS_BRUSH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH))
#define GIMP_BRUSH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_BRUSH, GimpBrushClass))
typedef struct _GimpBrushClass GimpBrushClass;
@ -63,7 +64,7 @@ struct _GimpBrushClass
};
GtkType gimp_brush_get_type (void);
GType gimp_brush_get_type (void);
GimpData * gimp_brush_new (const gchar *name);
GimpData * gimp_brush_get_standard (void);

2
app/core/gimpbrushgenerated-load.c
View File

@ -94,7 +94,7 @@ gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_brush_generated_destroy;

2
app/core/gimpbrushgenerated-save.c
View File

@ -94,7 +94,7 @@ gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_brush_generated_destroy;

2
app/core/gimpbrushgenerated.c
View File

@ -94,7 +94,7 @@ gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_brush_generated_destroy;

8
app/core/gimpbrushgenerated.h
View File

@ -29,10 +29,10 @@
#define GIMP_TYPE_BRUSH_GENERATED (gimp_brush_generated_get_type ())
#define GIMP_BRUSH_GENERATED(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGenerated))
#define GIMP_BRUSH_GENERATED_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGeneratedClass))
#define GIMP_IS_BRUSH_GENERATED(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_BRUSH_GENERATED))
#define GIMP_IS_BRUSH_GENERATED_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_GENERATED))
#define GIMP_BRUSH_GENERATED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGenerated))
#define GIMP_BRUSH_GENERATED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGeneratedClass))
#define GIMP_IS_BRUSH_GENERATED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BRUSH_GENERATED))
#define GIMP_IS_BRUSH_GENERATED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_GENERATED))
typedef struct _GimpBrushGeneratedClass GimpBrushGeneratedClass;

2
app/core/gimpbrushpipe-load.c
View File

@ -189,7 +189,7 @@ gimp_brush_pipe_class_init (GimpBrushPipeClass *klass)
object_class = (GtkObjectClass *) klass;
brush_class = (GimpBrushClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
parent_class = g_type_class_peek_parent (klass);
brush_class->select_brush = gimp_brush_pipe_select_brush;
brush_class->want_null_motion = gimp_brush_pipe_want_null_motion;

2
app/core/gimpbrushpipe.c
View File

@ -189,7 +189,7 @@ gimp_brush_pipe_class_init (GimpBrushPipeClass *klass)
object_class = (GtkObjectClass *) klass;
brush_class = (GimpBrushClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
parent_class = g_type_class_peek_parent (klass);
brush_class->select_brush = gimp_brush_pipe_select_brush;
brush_class->want_null_motion = gimp_brush_pipe_want_null_motion;

8
app/core/gimpbrushpipe.h
View File

@ -28,10 +28,10 @@
#define GIMP_TYPE_BRUSH_PIPE (gimp_brush_pipe_get_type ())
#define GIMP_BRUSH_PIPE(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH_PIPE, GimpBrushPipe))
#define GIMP_BRUSH_PIPE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_PIPE, GimpBrushPipeClass))
#define GIMP_IS_BRUSH_PIPE(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_BRUSH_PIPE))
#define GIMP_IS_BRUSH_PIPE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_PIPE))
#define GIMP_BRUSH_PIPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BRUSH_PIPE, GimpBrushPipe))
#define GIMP_BRUSH_PIPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_PIPE, GimpBrushPipeClass))
#define GIMP_IS_BRUSH_PIPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BRUSH_PIPE))
#define GIMP_IS_BRUSH_PIPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BRUSH_PIPE))
typedef enum

2
app/core/gimpbuffer.c
View File

@ -78,7 +78,7 @@ gimp_buffer_class_init (GimpBufferClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_buffer_destroy;

8
app/core/gimpbuffer.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_BUFFER (gimp_buffer_get_type ())
#define GIMP_BUFFER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BUFFER, GimpBuffer))
#define GIMP_BUFFER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BUFFER, GimpBufferClass))
#define GIMP_IS_BUFFER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_BUFFER))
#define GIMP_IS_BUFFER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BUFFER))
#define GIMP_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BUFFER, GimpBuffer))
#define GIMP_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BUFFER, GimpBufferClass))
#define GIMP_IS_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BUFFER))
#define GIMP_IS_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BUFFER))
typedef struct _GimpBufferClass GimpBufferClass;

4
app/core/gimpchannel-combine.c
View File

@ -90,7 +90,7 @@ gimp_channel_class_init (GimpChannelClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_channel_destroy;
}
@ -1512,7 +1512,7 @@ gimp_channel_translate (GimpChannel *mask,
copy_region (&srcPR, &destPR);
/* free the temporary mask */
gtk_object_unref (GTK_OBJECT (tmp_mask));
g_object_unref (G_OBJECT (tmp_mask));
}
/* calculate new bounds */

8
app/core/gimpchannel-combine.h
View File

@ -28,10 +28,10 @@
#define GIMP_TYPE_CHANNEL (gimp_channel_get_type ())
#define GIMP_CHANNEL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CHANNEL, GimpChannel))
#define GIMP_CHANNEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CHANNEL, GimpChannelClass))
#define GIMP_IS_CHANNEL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CHANNEL))
#define GIMP_IS_CHANNEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CHANNEL))
#define GIMP_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CHANNEL, GimpChannel))
#define GIMP_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CHANNEL, GimpChannelClass))
#define GIMP_IS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CHANNEL))
#define GIMP_IS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CHANNEL))
typedef struct _GimpChannelClass GimpChannelClass;

4
app/core/gimpchannel.c
View File

@ -90,7 +90,7 @@ gimp_channel_class_init (GimpChannelClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_channel_destroy;
}
@ -1512,7 +1512,7 @@ gimp_channel_translate (GimpChannel *mask,
copy_region (&srcPR, &destPR);
/* free the temporary mask */
gtk_object_unref (GTK_OBJECT (tmp_mask));
g_object_unref (G_OBJECT (tmp_mask));
}
/* calculate new bounds */

8
app/core/gimpchannel.h
View File

@ -28,10 +28,10 @@
#define GIMP_TYPE_CHANNEL (gimp_channel_get_type ())
#define GIMP_CHANNEL(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CHANNEL, GimpChannel))
#define GIMP_CHANNEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CHANNEL, GimpChannelClass))
#define GIMP_IS_CHANNEL(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CHANNEL))
#define GIMP_IS_CHANNEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CHANNEL))
#define GIMP_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CHANNEL, GimpChannel))
#define GIMP_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CHANNEL, GimpChannelClass))
#define GIMP_IS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CHANNEL))
#define GIMP_IS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CHANNEL))
typedef struct _GimpChannelClass GimpChannelClass;

315
app/core/gimpcontainer.c
View File

@ -31,11 +31,11 @@
typedef struct _GimpContainerHandler
{
gchar *signame;
GtkSignalFunc func;
gpointer user_data;
gchar *signame;
GCallback callback;
gpointer callback_data;
GQuark quark; /* used to attach the signal id's of child signals */
GQuark quark; /* used to attach the signal id's of child signals */
} GimpContainerHandler;
@ -69,10 +69,10 @@ static guint container_signals[LAST_SIGNAL] = { 0 };
static GimpObjectClass *parent_class = NULL;
GtkType
GType
gimp_container_get_type (void)
{
static GtkType container_type = 0;
static GType container_type = 0;
if (! container_type)
{
@ -112,111 +112,109 @@ gimp_container_class_init (GimpContainerClass* klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_OBJECT);
parent_class = g_type_class_peek_parent (klass);
container_signals[ADD] =
gtk_signal_new ("add",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
add),
gtk_marshal_NONE__OBJECT,
GTK_TYPE_NONE, 1,
GIMP_TYPE_OBJECT);
g_signal_new ("add",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpContainerClass, add),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_OBJECT);
container_signals[REMOVE] =
gtk_signal_new ("remove",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
remove),
gtk_marshal_NONE__OBJECT,
GTK_TYPE_NONE, 1,
GIMP_TYPE_OBJECT);
g_signal_new ("remove",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpContainerClass, remove),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_OBJECT);
container_signals[REORDER] =
gtk_signal_new ("reorder",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
reorder),
gimp_marshal_NONE__OBJECT_INT,
GTK_TYPE_NONE, 2,
GIMP_TYPE_OBJECT,
GTK_TYPE_INT);
g_signal_new ("reorder",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpContainerClass, reorder),
NULL, NULL,
gimp_cclosure_marshal_VOID__OBJECT_INT,
G_TYPE_NONE, 2,
GIMP_TYPE_OBJECT,
G_TYPE_INT);
container_signals[HAVE] =
gtk_signal_new ("have",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
have),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
GIMP_TYPE_OBJECT);
g_signal_new ("have",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpContainerClass, have),
NULL, NULL,
gimp_cclosure_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN, 1,
GIMP_TYPE_OBJECT);
container_signals[FOREACH] =
gtk_signal_new ("foreach",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
foreach),
gtk_marshal_NONE__POINTER_POINTER,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
GTK_TYPE_POINTER);
g_signal_new ("foreach",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpContainerClass, foreach),
NULL, NULL,
gimp_cclosure_marshal_VOID__POINTER_POINTER,
G_TYPE_NONE, 2,
G_TYPE_POINTER,
G_TYPE_POINTER);
container_signals[GET_CHILD_BY_NAME] =
gtk_signal_new ("get_child_by_name",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
get_child_by_name),
gimp_marshal_POINTER__POINTER,
GIMP_TYPE_OBJECT, 1,
GTK_TYPE_POINTER);
g_signal_new ("get_child_by_name",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpContainerClass, get_child_by_name),
NULL, NULL,
gimp_cclosure_marshal_OBJECT__POINTER,
GIMP_TYPE_OBJECT, 1,
G_TYPE_POINTER);
container_signals[GET_CHILD_BY_INDEX] =
gtk_signal_new ("get_child_by_index",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
get_child_by_index),
gimp_marshal_POINTER__INT,
GIMP_TYPE_OBJECT, 1,
GTK_TYPE_INT);
g_signal_new ("get_child_by_index",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpContainerClass, get_child_by_index),
NULL, NULL,
gimp_cclosure_marshal_OBJECT__INT,
GIMP_TYPE_OBJECT, 1,
G_TYPE_INT);
container_signals[GET_CHILD_INDEX] =
gtk_signal_new ("get_child_index",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
get_child_index),
gtk_marshal_INT__POINTER,
GTK_TYPE_INT, 1,
GIMP_TYPE_OBJECT);
g_signal_new ("get_child_index",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpContainerClass, get_child_index),
NULL, NULL,
gimp_cclosure_marshal_INT__OBJECT,
G_TYPE_INT, 1,
GIMP_TYPE_OBJECT);
container_signals[FREEZE] =
gtk_signal_new ("freeze",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
freeze),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("freeze",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpContainerClass, freeze),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
container_signals[THAW] =
gtk_signal_new ("thaw",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
thaw),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("thaw",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpContainerClass, thaw),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, container_signals, LAST_SIGNAL);
object_class->destroy = gimp_container_destroy;
object_class->destroy = gimp_container_destroy;
klass->add = NULL;
klass->remove = NULL;
@ -259,7 +257,7 @@ gimp_container_child_destroy_callback (GtkObject *object,
gimp_container_remove (container, GIMP_OBJECT (object));
}
GtkType
GType
gimp_container_children_type (const GimpContainer *container)
{
return container->children_type;
@ -285,12 +283,10 @@ gimp_container_add (GimpContainer *container,
GList *list;
guint handler_id;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (GTK_CHECK_TYPE (object, container->children_type),
FALSE);
g_return_val_if_fail (g_type_instance_is_a ((GTypeInstance *) object,
container->children_type), FALSE);
if (gimp_container_have (container, object))
{
@ -303,13 +299,13 @@ gimp_container_add (GimpContainer *container,
{
handler = (GimpContainerHandler *) list->data;
handler_id = gtk_signal_connect (GTK_OBJECT (object),
handler->signame,
handler->func,
handler->user_data);
handler_id = g_signal_connect (G_OBJECT (object),
handler->signame,
handler->callback,
handler->callback_data);
gtk_object_set_data_by_id (GTK_OBJECT (object), handler->quark,
GUINT_TO_POINTER (handler_id));
g_object_set_qdata (G_OBJECT (object), handler->quark,
GUINT_TO_POINTER (handler_id));
}
switch (container->policy)
@ -320,15 +316,15 @@ gimp_container_add (GimpContainer *container,
break;
case GIMP_CONTAINER_POLICY_WEAK:
gtk_signal_connect (GTK_OBJECT (object), "destroy",
GTK_SIGNAL_FUNC (gimp_container_child_destroy_callback),
container);
g_signal_connect (G_OBJECT (object), "destroy",
G_CALLBACK (gimp_container_child_destroy_callback),
container);
break;
}
container->num_children++;
gtk_signal_emit (GTK_OBJECT (container), container_signals[ADD], object);
g_signal_emit (GTK_OBJECT (container), container_signals[ADD], 0, object);
return TRUE;
}
@ -341,12 +337,10 @@ gimp_container_remove (GimpContainer *container,
GList *list;
guint handler_id;
g_return_val_if_fail (container, FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (GTK_CHECK_TYPE (object, container->children_type),
FALSE);
g_return_val_if_fail (g_type_instance_is_a ((GTypeInstance *) object,
container->children_type), FALSE);
if (! gimp_container_have (container, object))
{
@ -360,13 +354,13 @@ gimp_container_remove (GimpContainer *container,
handler = (GimpContainerHandler *) list->data;
handler_id = GPOINTER_TO_UINT
(gtk_object_get_data_by_id (GTK_OBJECT (object), handler->quark));
(g_object_get_qdata (G_OBJECT (object), handler->quark));
if (handler_id)
{
gtk_signal_disconnect (GTK_OBJECT (object), handler_id);
g_signal_handler_disconnect (G_OBJECT (object), handler_id);
gtk_object_set_data_by_id (GTK_OBJECT (object), handler->quark, NULL);
g_object_set_qdata (G_OBJECT (object), handler->quark, NULL);
}
}
@ -379,17 +373,17 @@ gimp_container_remove (GimpContainer *container,
break;
case GIMP_CONTAINER_POLICY_WEAK:
gtk_signal_disconnect_by_func
(GTK_OBJECT (object),
GTK_SIGNAL_FUNC (gimp_container_child_destroy_callback),
g_signal_handlers_disconnect_by_func
(G_OBJECT (object),
G_CALLBACK (gimp_container_child_destroy_callback),
container);
break;
}
container->num_children--;
gtk_signal_emit (GTK_OBJECT (container), container_signals[REMOVE],
object);
g_signal_emit (GTK_OBJECT (container), container_signals[REMOVE], 0,
object);
gtk_object_unref (GTK_OBJECT (object));
@ -401,12 +395,10 @@ gimp_container_insert (GimpContainer *container,
GimpObject *object,
gint index)
{
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (GTK_CHECK_TYPE (object, container->children_type),
FALSE);
g_return_val_if_fail (g_type_instance_is_a ((GTypeInstance *) object,
container->children_type), FALSE);
g_return_val_if_fail (index >= -1 &&
index <= container->num_children, FALSE);
@ -431,12 +423,10 @@ gimp_container_reorder (GimpContainer *container,
GimpObject *object,
gint new_index)
{
g_return_val_if_fail (container, FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (GTK_CHECK_TYPE (object, container->children_type),
FALSE);
g_return_val_if_fail (g_type_instance_is_a ((GTypeInstance *) object,
container->children_type), FALSE);
g_return_val_if_fail (new_index >= -1 &&
new_index < container->num_children, FALSE);
@ -448,8 +438,8 @@ gimp_container_reorder (GimpContainer *container,
return FALSE;
}
gtk_signal_emit (GTK_OBJECT (container), container_signals[REORDER],
object, new_index);
g_signal_emit (G_OBJECT (container), container_signals[REORDER], 0,
object, new_index);
return TRUE;
}
@ -460,14 +450,13 @@ gimp_container_have (GimpContainer *container,
{
gboolean have = FALSE;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
if (container->num_children < 1)
return FALSE;
gtk_signal_emit (GTK_OBJECT (container), container_signals[HAVE],
object, &have);
g_signal_emit (G_OBJECT (container), container_signals[HAVE], 0,
object, &have);
return have;
}
@ -477,13 +466,12 @@ gimp_container_foreach (GimpContainer *container,
GFunc func,
gpointer user_data)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
g_return_if_fail (func != NULL);
if (container->num_children > 0)
gtk_signal_emit (GTK_OBJECT (container), container_signals[FOREACH],
func, user_data);
g_signal_emit (G_OBJECT (container), container_signals[FOREACH], 0,
func, user_data);
}
GimpObject *
@ -492,12 +480,11 @@ gimp_container_get_child_by_name (const GimpContainer *container,
{
GimpObject *object = NULL;
g_return_val_if_fail (container != NULL, NULL);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
g_return_val_if_fail (name != NULL, NULL);
gtk_signal_emit (GTK_OBJECT (container), container_signals[GET_CHILD_BY_NAME],
name, &object);
g_signal_emit (G_OBJECT (container), container_signals[GET_CHILD_BY_NAME], 0,
name, &object);
return object;
}
@ -508,12 +495,11 @@ gimp_container_get_child_by_index (const GimpContainer *container,
{
GimpObject *object = NULL;
g_return_val_if_fail (container != NULL, NULL);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
g_return_val_if_fail (index >= 0 && index < container->num_children, NULL);
gtk_signal_emit (GTK_OBJECT (container), container_signals[GET_CHILD_BY_INDEX],
index, &object);
g_signal_emit (G_OBJECT (container), container_signals[GET_CHILD_BY_INDEX], 0,
index, &object);
return object;
}
@ -524,13 +510,13 @@ gimp_container_get_child_index (const GimpContainer *container,
{
gint index = -1;
g_return_val_if_fail (container != NULL, -1);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), -1);
g_return_val_if_fail (object != NULL, -1);
g_return_val_if_fail (GTK_CHECK_TYPE (object, container->children_type), -1);
g_return_val_if_fail (g_type_instance_is_a ((GTypeInstance *) object,
container->children_type), -1);
gtk_signal_emit (GTK_OBJECT (container), container_signals[GET_CHILD_INDEX],
object, &index);
g_signal_emit (G_OBJECT (container), container_signals[GET_CHILD_INDEX], 0,
object, &index);
return index;
}
@ -538,32 +524,29 @@ gimp_container_get_child_index (const GimpContainer *container,
void
gimp_container_freeze (GimpContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
container->freeze_count++;
if (container->freeze_count == 1)
gtk_signal_emit (GTK_OBJECT (container), container_signals[FREEZE]);
g_signal_emit (G_OBJECT (container), container_signals[FREEZE], 0);
}
void
gimp_container_thaw (GimpContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
if (container->freeze_count > 0)
container->freeze_count--;
if (container->freeze_count == 0)
gtk_signal_emit (GTK_OBJECT (container), container_signals[THAW]);
g_signal_emit (G_OBJECT (container), container_signals[THAW], 0);
}
gboolean
gimp_container_frozen (GimpContainer *container)
{
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
return (container->freeze_count > 0) ? TRUE : FALSE;
@ -575,41 +558,39 @@ gimp_container_add_handler_foreach_func (GimpObject *object,
{
guint handler_id;
handler_id = gtk_signal_connect (GTK_OBJECT (object),
handler->signame,
handler->func,
handler->user_data);
handler_id = g_signal_connect (G_OBJECT (object),
handler->signame,
handler->callback,
handler->callback_data);
gtk_object_set_data_by_id (GTK_OBJECT (object), handler->quark,
GUINT_TO_POINTER (handler_id));
g_object_set_qdata (G_OBJECT (object), handler->quark,
GUINT_TO_POINTER (handler_id));
}
GQuark
gimp_container_add_handler (GimpContainer *container,
const gchar *signame,
GtkSignalFunc callback,
GCallback callback,
gpointer callback_data)
{
GimpContainerHandler *handler;
gchar *key;
g_return_val_if_fail (container != NULL, 0);
g_return_val_if_fail (GIMP_IS_CONTAINER (container), 0);
g_return_val_if_fail (signame != NULL, 0);
g_return_val_if_fail (gtk_signal_lookup (signame,
container->children_type), 0);
g_return_val_if_fail (g_signal_lookup (signame, container->children_type), 0);
g_return_val_if_fail (callback != NULL, 0);
handler = g_new (GimpContainerHandler, 1);
handler = g_new0 (GimpContainerHandler, 1);
/* create a unique key for this handler */
key = g_strdup_printf ("%s-%p", signame, handler);
handler->signame = g_strdup (signame);
handler->func = callback;
handler->user_data = callback_data;
handler->quark = g_quark_from_string (key);
handler->signame = g_strdup (signame);
handler->callback = callback;
handler->callback_data = callback_data;
handler->quark = g_quark_from_string (key);
g_free (key);
@ -629,14 +610,14 @@ gimp_container_remove_handler_foreach_func (GimpObject *object,
guint handler_id;
handler_id =
GPOINTER_TO_UINT (gtk_object_get_data_by_id (GTK_OBJECT (object),
handler->quark));
GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (object),
handler->quark));
if (handler_id)
{
gtk_signal_disconnect (GTK_OBJECT (object), handler_id);
g_signal_handler_disconnect (G_OBJECT (object), handler_id);
gtk_object_set_data_by_id (GTK_OBJECT (object), handler->quark, NULL);
g_object_set_qdata (G_OBJECT (object), handler->quark, NULL);
}
}

18
app/core/gimpcontainer.h
View File

@ -34,10 +34,10 @@ typedef enum
#define GIMP_TYPE_CONTAINER (gimp_container_get_type ())
#define GIMP_CONTAINER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CONTAINER, GimpContainer))
#define GIMP_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTAINER, GimpContainerClass))
#define GIMP_IS_CONTAINER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CONTAINER))
#define GIMP_IS_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTAINER))
#define GIMP_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CONTAINER, GimpContainer))
#define GIMP_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CONTAINER, GimpContainerClass))
#define GIMP_IS_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CONTAINER))
#define GIMP_IS_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTAINER))
typedef struct _GimpContainerClass GimpContainerClass;
@ -47,7 +47,7 @@ struct _GimpContainer
GimpObject parent_instance;
/* public, read-only */
GtkType children_type;
GType children_type;
GimpContainerPolicy policy;
gint num_children;
@ -83,9 +83,9 @@ struct _GimpContainerClass
};
GtkType gimp_container_get_type (void);
GType gimp_container_get_type (void);
GtkType gimp_container_children_type (const GimpContainer *container);
GType gimp_container_children_type (const GimpContainer *container);
GimpContainerPolicy gimp_container_policy (const GimpContainer *container);
gint gimp_container_num_children (const GimpContainer *container);
@ -119,8 +119,8 @@ gboolean gimp_container_frozen (GimpContainer *container);
GQuark gimp_container_add_handler (GimpContainer *container,
const gchar *signame,
GtkSignalFunc handler,
gpointer user_data);
GCallback callback,
gpointer callback_data);
void gimp_container_remove_handler (GimpContainer *container,
GQuark id);

788
app/core/gimpcontext.c
View File

File diff suppressed because it is too large Load Diff

22
app/core/gimpcontext.h
View File

@ -76,10 +76,10 @@ typedef enum
#define GIMP_TYPE_CONTEXT (gimp_context_get_type ())
#define GIMP_CONTEXT(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_CONTEXT, GimpContext))
#define GIMP_CONTEXT_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_CONTEXT, GimpContextClass))
#define GIMP_IS_CONTEXT(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CONTEXT))
#define GIMP_IS_CONTEXT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTEXT))
#define GIMP_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CONTEXT, GimpContext))
#define GIMP_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_CONTEXT, GimpContextClass))
#define GIMP_IS_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CONTEXT))
#define GIMP_IS_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CONTEXT))
typedef struct _GimpContextClass GimpContextClass;
@ -154,7 +154,7 @@ struct _GimpContextClass
};
GtkType gimp_context_get_type (void);
GType gimp_context_get_type (void);
GimpContext * gimp_context_new (Gimp *gimp,
const gchar *name,
@ -195,17 +195,17 @@ void gimp_context_copy_args (GimpContext *src,
GimpContextArgMask args_mask);
/* manipulate by GtkType */
GimpContextArgType gimp_context_type_to_arg (GtkType type);
const gchar * gimp_context_type_to_signal_name (GtkType type);
/* manipulate by GType */
GimpContextArgType gimp_context_type_to_arg (GType type);
const gchar * gimp_context_type_to_signal_name (GType type);
GimpObject * gimp_context_get_by_type (GimpContext *context,
GtkType type);
GType type);
void gimp_context_set_by_type (GimpContext *context,
GtkType type,
GType type,
GimpObject *object);
void gimp_context_changed_by_type (GimpContext *context,
GtkType type);
GType type);
/* image */

94
app/core/gimpdata.c
View File

@ -61,10 +61,10 @@ static guint data_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_data_get_type (void)
{
static GtkType data_type = 0;
static GType data_type = 0;
if (! data_type)
{
@ -95,54 +95,52 @@ gimp_data_class_init (GimpDataClass *klass)
object_class = (GtkObjectClass *) klass;
gimp_object_class = (GimpObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
data_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDataClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
data_signals[SAVE] =
gtk_signal_new ("save",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
save),
gtk_marshal_BOOL__NONE,
GTK_TYPE_BOOL, 0);
g_signal_new ("save",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpDataClass, save),
NULL, NULL,
gimp_cclosure_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
data_signals[GET_EXTENSION] =
gtk_signal_new ("get_extension",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
get_extension),
gimp_marshal_POINTER__NONE,
GTK_TYPE_POINTER, 0);
g_signal_new ("get_extension",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpDataClass, get_extension),
NULL, NULL,
gimp_cclosure_marshal_POINTER__VOID,
G_TYPE_POINTER, 0);
data_signals[DUPLICATE] =
gtk_signal_new ("duplicate",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
duplicate),
gimp_marshal_POINTER__NONE,
GTK_TYPE_POINTER, 0);
g_signal_new ("duplicate",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpDataClass, duplicate),
NULL, NULL,
gimp_cclosure_marshal_POINTER__VOID,
G_TYPE_POINTER, 0);
gtk_object_class_add_signals (object_class, data_signals, LAST_SIGNAL);
object_class->destroy = gimp_data_destroy;
object_class->destroy = gimp_data_destroy;
gimp_object_class->name_changed = gimp_data_name_changed;
klass->dirty = gimp_data_real_dirty;
klass->save = NULL;
klass->get_extension = NULL;
klass->duplicate = NULL;
klass->dirty = gimp_data_real_dirty;
klass->save = NULL;
klass->get_extension = NULL;
klass->duplicate = NULL;
}
static void
@ -179,7 +177,6 @@ gimp_data_save (GimpData *data)
{
gboolean success = FALSE;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
if (! data->filename)
@ -189,8 +186,8 @@ gimp_data_save (GimpData *data)
return FALSE;
}
gtk_signal_emit (GTK_OBJECT (data), data_signals[SAVE],
&success);
g_signal_emit (G_OBJECT (data), data_signals[SAVE], 0,
&success);
if (success)
data->dirty = FALSE;
@ -201,10 +198,9 @@ gimp_data_save (GimpData *data)
void
gimp_data_dirty (GimpData *data)
{
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
gtk_signal_emit (GTK_OBJECT (data), data_signals[DIRTY]);
g_signal_emit (G_OBJECT (data), data_signals[DIRTY], 0);
}
static void
@ -218,7 +214,6 @@ gimp_data_real_dirty (GimpData *data)
gboolean
gimp_data_delete_from_disk (GimpData *data)
{
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
g_return_val_if_fail (data->filename != NULL, FALSE);
@ -237,11 +232,10 @@ gimp_data_get_extension (GimpData *data)
{
const gchar *extension = NULL;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (GIMP_IS_DATA (data), NULL);
gtk_signal_emit (GTK_OBJECT (data), data_signals[GET_EXTENSION],
&extension);
g_signal_emit (G_OBJECT (data), data_signals[GET_EXTENSION], 0,
&extension);
return extension;
}
@ -250,7 +244,6 @@ void
gimp_data_set_filename (GimpData *data,
const gchar *filename)
{
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
g_free (data->filename);
@ -271,7 +264,6 @@ gimp_data_create_filename (GimpData *data,
gint unum = 1;
FILE *file;
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
g_return_if_fail (basename != NULL);
g_return_if_fail (data_path != NULL);
@ -318,8 +310,8 @@ gimp_data_duplicate (GimpData *data)
{
GimpData *new_data = NULL;
gtk_signal_emit (GTK_OBJECT (data), data_signals[DUPLICATE],
&new_data);
g_signal_emit (G_OBJECT (data), data_signals[DUPLICATE], 0,
&new_data);
return new_data;
}

11
app/core/gimpdata.h
View File

@ -27,10 +27,11 @@
#define GIMP_TYPE_DATA (gimp_data_get_type ())
#define GIMP_DATA(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DATA, GimpData))
#define GIMP_DATA_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA, GimpDataClass))
#define GIMP_IS_DATA(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DATA))
#define GIMP_IS_DATA_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA))
#define GIMP_DATA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DATA, GimpData))
#define GIMP_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA, GimpDataClass))
#define GIMP_IS_DATA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DATA))
#define GIMP_IS_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA))
#define GIMP_DATA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DATA, GimpDataClass))
typedef struct _GimpDataClass GimpDataClass;
@ -54,7 +55,7 @@ struct _GimpDataClass
};
GtkType gimp_data_get_type (void);
GType gimp_data_get_type (void);
gboolean gimp_data_save (GimpData *data);

2
app/core/gimpdatafactory.c
View File

@ -78,7 +78,7 @@ gimp_data_factory_class_init (GimpDataFactoryClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_OBJECT);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_data_factory_destroy;
}

8
app/core/gimpdatafactory.h
View File

@ -41,10 +41,10 @@ struct _GimpDataFactoryLoaderEntry
#define GIMP_TYPE_DATA_FACTORY (gimp_data_factory_get_type ())
#define GIMP_DATA_FACTORY(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DATA_FACTORY, GimpDataFactory))
#define GIMP_DATA_FACTORY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA_FACTORY, GimpDataFactoryClass))
#define GIMP_IS_DATA_FACTORY(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DATA_FACTORY))
#define GIMP_IS_DATA_FACTORY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA_FACTORY))
#define GIMP_DATA_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DATA_FACTORY, GimpDataFactory))
#define GIMP_DATA_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA_FACTORY, GimpDataFactoryClass))
#define GIMP_IS_DATA_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DATA_FACTORY))
#define GIMP_IS_DATA_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA_FACTORY))
typedef struct _GimpDataFactoryClass GimpDataFactoryClass;

8
app/core/gimpdatalist.c
View File

@ -86,7 +86,7 @@ gimp_data_list_class_init (GimpDataListClass *klass)
container_class = (GimpContainerClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_LIST);
parent_class = g_type_class_peek_parent (klass);
container_class->add = gimp_data_list_add;
container_class->remove = gimp_data_list_remove;
@ -124,7 +124,7 @@ gimp_data_list_remove (GimpContainer *container,
list = GIMP_LIST (container);
gtk_signal_disconnect_by_func (GTK_OBJECT (object),
gimp_data_list_object_renamed_callback,
G_CALLBACK (gimp_data_list_object_renamed_callback),
container);
list->list = g_list_remove (list->list, object);
@ -225,7 +225,7 @@ gimp_data_list_uniquefy_data_name (GimpDataList *data_list,
if (have)
gtk_signal_handler_block_by_func
(GTK_OBJECT (object),
gimp_data_list_object_renamed_callback,
G_CALLBACK (gimp_data_list_object_renamed_callback),
data_list);
gimp_object_set_name (object, new_name);
@ -233,7 +233,7 @@ gimp_data_list_uniquefy_data_name (GimpDataList *data_list,
if (have)
gtk_signal_handler_unblock_by_func
(GTK_OBJECT (object),
gimp_data_list_object_renamed_callback,
G_CALLBACK (gimp_data_list_object_renamed_callback),
data_list);
g_free (new_name);

8
app/core/gimpdatalist.h
View File

@ -27,10 +27,10 @@
#define GIMP_TYPE_DATA_LIST (gimp_data_list_get_type ())
#define GIMP_DATA_LIST(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DATA_LIST, GimpDataList))
#define GIMP_DATA_LIST_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_DATA_LIST, GimpDataListClass))
#define GIMP_IS_DATA_LIST(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DATA_LIST))
#define GIMP_IS_DATA_LIST_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA_LIST))
#define GIMP_DATA_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DATA_LIST, GimpDataList))
#define GIMP_DATA_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_DATA_LIST, GimpDataListClass))
#define GIMP_IS_DATA_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DATA_LIST))
#define GIMP_IS_DATA_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA_LIST))
typedef struct _GimpDataListClass GimpDataListClass;

57
app/core/gimpdrawable-blend.c
View File

@ -709,51 +709,60 @@ blend_options_new (void)
/* the blend mode menu */
options->blend_mode_w = gimp_option_menu_new2
(FALSE, gimp_menu_item_update,
&options->blend_mode, (gpointer) options->blend_mode_d,
(FALSE,
G_CALLBACK (gimp_menu_item_update),
&options->blend_mode,
GINT_TO_POINTER (options->blend_mode_d),
_("FG to BG (RGB)"), (gpointer) FG_BG_RGB_MODE, NULL,
_("FG to BG (HSV)"), (gpointer) FG_BG_HSV_MODE, NULL,
_("FG to Transparent"), (gpointer) FG_TRANS_MODE, NULL,
_("Custom Gradient"), (gpointer) CUSTOM_MODE, NULL,
_("FG to BG (RGB)"), GINT_TO_POINTER (FG_BG_RGB_MODE), NULL,
_("FG to BG (HSV)"), GINT_TO_POINTER (FG_BG_HSV_MODE), NULL,
_("FG to Transparent"), GINT_TO_POINTER (FG_TRANS_MODE), NULL,
_("Custom Gradient"), GINT_TO_POINTER (CUSTOM_MODE), NULL,
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Blend:"), 1.0, 0.5,
options->blend_mode_w, 1, TRUE);
/* the gradient type menu */
options->gradient_type_w = gimp_option_menu_new2
(FALSE, gradient_type_callback,
&options->gradient_type, (gpointer) options->gradient_type_d,
(FALSE,
G_CALLBACK (gradient_type_callback),
&options->gradient_type,
GINT_TO_POINTER (options->gradient_type_d),
_("Linear"), (gpointer) LINEAR, NULL,
_("Bi-Linear"), (gpointer) BILINEAR, NULL,
_("Radial"), (gpointer) RADIAL, NULL,
_("Square"), (gpointer) SQUARE, NULL,
_("Conical (symmetric)"), (gpointer) CONICAL_SYMMETRIC, NULL,
_("Conical (asymmetric)"), (gpointer) CONICAL_ASYMMETRIC, NULL,
_("Shapeburst (angular)"), (gpointer) SHAPEBURST_ANGULAR, NULL,
_("Shapeburst (spherical)"), (gpointer) SHAPEBURST_SPHERICAL, NULL,
_("Shapeburst (dimpled)"), (gpointer) SHAPEBURST_DIMPLED, NULL,
_("Spiral (clockwise)"), (gpointer) SPIRAL_CLOCKWISE, NULL,
_("Spiral (anticlockwise)"), (gpointer) SPIRAL_ANTICLOCKWISE, NULL,
_("Linear"), GINT_TO_POINTER (LINEAR), NULL,
_("Bi-Linear"), GINT_TO_POINTER (BILINEAR), NULL,
_("Radial"), GINT_TO_POINTER (RADIAL), NULL,
_("Square"), GINT_TO_POINTER (SQUARE), NULL,
_("Conical (symmetric)"), GINT_TO_POINTER (CONICAL_SYMMETRIC), NULL,
_("Conical (asymmetric)"), GINT_TO_POINTER (CONICAL_ASYMMETRIC), NULL,
_("Shapeburst (angular)"), GINT_TO_POINTER (SHAPEBURST_ANGULAR), NULL,
_("Shapeburst (spherical)"), GINT_TO_POINTER (SHAPEBURST_SPHERICAL), NULL,
_("Shapeburst (dimpled)"), GINT_TO_POINTER (SHAPEBURST_DIMPLED), NULL,
_("Spiral (clockwise)"), GINT_TO_POINTER (SPIRAL_CLOCKWISE), NULL,
_("Spiral (anticlockwise)"), GINT_TO_POINTER (SPIRAL_ANTICLOCKWISE), NULL,
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("Gradient:"), 1.0, 0.5,
options->gradient_type_w, 1, TRUE);
/* the repeat option */
options->repeat_w = gimp_option_menu_new2
(FALSE, gimp_menu_item_update,
&options->repeat, (gpointer) options->repeat_d,
(FALSE,
G_CALLBACK (gimp_menu_item_update),
&options->repeat,
GINT_TO_POINTER (options->repeat_d),
_("None"), (gpointer) REPEAT_NONE, NULL,
_("Sawtooth Wave"), (gpointer) REPEAT_SAWTOOTH, NULL,
_("Triangular Wave"), (gpointer) REPEAT_TRIANGULAR, NULL,
_("None"), GINT_TO_POINTER (REPEAT_NONE), NULL,
_("Sawtooth Wave"), GINT_TO_POINTER (REPEAT_SAWTOOTH), NULL,
_("Triangular Wave"), GINT_TO_POINTER (REPEAT_TRIANGULAR), NULL,
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Repeat:"), 1.0, 0.5,
options->repeat_w, 1, TRUE);

37
app/core/gimpdrawable-transform.c
View File

@ -136,14 +136,16 @@ static void gimp_transform_tool_draw (GimpDrawTool *draw_too
static TranInfo old_trans_info;
InfoDialog *transform_info = NULL;
static gboolean transform_info_inited = FALSE;
static GimpDrawToolClass *parent_class = NULL;
static guint gimp_transform_tool_signals[LAST_SIGNAL] = { 0 };
static GimpDrawToolClass *parent_class = NULL;
static guint gimp_transform_tool_signals[LAST_SIGNAL] = { 0 };
GtkType
GType
gimp_transform_tool_get_type (void)
{
static GtkType tool_type = 0;
static GType tool_type = 0;
if (! tool_type)
{
@ -176,21 +178,18 @@ gimp_transform_tool_class_init (GimpTransformToolClass *klass)
tool_class = (GimpToolClass *) klass;
draw_class = (GimpDrawToolClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DRAW_TOOL);
parent_class = g_type_class_peek_parent (klass);
gimp_transform_tool_signals[TRANSFORM] =
gtk_signal_new ("transform",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpTransformToolClass,
transform),
gimp_marshal_POINTER__POINTER_INT,
GTK_TYPE_POINTER, 2,
GTK_TYPE_POINTER,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_transform_tool_signals,
LAST_SIGNAL);
g_signal_new ("transform",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpTransformToolClass, transform),
NULL, NULL,
gimp_cclosure_marshal_POINTER__POINTER_INT,
G_TYPE_POINTER, 2,
G_TYPE_POINTER,
G_TYPE_INT);
object_class->destroy = gimp_transform_tool_destroy;
@ -452,7 +451,7 @@ gimp_transform_tool_button_press (GimpTool *tool,
if (transform_info && !transform_info_inited)
{
GtkType tool_type;
GType tool_type;
tool_type =
gimp_context_get_tool (gimp_get_user_context (gdisp->gimage->gimp))->tool_type;
@ -611,7 +610,7 @@ gimp_transform_tool_doit (GimpTransformTool *gt_tool,
/* create and initialize the transform_undo structure */
tu = g_new0 (TransformUndo, 1);
tu->tool_ID = tool->ID;
tu->tool_type = GTK_OBJECT (tool)->klass->type;
tu->tool_type = G_TYPE_FROM_INSTANCE (tool);
for (i = 0; i < TRAN_INFO_SIZE; i++)
tu->trans_info[i] = old_trans_info[i];

49
app/core/gimpdrawable.c
View File

@ -114,28 +114,25 @@ gimp_drawable_class_init (GimpDrawableClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_drawable_signals[VISIBILITY_CHANGED] =
gtk_signal_new ("visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDrawableClass,
visibility_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDrawableClass, visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_drawable_signals[REMOVED] =
gtk_signal_new ("removed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDrawableClass,
removed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, gimp_drawable_signals,
LAST_SIGNAL);
g_signal_new ("removed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpDrawableClass, removed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->destroy = gimp_drawable_destroy;
@ -183,13 +180,19 @@ gimp_drawable_destroy (GtkObject *object)
GINT_TO_POINTER (drawable->ID));
if (drawable->tiles)
tile_manager_destroy (drawable->tiles);
{
tile_manager_destroy (drawable->tiles);
drawable->tiles = NULL;
}
if (drawable->preview_cache)
gimp_preview_cache_invalidate (&drawable->preview_cache);
if (drawable->parasites)
gtk_object_unref (GTK_OBJECT (drawable->parasites));
{
g_object_unref (G_OBJECT (drawable->parasites));
drawable->parasites = NULL;
}
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
@ -656,7 +659,7 @@ gimp_drawable_removed (GimpDrawable *drawable)
g_return_if_fail (drawable != NULL);
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
gtk_signal_emit (GTK_OBJECT (drawable), gimp_drawable_signals[REMOVED]);
g_signal_emit (G_OBJECT (drawable), gimp_drawable_signals[REMOVED], 0);
}
gboolean
@ -732,8 +735,8 @@ gimp_drawable_set_visible (GimpDrawable *drawable,
{
drawable->visible = visible;
gtk_signal_emit (GTK_OBJECT (drawable),
gimp_drawable_signals[VISIBILITY_CHANGED]);
g_signal_emit (G_OBJECT (drawable),
gimp_drawable_signals[VISIBILITY_CHANGED], 0);
gimp_drawable_update (drawable,
0, 0,

8
app/core/gimpdrawable.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_DRAWABLE (gimp_drawable_get_type ())
#define GIMP_DRAWABLE(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DRAWABLE, GimpDrawable))
#define GIMP_IS_DRAWABLE(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DRAWABLE))
#define GIMP_DRAWABLE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE, GimpDrawableClass))
#define GIMP_IS_DRAWABLE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE))
#define GIMP_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DRAWABLE, GimpDrawable))
#define GIMP_IS_DRAWABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DRAWABLE))
#define GIMP_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE, GimpDrawableClass))
#define GIMP_IS_DRAWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE))
typedef struct _GimpDrawableClass GimpDrawableClass;

8
app/core/gimpgradient.c
View File

@ -69,10 +69,10 @@ static gdouble gimp_gradient_calc_sphere_decreasing_factor (gdouble middle,
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_gradient_get_type (void)
{
static GtkType gradient_type = 0;
static GType gradient_type = 0;
if (! gradient_type)
{
@ -105,7 +105,7 @@ gimp_gradient_class_init (GimpGradientClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_gradient_destroy;
@ -478,7 +478,6 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
gdouble middle;
GimpRGB rgb;
g_return_if_fail (gradient != NULL);
g_return_if_fail (GIMP_IS_GRADIENT (gradient));
g_return_if_fail (color != NULL);
@ -611,7 +610,6 @@ gimp_gradient_get_segment_at (GimpGradient *gradient,
{
GimpGradientSegment *seg;
g_return_val_if_fail (gradient != NULL, NULL);
g_return_val_if_fail (GIMP_IS_GRADIENT (gradient), NULL);
/* handle FP imprecision at the edges of the gradient */

10
app/core/gimpgradient.h
View File

@ -59,10 +59,10 @@ struct _GimpGradientSegment
#define GIMP_TYPE_GRADIENT (gimp_gradient_get_type ())
#define GIMP_GRADIENT(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_GRADIENT, GimpGradient))
#define GIMP_GRADIENT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GRADIENT, GimpGradientClass))
#define GIMP_IS_GRADIENT(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_GRADIENT))
#define GIMP_IS_GRADIENT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GRADIENT))
#define GIMP_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_GRADIENT, GimpGradient))
#define GIMP_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_GRADIENT, GimpGradientClass))
#define GIMP_IS_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_GRADIENT))
#define GIMP_IS_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_GRADIENT))
typedef struct _GimpGradientClass GimpGradientClass;
@ -83,7 +83,7 @@ struct _GimpGradientClass
};
GtkType gimp_gradient_get_type (void);
GType gimp_gradient_get_type (void);
GimpData * gimp_gradient_new (const gchar *name);
GimpData * gimp_gradient_get_standard (void);

313
app/core/gimpimage-guides.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpimage-guides.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

313
app/core/gimpimage-merge.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpimage-merge.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

313
app/core/gimpimage-projection.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpimage-projection.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

313
app/core/gimpimage-resize.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpimage-resize.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

313
app/core/gimpimage-scale.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpimage-scale.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

313
app/core/gimpimage.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpimage.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

120
app/core/gimplayer.c
View File

@ -113,60 +113,58 @@ gimp_layer_class_init (GimpLayerClass *klass)
drawable_class = (GimpDrawableClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE);
parent_class = g_type_class_peek_parent (klass);
layer_signals[OPACITY_CHANGED] =
gtk_signal_new ("opacity_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerClass,
opacity_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("opacity_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerClass, opacity_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
layer_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
layer_signals[PRESERVE_TRANS_CHANGED] =
gtk_signal_new ("preserve_trans_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerClass,
preserve_trans_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("preserve_trans_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerClass, preserve_trans_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
layer_signals[LINKED_CHANGED] =
gtk_signal_new ("linked_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerClass,
linked_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("linked_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerClass, linked_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
layer_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, layer_signals, LAST_SIGNAL);
object_class->destroy = gimp_layer_destroy;
object_class->destroy = gimp_layer_destroy;
viewable_class->invalidate_preview = gimp_layer_invalidate_preview;
klass->mask_changed = NULL;
klass->mask_changed = NULL;
}
static void
@ -390,7 +388,7 @@ gimp_layer_copy (GimpLayer *layer,
}
/* copy the parasites */
gtk_object_unref (GTK_OBJECT (GIMP_DRAWABLE (new_layer)->parasites));
g_object_unref (G_OBJECT (GIMP_DRAWABLE (new_layer)->parasites));
GIMP_DRAWABLE (new_layer)->parasites =
gimp_parasite_list_copy (GIMP_DRAWABLE (layer)->parasites);
@ -475,10 +473,7 @@ gimp_layer_add_mask (GimpLayer *layer,
GimpImage *gimage;
LayerMaskUndo *lmu;
g_return_val_if_fail (layer != NULL, NULL);
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
g_return_val_if_fail (mask != NULL, NULL);
g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), NULL);
gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer));
@ -542,7 +537,7 @@ gimp_layer_add_mask (GimpLayer *layer,
undo_push_layer_mask (gimage, LAYER_MASK_ADD_UNDO, lmu);
}
gtk_signal_emit (GTK_OBJECT (layer), layer_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (layer), layer_signals[MASK_CHANGED], 0);
return layer->mask;
}
@ -638,18 +633,23 @@ gimp_layer_destroy (GtkObject *object)
layer = GIMP_LAYER (object);
/* if a layer mask exists, free it */
if (layer->mask)
gtk_object_unref (GTK_OBJECT (layer->mask));
{
g_object_unref (G_OBJECT (layer->mask));
layer->mask = NULL;
}
/* free the layer boundary if it exists */
if (layer->fs.segs)
g_free (layer->fs.segs);
{
g_free (layer->fs.segs);
layer->fs.segs = NULL;
}
/* free the floating selection if it exists */
if (gimp_layer_is_floating_sel (layer))
{
tile_manager_destroy (layer->fs.backing_store);
layer->fs.backing_store = NULL;
}
if (GTK_OBJECT_CLASS (parent_class)->destroy)
@ -757,7 +757,7 @@ gimp_layer_apply_mask (GimpLayer *layer,
gimp_drawable_height (GIMP_DRAWABLE (layer)));
}
gtk_signal_emit (GTK_OBJECT (layer), layer_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (layer), layer_signals[MASK_CHANGED], 0);
}
void
@ -1383,7 +1383,6 @@ gimp_layer_get_mask (GimpLayer *layer)
gboolean
gimp_layer_has_alpha (GimpLayer *layer)
{
g_return_val_if_fail (layer != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
return GIMP_IMAGE_TYPE_HAS_ALPHA (GIMP_DRAWABLE (layer)->type);
@ -1392,7 +1391,6 @@ gimp_layer_has_alpha (GimpLayer *layer)
gboolean
gimp_layer_is_floating_sel (GimpLayer *layer)
{
g_return_val_if_fail (layer != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
return (layer->fs.drawable != NULL);
@ -1404,7 +1402,6 @@ gimp_layer_set_opacity (GimpLayer *layer,
{
gint layer_opacity;
g_return_if_fail (layer != NULL);
g_return_if_fail (GIMP_IS_LAYER (layer));
layer_opacity = (gint) (opacity * 255.999);
@ -1413,7 +1410,7 @@ gimp_layer_set_opacity (GimpLayer *layer,
{
layer->opacity = layer_opacity;
gtk_signal_emit (GTK_OBJECT (layer), layer_signals[OPACITY_CHANGED]);
g_signal_emit (G_OBJECT (layer), layer_signals[OPACITY_CHANGED], 0);
gimp_drawable_update (GIMP_DRAWABLE (layer),
0, 0,
@ -1425,7 +1422,6 @@ gimp_layer_set_opacity (GimpLayer *layer,
gdouble
gimp_layer_get_opacity (GimpLayer *layer)
{
g_return_val_if_fail (layer != NULL, 1.0);
g_return_val_if_fail (GIMP_IS_LAYER (layer), 1.0);
return (gdouble) layer->opacity / 255.0;
@ -1435,14 +1431,13 @@ void
gimp_layer_set_mode (GimpLayer *layer,
LayerModeEffects mode)
{
g_return_if_fail (layer != NULL);
g_return_if_fail (GIMP_IS_LAYER (layer));
if (layer->mode != mode)
{
layer->mode = mode;
gtk_signal_emit (GTK_OBJECT (layer), layer_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (layer), layer_signals[MODE_CHANGED], 0);
gimp_drawable_update (GIMP_DRAWABLE (layer),
0, 0,
@ -1454,7 +1449,6 @@ gimp_layer_set_mode (GimpLayer *layer,
LayerModeEffects
gimp_layer_get_mode (GimpLayer *layer)
{
g_return_val_if_fail (layer != NULL, NORMAL_MODE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), NORMAL_MODE);
return layer->mode;
@ -1464,22 +1458,20 @@ void
gimp_layer_set_preserve_trans (GimpLayer *layer,
gboolean preserve)
{
g_return_if_fail (layer != NULL);
g_return_if_fail (GIMP_IS_LAYER (layer));
if (layer->preserve_trans != preserve)
{
layer->preserve_trans = preserve ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (layer),
layer_signals[PRESERVE_TRANS_CHANGED]);
g_signal_emit (G_OBJECT (layer),
layer_signals[PRESERVE_TRANS_CHANGED], 0);
}
}
gboolean
gimp_layer_get_preserve_trans (GimpLayer *layer)
{
g_return_val_if_fail (layer != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
return layer->preserve_trans;
@ -1489,21 +1481,19 @@ void
gimp_layer_set_linked (GimpLayer *layer,
gboolean linked)
{
g_return_if_fail (layer != NULL);
g_return_if_fail (GIMP_IS_LAYER (layer));
if (layer->linked != linked)
{
layer->linked = linked ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (layer), layer_signals[LINKED_CHANGED]);
g_signal_emit (G_OBJECT (layer), layer_signals[LINKED_CHANGED], 0);
}
}
gboolean
gimp_layer_get_linked (GimpLayer *layer)
{
g_return_val_if_fail (layer != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
return layer->linked;

8
app/core/gimplayer.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
#define GIMP_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
typedef struct _GimpLayerClass GimpLayerClass;

65
app/core/gimplayermask.c
View File

@ -89,36 +89,34 @@ gimp_layer_mask_class_init (GimpLayerMaskClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_CHANNEL);
parent_class = g_type_class_peek_parent (klass);
layer_mask_signals[APPLY_CHANGED] =
gtk_signal_new ("apply_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerMaskClass,
apply_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("apply_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerMaskClass, apply_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
layer_mask_signals[EDIT_CHANGED] =
gtk_signal_new ("edit_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerMaskClass,
edit_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("edit_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerMaskClass, edit_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
layer_mask_signals[SHOW_CHANGED] =
gtk_signal_new ("show_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpLayerMaskClass,
show_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, layer_mask_signals, LAST_SIGNAL);
g_signal_new ("show_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpLayerMaskClass, show_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->destroy = gimp_layer_mask_destroy;
}
@ -138,7 +136,6 @@ gimp_layer_mask_destroy (GtkObject *object)
{
GimpLayerMask *layer_mask;
g_return_if_fail (object != NULL);
g_return_if_fail (GIMP_IS_LAYER_MASK (object));
layer_mask = GIMP_LAYER_MASK (object);
@ -246,7 +243,6 @@ void
gimp_layer_mask_set_apply (GimpLayerMask *layer_mask,
gboolean apply)
{
g_return_if_fail (layer_mask != NULL);
g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask));
if (layer_mask->apply_mask != apply)
@ -265,15 +261,14 @@ gimp_layer_mask_set_apply (GimpLayerMask *layer_mask,
gimp_drawable_height (drawable));
}
gtk_signal_emit (GTK_OBJECT (layer_mask),
layer_mask_signals[APPLY_CHANGED]);
g_signal_emit (G_OBJECT (layer_mask),
layer_mask_signals[APPLY_CHANGED], 0);
}
}
gboolean
gimp_layer_mask_get_apply (GimpLayerMask *layer_mask)
{
g_return_val_if_fail (layer_mask != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER_MASK (layer_mask), FALSE);
return layer_mask->apply_mask;
@ -283,22 +278,20 @@ void
gimp_layer_mask_set_edit (GimpLayerMask *layer_mask,
gboolean edit)
{
g_return_if_fail (layer_mask != NULL);
g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask));
if (layer_mask->edit_mask != edit)
{
layer_mask->edit_mask = edit;
gtk_signal_emit (GTK_OBJECT (layer_mask),
layer_mask_signals[EDIT_CHANGED]);
g_signal_emit (G_OBJECT (layer_mask),
layer_mask_signals[EDIT_CHANGED], 0);
}
}
gboolean
gimp_layer_mask_get_edit (GimpLayerMask *layer_mask)
{
g_return_val_if_fail (layer_mask != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER_MASK (layer_mask), FALSE);
return layer_mask->edit_mask;
@ -308,7 +301,6 @@ void
gimp_layer_mask_set_show (GimpLayerMask *layer_mask,
gboolean show)
{
g_return_if_fail (layer_mask != NULL);
g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask));
if (layer_mask->show_mask != show)
@ -327,15 +319,14 @@ gimp_layer_mask_set_show (GimpLayerMask *layer_mask,
gimp_drawable_height (drawable));
}
gtk_signal_emit (GTK_OBJECT (layer_mask),
layer_mask_signals[SHOW_CHANGED]);
g_signal_emit (G_OBJECT (layer_mask),
layer_mask_signals[SHOW_CHANGED], 0);
}
}
gboolean
gimp_layer_mask_get_show (GimpLayerMask *layer_mask)
{
g_return_val_if_fail (layer_mask != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_LAYER_MASK (layer_mask), FALSE);
return layer_mask->show_mask;

8
app/core/gimplayermask.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_LAYER_MASK (gimp_layer_mask_get_type ())
#define GIMP_LAYER_MASK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
#define GIMP_LAYER_MASK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
typedef struct _GimpLayerMaskClass GimpLayerMaskClass;

8
app/core/gimplist.c
View File

@ -56,10 +56,10 @@ static gint gimp_list_get_child_index (GimpContainer *container,
static GimpContainerClass *parent_class = NULL;
GtkType
GType
gimp_list_get_type (void)
{
static GtkType list_type = 0;
static GType list_type = 0;
if (! list_type)
{
@ -90,9 +90,9 @@ gimp_list_class_init (GimpListClass *klass)
object_class = (GtkObjectClass *) klass;
container_class = (GimpContainerClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_CONTAINER);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_list_destroy;
object_class->destroy = gimp_list_destroy;
container_class->add = gimp_list_add;
container_class->remove = gimp_list_remove;

8
app/core/gimplist.h
View File

@ -27,10 +27,10 @@
#define GIMP_TYPE_LIST (gimp_list_get_type ())
#define GIMP_LIST(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LIST, GimpList))
#define GIMP_LIST_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LIST, GimpListClass))
#define GIMP_IS_LIST(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LIST))
#define GIMP_IS_LIST_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LIST))
#define GIMP_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_LIST, GimpList))
#define GIMP_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LIST, GimpListClass))
#define GIMP_IS_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_LIST))
#define GIMP_IS_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LIST))
typedef struct _GimpListClass GimpListClass;

1120
app/core/gimpmarshal.c
View File

File diff suppressed because it is too large Load Diff

256
app/core/gimpmarshal.h
View File

@ -1,84 +1,208 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_MARSHAL_H__
#define __GIMP_MARSHAL_H__
G_BEGIN_DECLS
void gimp_marshal_NONE__INT_INT_INT_INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* BOOLEAN:OBJECT (./gimpmarshal.list:25) */
extern void gimp_cclosure_marshal_BOOLEAN__OBJECT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_NONE__INT_INT_INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* BOOLEAN:POINTER (./gimpmarshal.list:26) */
extern void gimp_cclosure_marshal_BOOLEAN__POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_NONE__INT_POINTER_POINTER (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* BOOLEAN:VOID (./gimpmarshal.list:27) */
extern void gimp_cclosure_marshal_BOOLEAN__VOID (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_NONE__OBJECT_INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* INT:OBJECT (./gimpmarshal.list:29) */
extern void gimp_cclosure_marshal_INT__OBJECT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_NONE__DOUBLE (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* INT:POINTER (./gimpmarshal.list:30) */
extern void gimp_cclosure_marshal_INT__POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_INT__POINTER (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* OBJECT:INT (./gimpmarshal.list:32) */
extern void gimp_cclosure_marshal_OBJECT__INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_POINTER__NONE (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* OBJECT:POINTER (./gimpmarshal.list:33) */
extern void gimp_cclosure_marshal_OBJECT__POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_POINTER__INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* POINTER:INT (./gimpmarshal.list:35) */
extern void gimp_cclosure_marshal_POINTER__INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_POINTER__INT_INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* POINTER:INT,INT (./gimpmarshal.list:36) */
extern void gimp_cclosure_marshal_POINTER__INT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_POINTER__POINTER (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* POINTER:OBJECT,INT (./gimpmarshal.list:37) */
extern void gimp_cclosure_marshal_POINTER__OBJECT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_POINTER__POINTER_INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* POINTER:POINTER (./gimpmarshal.list:38) */
extern void gimp_cclosure_marshal_POINTER__POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
void gimp_marshal_POINTER__POINTER_INT_INT (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* POINTER:POINTER,INT (./gimpmarshal.list:39) */
extern void gimp_cclosure_marshal_POINTER__POINTER_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* POINTER:POINTER,INT,INT (./gimpmarshal.list:40) */
extern void gimp_cclosure_marshal_POINTER__POINTER_INT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* POINTER:VOID (./gimpmarshal.list:41) */
extern void gimp_cclosure_marshal_POINTER__VOID (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:DOUBLE (./gimpmarshal.list:43) */
extern void gimp_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:INT,INT (./gimpmarshal.list:44) */
extern void gimp_cclosure_marshal_VOID__INT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:INT,INT,INT (./gimpmarshal.list:45) */
extern void gimp_cclosure_marshal_VOID__INT_INT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:INT,INT,INT,INT (./gimpmarshal.list:46) */
extern void gimp_cclosure_marshal_VOID__INT_INT_INT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:INT,POINTER (./gimpmarshal.list:47) */
extern void gimp_cclosure_marshal_VOID__INT_POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:INT,POINTER,POINTER (./gimpmarshal.list:48) */
extern void gimp_cclosure_marshal_VOID__INT_POINTER_POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:OBJECT,INT (./gimpmarshal.list:49) */
extern void gimp_cclosure_marshal_VOID__OBJECT_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:OBJECT,INT,POINTER (./gimpmarshal.list:50) */
extern void gimp_cclosure_marshal_VOID__OBJECT_INT_POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:OBJECT,POINTER (./gimpmarshal.list:51) */
extern void gimp_cclosure_marshal_VOID__OBJECT_POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:POINTER,INT (./gimpmarshal.list:52) */
extern void gimp_cclosure_marshal_VOID__POINTER_INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
/* VOID:POINTER,POINTER (./gimpmarshal.list:53) */
extern void gimp_cclosure_marshal_VOID__POINTER_POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
G_END_DECLS
#endif /* __GIMP_MARSHAL_H__ */

53
app/core/gimpmarshal.list Normal file
View File

@ -0,0 +1,53 @@
# see glib-genmarshal(1) for a detailed description of the file format,
# possible parameter types are:
# VOID indicates no return type, or no extra
# parameters. if VOID is used as the parameter
# list, no additional parameters may be present.
# BOOLEAN for boolean types (gboolean)
# CHAR for signed char types (gchar)
# UCHAR for unsigned char types (guchar)
# INT for signed integer types (gint)
# UINT for unsigned integer types (guint)
# LONG for signed long integer types (glong)
# ULONG for unsigned long integer types (gulong)
# ENUM for enumeration types (gint)
# FLAGS for flag enumeration types (guint)
# FLOAT for single-precision float types (gfloat)
# DOUBLE for double-precision float types (gdouble)
# STRING for string types (gchar*)
# BOXED for boxed (anonymous but reference counted) types (GBoxed*)
# POINTER for anonymous pointer types (gpointer)
# PARAM for GParamSpec or derived types (GParamSpec*)
# OBJECT for GObject or derived types (GObject*)
# NONE deprecated alias for VOID
# BOOL deprecated alias for BOOLEAN
BOOLEAN: OBJECT
BOOLEAN: POINTER
BOOLEAN: VOID
INT: OBJECT
INT: POINTER
OBJECT: INT
OBJECT: POINTER
POINTER: INT
POINTER: INT, INT
POINTER: OBJECT, INT
POINTER: POINTER
POINTER: POINTER, INT
POINTER: POINTER, INT, INT
POINTER: VOID
VOID: DOUBLE
VOID: INT, INT
VOID: INT, INT, INT
VOID: INT, INT, INT, INT
VOID: INT, POINTER
VOID: INT, POINTER, POINTER
VOID: OBJECT, INT
VOID: OBJECT, INT, POINTER
VOID: OBJECT, POINTER
VOID: POINTER, INT
VOID: POINTER, POINTER

36
app/core/gimpobject.c
View File

@ -57,10 +57,10 @@ static guint object_signals[LAST_SIGNAL] = { 0 };
static GtkObjectClass *parent_class = NULL;
GtkType
GType
gimp_object_get_type (void)
{
static GtkType object_type = 0;
static GType object_type = 0;
if (! object_type)
{
@ -89,27 +89,25 @@ gimp_object_class_init (GimpObjectClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GTK_TYPE_OBJECT);
parent_class = g_type_class_peek_parent (klass);
gtk_object_add_arg_type ("GimpObject::name", GTK_TYPE_STRING,
GTK_ARG_READWRITE, ARG_NAME);
object_signals[NAME_CHANGED] =
gtk_signal_new ("name_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpObjectClass,
name_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, object_signals, LAST_SIGNAL);
g_signal_new ("name_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpObjectClass, name_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->destroy = gimp_object_destroy;
object_class->set_arg = gimp_object_set_arg;
object_class->get_arg = gimp_object_get_arg;
klass->name_changed = NULL;
klass->name_changed = NULL;
}
static void
@ -125,8 +123,11 @@ gimp_object_destroy (GtkObject *object)
gimp_object = GIMP_OBJECT (object);
g_free (gimp_object->name);
gimp_object->name = NULL;
if (gimp_object->name)
{
g_free (gimp_object->name);
gimp_object->name = NULL;
}
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
@ -175,7 +176,6 @@ void
gimp_object_set_name (GimpObject *object,
const gchar *name)
{
g_return_if_fail (object);
g_return_if_fail (GIMP_IS_OBJECT (object));
if ((!object->name && !name) ||
@ -192,7 +192,6 @@ gimp_object_set_name (GimpObject *object,
const gchar *
gimp_object_get_name (const GimpObject *object)
{
g_return_val_if_fail (object, NULL);
g_return_val_if_fail (GIMP_IS_OBJECT (object), NULL);
return object->name;
@ -201,8 +200,7 @@ gimp_object_get_name (const GimpObject *object)
void
gimp_object_name_changed (GimpObject *object)
{
g_return_if_fail (object);
g_return_if_fail (GIMP_IS_OBJECT (object));
gtk_signal_emit (GTK_OBJECT (object), object_signals[NAME_CHANGED]);
g_signal_emit (G_OBJECT (object), object_signals[NAME_CHANGED], 0);
}

10
app/core/gimpobject.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_OBJECT (gimp_object_get_type ())
#define GIMP_OBJECT(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_OBJECT, GimpObject))
#define GIMP_OBJECT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OBJECT, GimpObjectClass))
#define GIMP_IS_OBJECT(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_OBJECT))
#define GIMP_IS_OBJECT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OBJECT))
#define GIMP_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_OBJECT, GimpObject))
#define GIMP_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_OBJECT, GimpObjectClass))
#define GIMP_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_OBJECT))
#define GIMP_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_OBJECT))
typedef struct _GimpObjectClass GimpObjectClass;
@ -47,7 +47,7 @@ struct _GimpObjectClass
};
GtkType gimp_object_get_type (void);
GType gimp_object_get_type (void);
void gimp_object_set_name (GimpObject *object,
const gchar *name);

26
app/core/gimppalette-load.c
View File

@ -58,10 +58,10 @@ static void gimp_palette_entry_free (GimpPaletteEntry *entry);
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_palette_get_type (void)
{
static GtkType palette_type = 0;
static GType palette_type = 0;
if (! palette_type)
{
@ -94,7 +94,7 @@ gimp_palette_class_init (GimpPaletteClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_palette_destroy;
@ -118,22 +118,18 @@ static void
gimp_palette_destroy (GtkObject *object)
{
GimpPalette *palette;
GimpPaletteEntry *entry;
GList *list;
g_return_if_fail (GIMP_IS_PALETTE (object));
palette = GIMP_PALETTE (object);
for (list = palette->colors; list; list = g_list_next (list))
if (palette->colors)
{
entry = (GimpPaletteEntry *) list->data;
gimp_palette_entry_free (entry);
g_list_foreach (palette->colors, (GFunc) gimp_palette_entry_free, NULL);
g_list_free (palette->colors);
palette->colors = NULL;
}
g_list_free (palette->colors);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
@ -294,7 +290,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -311,7 +307,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -340,7 +336,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -407,7 +403,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}

26
app/core/gimppalette-save.c
View File

@ -58,10 +58,10 @@ static void gimp_palette_entry_free (GimpPaletteEntry *entry);
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_palette_get_type (void)
{
static GtkType palette_type = 0;
static GType palette_type = 0;
if (! palette_type)
{
@ -94,7 +94,7 @@ gimp_palette_class_init (GimpPaletteClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_palette_destroy;
@ -118,22 +118,18 @@ static void
gimp_palette_destroy (GtkObject *object)
{
GimpPalette *palette;
GimpPaletteEntry *entry;
GList *list;
g_return_if_fail (GIMP_IS_PALETTE (object));
palette = GIMP_PALETTE (object);
for (list = palette->colors; list; list = g_list_next (list))
if (palette->colors)
{
entry = (GimpPaletteEntry *) list->data;
gimp_palette_entry_free (entry);
g_list_foreach (palette->colors, (GFunc) gimp_palette_entry_free, NULL);
g_list_free (palette->colors);
palette->colors = NULL;
}
g_list_free (palette->colors);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
@ -294,7 +290,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -311,7 +307,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -340,7 +336,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -407,7 +403,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}

26
app/core/gimppalette.c
View File

@ -58,10 +58,10 @@ static void gimp_palette_entry_free (GimpPaletteEntry *entry);
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_palette_get_type (void)
{
static GtkType palette_type = 0;
static GType palette_type = 0;
if (! palette_type)
{
@ -94,7 +94,7 @@ gimp_palette_class_init (GimpPaletteClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_palette_destroy;
@ -118,22 +118,18 @@ static void
gimp_palette_destroy (GtkObject *object)
{
GimpPalette *palette;
GimpPaletteEntry *entry;
GList *list;
g_return_if_fail (GIMP_IS_PALETTE (object));
palette = GIMP_PALETTE (object);
for (list = palette->colors; list; list = g_list_next (list))
if (palette->colors)
{
entry = (GimpPaletteEntry *) list->data;
gimp_palette_entry_free (entry);
g_list_foreach (palette->colors, (GFunc) gimp_palette_entry_free, NULL);
g_list_free (palette->colors);
palette->colors = NULL;
}
g_list_free (palette->colors);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
@ -294,7 +290,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -311,7 +307,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -340,7 +336,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}
@ -407,7 +403,7 @@ gimp_palette_load (const gchar *filename)
filename, linenum);
fclose (fp);
gtk_object_sink (GTK_OBJECT (palette));
g_object_unref (G_OBJECT (palette));
return NULL;
}

10
app/core/gimppalette.h
View File

@ -27,10 +27,10 @@
#define GIMP_TYPE_PALETTE (gimp_palette_get_type ())
#define GIMP_PALETTE(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_PALETTE, GimpPalette))
#define GIMP_IS_PALETTE(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_PALETTE))
#define GIMP_PALETTE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PALETTE, GimpPaletteClass))
#define GIMP_IS_PALETTE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PALETTE))
#define GIMP_PALETTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PALETTE, GimpPalette))
#define GIMP_IS_PALETTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PALETTE))
#define GIMP_PALETTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PALETTE, GimpPaletteClass))
#define GIMP_IS_PALETTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PALETTE))
typedef struct _GimpPaletteEntry GimpPaletteEntry;
@ -63,7 +63,7 @@ struct _GimpPaletteClass
};
GtkType gimp_palette_get_type (void);
GType gimp_palette_get_type (void);
GimpData * gimp_palette_new (const gchar *name);
GimpData * gimp_palette_get_standard (void);

39
app/core/gimpparasitelist.c
View File

@ -56,32 +56,29 @@ gimp_parasite_list_class_init (GimpParasiteListClass *klass)
object_class = (GtkObjectClass *) klass;
parasite_list_signals[ADD] =
gtk_signal_new ("add",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpParasiteListClass,
add),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER);
g_signal_new ("add",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpParasiteListClass, add),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
parasite_list_signals[REMOVE] =
gtk_signal_new ("remove",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpParasiteListClass,
remove),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER);
gtk_object_class_add_signals (object_class, parasite_list_signals,
LAST_SIGNAL);
g_signal_new ("remove",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpParasiteListClass, remove),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
GTK_TYPE_POINTER);
object_class->destroy = gimp_parasite_list_destroy;
klass->add = NULL;
klass->remove = NULL;
klass->add = NULL;
klass->remove = NULL;
}
static void

4
app/core/gimpparasitelist.h
View File

@ -23,8 +23,8 @@
#define GIMP_TYPE_PARASITE_LIST (gimp_parasite_list_get_type ())
#define GIMP_PARASITE_LIST(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_PARASITE_LIST, GimpParasiteList))
#define GIMP_IS_PARASITE_LIST(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_PARASITE_LIST))
#define GIMP_PARASITE_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PARASITE_LIST, GimpParasiteList))
#define GIMP_IS_PARASITE_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PARASITE_LIST))
#define PARASITE_LIST_CLASS(class) GIMP_CHECK_CLASS_CAST (class, GIMP_TYPE_PARASITE_LIST, GimpParasiteListClass)

14
app/core/gimppattern-load.c
View File

@ -65,10 +65,10 @@ static GimpData * gimp_pattern_duplicate (GimpData *data);
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_pattern_get_type (void)
{
static GtkType pattern_type = 0;
static GType pattern_type = 0;
if (! pattern_type)
{
@ -101,7 +101,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_pattern_destroy;
@ -125,7 +125,10 @@ gimp_pattern_destroy (GtkObject *object)
pattern = GIMP_PATTERN (object);
if (pattern->mask)
temp_buf_free (pattern->mask);
{
temp_buf_free (pattern->mask);
pattern->mask = NULL;
}
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
@ -341,7 +344,7 @@ gimp_pattern_load (const gchar *filename)
error:
if (pattern)
gtk_object_unref (GTK_OBJECT (pattern));
g_object_unref (G_OBJECT (pattern));
else if (name)
g_free (name);
@ -353,7 +356,6 @@ gimp_pattern_load (const gchar *filename)
TempBuf *
gimp_pattern_get_mask (const GimpPattern *pattern)
{
g_return_val_if_fail (pattern != NULL, NULL);
g_return_val_if_fail (GIMP_IS_PATTERN (pattern), NULL);
return pattern->mask;

14
app/core/gimppattern.c
View File

@ -65,10 +65,10 @@ static GimpData * gimp_pattern_duplicate (GimpData *data);
static GimpDataClass *parent_class = NULL;
GtkType
GType
gimp_pattern_get_type (void)
{
static GtkType pattern_type = 0;
static GType pattern_type = 0;
if (! pattern_type)
{
@ -101,7 +101,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_pattern_destroy;
@ -125,7 +125,10 @@ gimp_pattern_destroy (GtkObject *object)
pattern = GIMP_PATTERN (object);
if (pattern->mask)
temp_buf_free (pattern->mask);
{
temp_buf_free (pattern->mask);
pattern->mask = NULL;
}
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
@ -341,7 +344,7 @@ gimp_pattern_load (const gchar *filename)
error:
if (pattern)
gtk_object_unref (GTK_OBJECT (pattern));
g_object_unref (G_OBJECT (pattern));
else if (name)
g_free (name);
@ -353,7 +356,6 @@ gimp_pattern_load (const gchar *filename)
TempBuf *
gimp_pattern_get_mask (const GimpPattern *pattern)
{
g_return_val_if_fail (pattern != NULL, NULL);
g_return_val_if_fail (GIMP_IS_PATTERN (pattern), NULL);
return pattern->mask;

10
app/core/gimppattern.h
View File

@ -27,10 +27,10 @@
#define GIMP_TYPE_PATTERN (gimp_pattern_get_type ())
#define GIMP_PATTERN(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_PATTERN, GimpPattern))
#define GIMP_PATTERN_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PATTERN, GimpPatternClass))
#define GIMP_IS_PATTERN(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_PATTERN))
#define GIMP_IS_PATTERN_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PATTERN))
#define GIMP_PATTERN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PATTERN, GimpPattern))
#define GIMP_PATTERN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PATTERN, GimpPatternClass))
#define GIMP_IS_PATTERN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PATTERN))
#define GIMP_IS_PATTERN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PATTERN))
typedef struct _GimpPatternClass GimpPatternClass;
@ -48,7 +48,7 @@ struct _GimpPatternClass
};
GtkType gimp_pattern_get_type (void);
GType gimp_pattern_get_type (void);
GimpData * gimp_pattern_new (const gchar *name);
GimpData * gimp_pattern_get_standard (void);

313
app/core/gimpprojection-construct.c
View File

@ -184,26 +184,29 @@ static guint gimp_image_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
GType
gimp_image_get_type (void)
{
static GtkType image_type = 0;
static GType image_type = 0;
if (! image_type)
{
GtkTypeInfo image_info =
static const GTypeInfo image_info =
{
"GimpImage",
sizeof (GimpImage),
sizeof (GimpImageClass),
(GtkClassInitFunc) gimp_image_class_init,
(GtkObjectInitFunc) gimp_image_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImage),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_init,
};
image_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &image_info);
image_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpImage",
&image_info, 0);
}
return image_type;
@ -220,134 +223,132 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_object_class = (GimpObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
gimp_image_signals[MODE_CHANGED] =
gtk_signal_new ("mode_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mode_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mode_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mode_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ALPHA_CHANGED] =
gtk_signal_new ("alpha_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
alpha_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("alpha_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, alpha_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[FLOATING_SELECTION_CHANGED] =
gtk_signal_new ("floating_selection_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
floating_selection_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("floating_selection_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, floating_selection_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_LAYER_CHANGED] =
gtk_signal_new ("active_layer_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_layer_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_layer_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_layer_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[ACTIVE_CHANNEL_CHANGED] =
gtk_signal_new ("active_channel_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
active_channel_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("active_channel_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, active_channel_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED] =
gtk_signal_new ("component_visibility_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_visibility_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_visibility_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_visibility_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[COMPONENT_ACTIVE_CHANGED] =
gtk_signal_new ("component_active_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
component_active_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("component_active_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, component_active_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[MASK_CHANGED] =
gtk_signal_new ("mask_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
mask_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("mask_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, mask_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[CLEAN] =
gtk_signal_new ("clean",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
clean),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("clean",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, clean),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("dirty",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, dirty),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gimp_image_signals[UPDATE] =
gtk_signal_new ("update",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
update),
gimp_marshal_NONE__INT_INT_INT_INT,
GTK_TYPE_NONE, 4,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, update),
NULL, NULL,
gimp_cclosure_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gimp_image_signals[COLORMAP_CHANGED] =
gtk_signal_new ("colormap_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
colormap_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
g_signal_new ("colormap_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, colormap_changed),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
gimp_image_signals[UNDO_EVENT] =
gtk_signal_new ("undo_event",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpImageClass,
undo_event),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, gimp_image_signals, LAST_SIGNAL);
g_signal_new ("undo_event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, undo_event),
NULL, NULL,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
object_class->destroy = gimp_image_destroy;
@ -466,25 +467,25 @@ gimp_image_destroy (GtkObject *object)
if (gimage->cmap)
g_free (gimage->cmap);
gtk_object_unref (GTK_OBJECT (gimage->layers));
gtk_object_unref (GTK_OBJECT (gimage->channels));
g_object_unref (G_OBJECT (gimage->layers));
g_object_unref (G_OBJECT (gimage->channels));
g_slist_free (gimage->layer_stack);
gtk_object_unref (GTK_OBJECT (gimage->selection_mask));
g_object_unref (G_OBJECT (gimage->selection_mask));
if (gimage->comp_preview)
temp_buf_free (gimage->comp_preview);
if (gimage->parasites)
gtk_object_unref (GTK_OBJECT (gimage->parasites));
g_object_unref (G_OBJECT (gimage->parasites));
g_list_foreach (gimage->guides, (GFunc) g_free, NULL);
g_list_free (gimage->guides);
undo_free (gimage);
gtk_object_unref (GTK_OBJECT (gimage->new_undo_stack));
gtk_object_unref (GTK_OBJECT (gimage->new_redo_stack));
g_object_unref (G_OBJECT (gimage->new_undo_stack));
g_object_unref (G_OBJECT (gimage->new_redo_stack));
}
static void
@ -1712,9 +1713,8 @@ gimp_image_colormap_changed (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (col < gimage->num_cols);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COLORMAP_CHANGED],
col);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[COLORMAP_CHANGED], 0,
col);
}
void
@ -1722,7 +1722,7 @@ gimp_image_mode_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MODE_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MODE_CHANGED], 0);
}
void
@ -1730,7 +1730,7 @@ gimp_image_mask_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[MASK_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[MASK_CHANGED], 0);
}
void
@ -1738,7 +1738,7 @@ gimp_image_alpha_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[ALPHA_CHANGED], 0);
}
void
@ -1746,8 +1746,8 @@ gimp_image_floating_selection_changed (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[FLOATING_SELECTION_CHANGED], 0);
}
void
@ -1759,8 +1759,8 @@ gimp_image_update (GimpImage *gimage,
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UPDATE],
x, y, width, height);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UPDATE], 0,
x, y, width, height);
}
@ -2556,9 +2556,9 @@ gimp_image_set_component_active (GimpImage *gimage,
*/
gimp_image_unset_active_channel (gimage);
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_ACTIVE_CHANGED], 0,
type);
}
}
@ -2624,9 +2624,9 @@ gimp_image_set_component_visible (GimpImage *gimage,
{
gimage->visible[pixel] = visible ? TRUE : FALSE;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED],
type);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[COMPONENT_VISIBILITY_CHANGED], 0,
type);
}
}
@ -2714,15 +2714,15 @@ gimp_image_set_active_layer (GimpImage *gimage,
{
gimage->active_layer = layer;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
if (gimage->active_channel)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
}
}
@ -2750,15 +2750,15 @@ gimp_image_set_active_channel (GimpImage *gimage,
{
gimage->active_channel = channel;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->active_layer)
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
@ -2779,8 +2779,8 @@ gimp_image_unset_active_channel (GimpImage *gimage)
{
gimage->active_channel = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_CHANNEL_CHANGED], 0);
if (gimage->layer_stack)
{
@ -3555,7 +3555,7 @@ gimp_image_remove_layer (GimpImage *gimage,
undo_push_layer (gimage, LAYER_REMOVE_UNDO, lu);
gtk_object_ref (GTK_OBJECT (layer));
g_object_ref (G_OBJECT (layer));
gimp_container_remove (gimage->layers, GIMP_OBJECT (layer));
gimage->layer_stack = g_slist_remove (gimage->layer_stack, layer);
@ -3578,15 +3578,15 @@ gimp_image_remove_layer (GimpImage *gimage,
{
gimage->active_layer = NULL;
gtk_signal_emit (GTK_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED]);
g_signal_emit (G_OBJECT (gimage),
gimp_image_signals[ACTIVE_LAYER_CHANGED], 0);
}
}
/* Send out REMOVED signal from layer */
gimp_drawable_removed (GIMP_DRAWABLE (layer));
gtk_object_unref (GTK_OBJECT (layer));
g_object_unref (G_OBJECT (layer));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3751,7 +3751,7 @@ gimp_image_remove_channel (GimpImage *gimage,
cu->prev_channel = gimp_image_get_active_channel (gimage);
undo_push_channel (gimage, CHANNEL_REMOVE_UNDO, cu);
gtk_object_ref (GTK_OBJECT (channel));
g_object_ref (G_OBJECT (channel));
gimp_container_remove (gimage->channels, GIMP_OBJECT (channel));
@ -3773,7 +3773,7 @@ gimp_image_remove_channel (GimpImage *gimage,
}
}
gtk_object_unref (GTK_OBJECT (channel));
g_object_unref (G_OBJECT (channel));
/* invalidate the composite preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
@ -3912,7 +3912,8 @@ void
gimp_image_undo_event (GimpImage *gimage,
gint event)
{
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], event);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[UNDO_EVENT], 0,
event);
}
@ -3952,7 +3953,8 @@ gimp_image_dirty (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty++;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[DIRTY]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[DIRTY], 0);
TRC (("dirty %d -> %d\n", gimage->dirty-1, gimage->dirty));
@ -3965,7 +3967,8 @@ gimp_image_clean (GimpImage *gimage)
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
gimage->dirty--;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
TRC (("clean %d -> %d\n", gimage->dirty+1, gimage->dirty));
@ -3979,7 +3982,7 @@ gimp_image_clean_all (GimpImage *gimage)
gimage->dirty = 0;
gtk_signal_emit (GTK_OBJECT (gimage), gimp_image_signals[CLEAN]);
g_signal_emit (G_OBJECT (gimage), gimp_image_signals[CLEAN], 0);
}
GimpLayer *

8
app/core/gimpprojection-construct.h
View File

@ -49,10 +49,10 @@ struct _GimpGuide
#define GIMP_TYPE_IMAGE (gimp_image_get_type ())
#define GIMP_IMAGE(obj) (GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
#define GIMP_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GIMP_TYPE_IMAGE, GimpImage))
#define GIMP_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GIMP_TYPE_IMAGE))
#define GIMP_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GIMP_TYPE_IMAGE, GimpImageClass))
#define GIMP_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE))
typedef struct _GimpImageClass GimpImageClass;

4
app/core/gimptoolinfo.c
View File

@ -79,7 +79,7 @@ gimp_tool_info_class_init (GimpToolInfoClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_DATA);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_tool_info_destroy;
@ -89,7 +89,7 @@ gimp_tool_info_class_init (GimpToolInfoClass *klass)
void
gimp_tool_info_init (GimpToolInfo *tool_info)
{
tool_info->tool_type = GTK_TYPE_NONE;
tool_info->tool_type = G_TYPE_NONE;
tool_info->blurb = NULL;
tool_info->help = NULL;

8
app/core/gimptoolinfo.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_TOOL_INFO (gimp_tool_info_get_type ())
#define GIMP_TOOL_INFO(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_TOOL_INFO, GimpToolInfo))
#define GIMP_IS_TOOL_INFO(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_TOOL_INFO))
#define GIMP_TOOL_INFO_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TOOL_INFO, GimpToolInfoClass))
#define GIMP_IS_TOOL_INFO_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_TOOL_INFO))
#define GIMP_TOOL_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_TOOL_INFO, GimpToolInfo))
#define GIMP_IS_TOOL_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_TOOL_INFO))
#define GIMP_TOOL_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TOOL_INFO, GimpToolInfoClass))
#define GIMP_IS_TOOL_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_TOOL_INFO))
typedef struct _GimpToolInfoClass GimpToolInfoClass;

40
app/core/gimpundo.c
View File

@ -87,34 +87,34 @@ gimp_undo_class_init (GimpUndoClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = g_type_class_peek_parent (klass);
undo_signals[PUSH] =
gtk_signal_new ("push",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpUndoClass, push),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE,
1, GTK_TYPE_POINTER);
g_signal_new ("push",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpUndoClass, push),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
undo_signals[POP] =
gtk_signal_new ("pop",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpUndoClass, pop),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE,
1, GTK_TYPE_POINTER);
g_signal_new ("pop",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpUndoClass, pop),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
gtk_object_class_add_signals (object_class, undo_signals, LAST_SIGNAL);
object_class->destroy = gimp_undo_destroy;
object_class->destroy = gimp_undo_destroy;
viewable_class->get_preview = gimp_undo_get_preview;
klass->push = gimp_undo_real_push;
klass->pop = gimp_undo_real_pop;
klass->push = gimp_undo_real_push;
klass->pop = gimp_undo_real_pop;
}
static void

8
app/core/gimpundo.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_UNDO (gimp_undo_get_type ())
#define GIMP_UNDO(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_UNDO, GimpUndo))
#define GIMP_UNDO_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_UNDO, GimpUndoClass))
#define GIMP_IS_UNDO(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_UNDO))
#define GIMP_IS_UNDO_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_UNDO))
#define GIMP_UNDO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_UNDO, GimpUndo))
#define GIMP_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_UNDO, GimpUndoClass))
#define GIMP_IS_UNDO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_UNDO))
#define GIMP_IS_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_UNDO))
typedef gboolean (* GimpUndoPopFunc) (GimpUndo *undo, GimpImage *gimage);

2
app/core/gimpundostack.c
View File

@ -75,7 +75,7 @@ gimp_undo_stack_class_init (GimpUndoStackClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_UNDO);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_undo_stack_destroy;
}

8
app/core/gimpundostack.h
View File

@ -24,10 +24,10 @@
#define GIMP_TYPE_UNDO_STACK (gimp_undo_stack_get_type ())
#define GIMP_UNDO_STACK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_UNDO_STACK, GimpUndoStack))
#define GIMP_UNDO_STACK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_UNDO_STACK, GimpUndoStackClass))
#define GIMP_IS_UNDO_STACK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_UNDO_STACK))
#define GIMP_IS_UNDO_STACK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_UNDO_STACK))
#define GIMP_UNDO_STACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_UNDO_STACK, GimpUndoStack))
#define GIMP_UNDO_STACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_UNDO_STACK, GimpUndoStackClass))
#define GIMP_IS_UNDO_STACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_UNDO_STACK))
#define GIMP_IS_UNDO_STACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_UNDO_STACK))
typedef struct _GimpUndoStackClass GimpUndoStackClass;

113
app/core/gimpviewable.c
View File

@ -52,10 +52,10 @@ static guint viewable_signals[LAST_SIGNAL] = { 0 };
static GimpObjectClass *parent_class = NULL;
GtkType
GType
gimp_viewable_get_type (void)
{
static GtkType viewable_type = 0;
static GType viewable_type = 0;
if (! viewable_type)
{
@ -84,51 +84,47 @@ gimp_viewable_class_init (GimpViewableClass *klass)
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_OBJECT);
parent_class = g_type_class_peek_parent (klass);
viewable_signals[INVALIDATE_PREVIEW] =
gtk_signal_new ("invalidate_preview",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpViewableClass,
invalidate_preview),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("invalidate_preview",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpViewableClass, invalidate_preview),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
viewable_signals[SIZE_CHANGED] =
gtk_signal_new ("size_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpViewableClass,
size_changed),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
g_signal_new ("size_changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpViewableClass, size_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
viewable_signals[GET_PREVIEW] =
gtk_signal_new ("get_preview",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpViewableClass,
get_preview),
gimp_marshal_POINTER__INT_INT,
GTK_TYPE_POINTER, 3,
GTK_TYPE_POINTER,
GTK_TYPE_INT,
GTK_TYPE_INT);
g_signal_new ("get_preview",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpViewableClass, get_preview),
NULL, NULL,
gimp_cclosure_marshal_POINTER__INT_INT,
G_TYPE_POINTER, 2,
G_TYPE_INT,
G_TYPE_INT);
viewable_signals[GET_NEW_PREVIEW] =
gtk_signal_new ("get_new_preview",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpViewableClass,
get_new_preview),
gimp_marshal_POINTER__INT_INT,
GTK_TYPE_POINTER, 3,
GTK_TYPE_POINTER,
GTK_TYPE_INT,
GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, viewable_signals, LAST_SIGNAL);
g_signal_new ("get_new_preview",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpViewableClass, get_new_preview),
NULL, NULL,
gimp_cclosure_marshal_POINTER__INT_INT,
G_TYPE_POINTER, 2,
G_TYPE_INT,
G_TYPE_INT);
klass->invalidate_preview = gimp_viewable_real_invalidate_preview;
klass->size_changed = NULL;
@ -144,28 +140,25 @@ gimp_viewable_init (GimpViewable *viewable)
void
gimp_viewable_invalidate_preview (GimpViewable *viewable)
{
g_return_if_fail (viewable);
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
gtk_signal_emit (GTK_OBJECT (viewable), viewable_signals[INVALIDATE_PREVIEW]);
g_signal_emit (G_OBJECT (viewable), viewable_signals[INVALIDATE_PREVIEW], 0);
}
void
gimp_viewable_size_changed (GimpViewable *viewable)
{
g_return_if_fail (viewable);
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
gtk_signal_emit (GTK_OBJECT (viewable), viewable_signals[SIZE_CHANGED]);
g_signal_emit (G_OBJECT (viewable), viewable_signals[SIZE_CHANGED], 0);
}
static void
gimp_viewable_real_invalidate_preview (GimpViewable *viewable)
{
g_return_if_fail (viewable);
g_return_if_fail (GIMP_IS_VIEWABLE (viewable));
gtk_object_set_data (GTK_OBJECT (viewable), "static-viewable-preview", NULL);
g_object_set_data (G_OBJECT (viewable), "static-viewable-preview", NULL);
}
TempBuf *
@ -175,20 +168,18 @@ gimp_viewable_get_preview (GimpViewable *viewable,
{
TempBuf *temp_buf = NULL;
g_return_val_if_fail (viewable, NULL);
g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), NULL);
g_return_val_if_fail (width > 0, NULL);
g_return_val_if_fail (height > 0, NULL);
gtk_signal_emit (GTK_OBJECT (viewable), viewable_signals[GET_PREVIEW],
width, height, &temp_buf);
g_signal_emit (G_OBJECT (viewable), viewable_signals[GET_PREVIEW], 0,
width, height, &temp_buf);
if (temp_buf)
return temp_buf;
temp_buf = gtk_object_get_data (GTK_OBJECT (viewable),
"static-viewable-preview");
temp_buf = g_object_get_data (G_OBJECT (viewable),
"static-viewable-preview");
if (temp_buf &&
temp_buf->width == width &&
@ -197,12 +188,12 @@ gimp_viewable_get_preview (GimpViewable *viewable,
temp_buf = NULL;
gtk_signal_emit (GTK_OBJECT (viewable), viewable_signals[GET_NEW_PREVIEW],
width, height, &temp_buf);
g_signal_emit (G_OBJECT (viewable), viewable_signals[GET_NEW_PREVIEW], 0,
width, height, &temp_buf);
gtk_object_set_data_full (GTK_OBJECT (viewable), "static-viewable-preview",
temp_buf,
(GtkDestroyNotify) temp_buf_free);
g_object_set_data_full (G_OBJECT (viewable), "static-viewable-preview",
temp_buf,
(GDestroyNotify) temp_buf_free);
return temp_buf;
}
@ -214,20 +205,18 @@ gimp_viewable_get_new_preview (GimpViewable *viewable,
{
TempBuf *temp_buf = NULL;
g_return_val_if_fail (viewable, NULL);
g_return_val_if_fail (GIMP_IS_VIEWABLE (viewable), NULL);
g_return_val_if_fail (width > 0, NULL);
g_return_val_if_fail (height > 0, NULL);
gtk_signal_emit (GTK_OBJECT (viewable), viewable_signals[GET_NEW_PREVIEW],
width, height, &temp_buf);
g_signal_emit (G_OBJECT (viewable), viewable_signals[GET_NEW_PREVIEW], 0,
width, height, &temp_buf);
if (temp_buf)
return temp_buf;
gtk_signal_emit (GTK_OBJECT (viewable), viewable_signals[GET_PREVIEW],
width, height, &temp_buf);
g_signal_emit (G_OBJECT (viewable), viewable_signals[GET_PREVIEW], 0,
width, height, &temp_buf);
if (temp_buf)
return temp_buf_copy (temp_buf, NULL);

10
app/core/gimpviewable.h
View File

@ -27,10 +27,10 @@
#define GIMP_TYPE_VIEWABLE (gimp_viewable_get_type ())
#define GIMP_VIEWABLE(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_VIEWABLE, GimpViewable))
#define GIMP_VIEWABLE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEWABLE, GimpViewableClass))
#define GIMP_IS_VIEWABLE(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_VIEWABLE))
#define GIMP_IS_VIEWABLE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEWABLE))
#define GIMP_VIEWABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VIEWABLE, GimpViewable))
#define GIMP_VIEWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VIEWABLE, GimpViewableClass))
#define GIMP_IS_VIEWABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VIEWABLE))
#define GIMP_IS_VIEWABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VIEWABLE))
typedef struct _GimpViewableClass GimpViewableClass;
@ -56,7 +56,7 @@ struct _GimpViewableClass
};
GtkType gimp_viewable_get_type (void);
GType gimp_viewable_get_type (void);
void gimp_viewable_invalidate_preview (GimpViewable *viewable);
void gimp_viewable_size_changed (GimpViewable *viewable);

278
app/devices.c
View File

@ -63,33 +63,33 @@ typedef struct _DeviceInfo DeviceInfo;
struct _DeviceInfo
{
guint32 device; /* device ID */
gchar *name;
GdkDevice *device;
gchar *name;
gshort is_present; /* is the device currently present */
gshort is_present; /* is the device currently present */
/* gdk_input options - for not present devices */
GdkInputMode mode;
gint num_axes;
GdkAxisUse *axes;
gint num_keys;
GdkDeviceKey *keys;
GdkInputMode mode;
gint num_axes;
GdkAxisUse *axes;
gint num_keys;
GdkDeviceKey *keys;
GimpContext *context;
GimpContext *context;
};
typedef struct _DeviceInfoDialog DeviceInfoDialog;
struct _DeviceInfoDialog
{
gint num_devices;
gint num_devices;
guint32 current;
guint32 *ids;
GdkDevice *current;
GdkDevice **devices;
GtkWidget *shell;
GtkWidget *table;
GtkWidget *shell;
GtkWidget *table;
GtkWidget **frames;
GtkWidget **tools;
@ -103,7 +103,7 @@ struct _DeviceInfoDialog
/* local functions */
static void input_dialog_able_callback (GtkWidget *widget,
guint32 deviceid,
GdkDevice *device,
gpointer data);
static void devices_write_rc_device (DeviceInfo *device_info,
@ -114,7 +114,7 @@ static void device_status_destroy_callback (void);
static void devices_close_callback (GtkWidget *widget,
gpointer data);
static void device_status_update (guint32 deviceid);
static void device_status_update (GdkDevice *device);
static void device_status_update_current (void);
static void device_status_drop_tool (GtkWidget *widget,
@ -139,11 +139,11 @@ static void device_status_data_changed (GimpContext *context,
gpointer data);
static void device_status_context_connect (GimpContext *context,
guint32 deviceid);
GdkDevice *device);
/* global data */
gint current_device = GDK_CORE_POINTER;
GdkDevice *current_device = NULL;
/* local data */
static GList *device_info_list = NULL;
@ -153,36 +153,19 @@ static DeviceInfoDialog *deviceD = NULL;
static gboolean suppress_update = FALSE;
/* utility functions for the device lists */
static GdkDeviceInfo *
gdk_device_info_get_by_id (guint32 deviceid)
{
GdkDeviceInfo *info;
GList *list;
for (list = gdk_input_list_devices (); list; list = g_list_next (list))
{
info = (GdkDeviceInfo *) list->data;
if (info->deviceid == deviceid)
return info;
}
return NULL;
}
/* utility functions for the device_info_list */
static DeviceInfo *
device_info_get_by_id (guint32 deviceid)
device_info_get_by_device (GdkDevice *device)
{
DeviceInfo *info;
GList *list;
GList *list;
for (list = device_info_list; list; list = g_list_next (list))
{
info = (DeviceInfo *) list->data;
if (info->device == deviceid)
if (info->device == device)
return info;
}
@ -193,7 +176,7 @@ static DeviceInfo *
device_info_get_by_name (gchar *name)
{
DeviceInfo *info;
GList *list;
GList *list;
for (list = device_info_list; list; list = g_list_next (list))
{
@ -269,34 +252,40 @@ input_dialog_create (void)
static void
input_dialog_able_callback (GtkWidget *widget,
guint32 deviceid,
GdkDevice *device,
gpointer data)
{
device_status_update (deviceid);
device_status_update (device);
}
void
devices_init (void)
{
GdkDeviceInfo *gdk_info;
DeviceInfo *device_info;
GList *list;
GdkDevice *device;
DeviceInfo *device_info;
GList *list;
current_device = gdk_core_pointer;
/* create device info structures for present devices */
for (list = gdk_input_list_devices (); list; list = g_list_next (list))
for (list = gdk_devices_list (); list; list = g_list_next (list))
{
gdk_info = (GdkDeviceInfo *) list->data;
device = (GdkDevice *) list->data;
device_info = g_new (DeviceInfo, 1);
device_info->device = gdk_info->deviceid;
device_info->name = g_strdup (gdk_info->name);
device_info->device = device;
device_info->name = g_strdup (device->name);
device_info->mode = device->mode;
device_info->is_present = TRUE;
device_info->mode = gdk_info->mode;
device_info->num_axes = gdk_info->num_axes;
device_info->num_axes = device->num_axes;
device_info->axes = NULL;
device_info->num_keys = device->num_axes;
device_info->keys = NULL;
device_info->context = gimp_create_context (the_gimp,
device_info->name, NULL);
gimp_context_define_args (device_info->context,
@ -305,7 +294,8 @@ devices_init (void)
gimp_context_copy_args (gimp_get_user_context (the_gimp),
device_info->context,
DEVICE_CONTEXT_MASK);
device_status_context_connect (device_info->context, device_info->device);
device_status_context_connect (device_info->context,
device_info->device);
device_info_list = g_list_append (device_info_list, device_info);
}
@ -323,7 +313,7 @@ devices_restore (void)
gimprc_parse_file (filename);
g_free (filename);
if ((device_info = device_info_get_by_id (current_device)) == NULL)
if ((device_info = device_info_get_by_device (current_device)) == NULL)
return;
suppress_update = TRUE;
@ -356,10 +346,12 @@ devices_rc_update (gchar *name,
/* Find device if we have it */
device_info = device_info_get_by_name (name);
if (!device_info)
if (! device_info)
{
device_info = g_new (DeviceInfo, 1);
device_info->name = g_strdup (name);
device_info->device = NULL;
device_info->name = g_strdup (name);
device_info->is_present = FALSE;
if (values & DEVICE_AXES)
@ -371,7 +363,7 @@ devices_rc_update (gchar *name,
else
{
device_info->num_axes = 0;
device_info->axes = NULL;
device_info->axes = NULL;
}
if (values & DEVICE_KEYS)
@ -380,6 +372,11 @@ devices_rc_update (gchar *name,
device_info->keys = g_new (GdkDeviceKey, num_keys);
memcpy (device_info->keys, axes, num_keys * sizeof (GdkDeviceKey));
}
else
{
device_info->num_keys = 0;
device_info->keys = NULL;
}
if (values & DEVICE_MODE)
device_info->mode = mode;
@ -394,31 +391,44 @@ devices_rc_update (gchar *name,
gimp_context_copy_args (gimp_get_user_context (the_gimp),
device_info->context,
DEVICE_CONTEXT_MASK);
device_status_context_connect (device_info->context, device_info->device);
device_status_context_connect (device_info->context,
device_info->device);
device_info_list = g_list_append (device_info_list, device_info);
}
else
{
GdkDeviceInfo *gdk_info;
GdkDevice *device;
gdk_info = gdk_device_info_get_by_id (device_info->device);
device = device_info->device;
if (gdk_info != NULL)
if (device)
{
if (values & DEVICE_MODE)
gdk_input_set_mode (gdk_info->deviceid, mode);
{
gdk_device_set_mode (device, mode);
}
if ((values & DEVICE_AXES) && num_axes >= gdk_info->num_axes)
gdk_input_set_axes (gdk_info->deviceid, axes);
if ((values & DEVICE_KEYS) && num_keys >= gdk_info->num_keys)
if ((values & DEVICE_AXES) && num_axes >= device->num_axes)
{
gint i;
for (i=0; i<MAX (num_keys, gdk_info->num_keys); i++)
gdk_input_set_key (gdk_info->deviceid, i,
keys[i].keyval, keys[i].modifiers);
for (i = 0; i < MIN (num_axes, device->num_axes); i++)
{
gdk_device_set_axis_use (device, i, axes[i]);
}
}
if ((values & DEVICE_KEYS) && num_keys >= device->num_keys)
{
gint i;
for (i = 0; i < MIN (num_keys, device->num_keys); i++)
{
gdk_device_set_key (device, i,
keys[i].keyval,
keys[i].modifiers);
}
}
}
else
@ -517,18 +527,18 @@ devices_rc_update (gchar *name,
}
void
select_device (guint32 new_device)
select_device (GdkDevice *new_device)
{
DeviceInfo *device_info;
DeviceInfo *device_info;
GimpContext *context;
device_info = device_info_get_by_id (current_device);
device_info = device_info_get_by_device (current_device);
gimp_context_unset_parent (device_info->context);
suppress_update = TRUE;
device_info = device_info_get_by_id (new_device);
device_info = device_info_get_by_device (new_device);
current_device = new_device;
@ -542,22 +552,22 @@ select_device (guint32 new_device)
device_status_update_current ();
}
gint
gboolean
devices_check_change (GdkEvent *event)
{
guint32 device;
GdkDevice *device;
switch (event->type)
{
case GDK_MOTION_NOTIFY:
device = ((GdkEventMotion *)event)->deviceid;
device = ((GdkEventMotion *) event)->device;
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
device = ((GdkEventButton *)event)->deviceid;
device = ((GdkEventButton *) event)->device;
break;
case GDK_PROXIMITY_OUT:
device = ((GdkEventProximity *)event)->deviceid;
device = ((GdkEventProximity *) event)->device;
break;
default:
device = current_device;
@ -568,26 +578,24 @@ devices_check_change (GdkEvent *event)
select_device (device);
return TRUE;
}
else
{
return FALSE;
}
return FALSE;
}
static void
devices_write_rc_device (DeviceInfo *device_info,
FILE *fp)
{
GdkDeviceInfo *gdk_info = NULL;
gchar *mode = NULL;
gint i;
GdkDevice *device = NULL;
gchar *mode = NULL;
gint i;
if (device_info->is_present)
gdk_info = gdk_device_info_get_by_id (device_info->device);
device = device_info->device;
fprintf (fp, "(device \"%s\"", device_info->name);
switch (gdk_info ? gdk_info->mode : device_info->mode)
switch (device ? device->mode : device_info->mode)
{
case GDK_MODE_DISABLED:
mode = "disabled";
@ -603,13 +611,13 @@ devices_write_rc_device (DeviceInfo *device_info,
fprintf (fp, "\n (mode %s)", mode);
fprintf (fp, "\n (axes %d",
gdk_info ? gdk_info->num_axes : device_info->num_axes);
device ? device->num_axes : device_info->num_axes);
for (i=0; i< (gdk_info ? gdk_info->num_axes : device_info->num_axes); i++)
for (i = 0; i < (device ? device->num_axes : device_info->num_axes); i++)
{
gchar *axis_type = NULL;
switch (gdk_info ? gdk_info->axes[i] : device_info->axes[i])
switch (device ? device->axes[i].use : device_info->axes[i])
{
case GDK_AXIS_IGNORE:
axis_type = "ignore";
@ -635,14 +643,14 @@ devices_write_rc_device (DeviceInfo *device_info,
fprintf (fp,")");
fprintf (fp, "\n (keys %d",
gdk_info ? gdk_info->num_keys : device_info->num_keys);
device ? device->num_keys : device_info->num_keys);
for (i = 0; i < (gdk_info ? gdk_info->num_keys : device_info->num_keys); i++)
for (i = 0; i < (device ? device->num_keys : device_info->num_keys); i++)
{
GdkModifierType modifiers = gdk_info ? gdk_info->keys[i].modifiers :
device_info->keys[i].modifiers;
guint keyval = gdk_info ? gdk_info->keys[i].keyval :
device_info->keys[i].keyval;
GdkModifierType modifiers = (device ? device->keys[i].modifiers :
device_info->keys[i].modifiers);
guint keyval = (device ? device->keys[i].keyval :
device_info->keys[i].keyval);
if (keyval)
{
@ -716,7 +724,7 @@ devices_write_rc (void)
gchar *filename;
FILE *fp;
device_info = device_info_get_by_id (current_device);
device_info = device_info_get_by_device (current_device);
filename = gimp_personal_rc_file ("devicerc");
fp = fopen (filename, "wb");
@ -773,7 +781,7 @@ device_status_create (void)
gtk_widget_realize (deviceD->table);
gtk_widget_show (deviceD->table);
deviceD->ids = g_new (guint32, deviceD->num_devices);
deviceD->devices = g_new (GdkDevice *, deviceD->num_devices);
deviceD->frames = g_new (GtkWidget *, deviceD->num_devices);
deviceD->tools = g_new (GtkWidget *, deviceD->num_devices);
deviceD->foregrounds = g_new (GtkWidget *, deviceD->num_devices);
@ -789,7 +797,7 @@ device_status_create (void)
device_info = (DeviceInfo *) list->data;
deviceD->ids[i] = device_info->device;
deviceD->devices[i] = device_info->device;
/* the device name */
@ -811,11 +819,10 @@ device_status_create (void)
gimp_preview_new_full (GIMP_VIEWABLE (gimp_context_get_tool (device_info->context)),
CELL_SIZE, CELL_SIZE, 0,
FALSE, FALSE, TRUE);
gtk_signal_connect_object_while_alive
(GTK_OBJECT (device_info->context),
"tool_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (deviceD->tools[i]));
gtk_signal_connect_object_while_alive (GTK_OBJECT (device_info->context),
"tool_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (deviceD->tools[i]));
gimp_gtk_drag_dest_set_by_type (deviceD->tools[i],
GTK_DEST_DEFAULT_ALL,
GIMP_TYPE_TOOL_INFO,
@ -823,7 +830,7 @@ device_status_create (void)
gimp_dnd_viewable_dest_set (deviceD->tools[i],
GIMP_TYPE_TOOL_INFO,
device_status_drop_tool,
GUINT_TO_POINTER (device_info->device));
device_info);
gtk_table_attach (GTK_TABLE (deviceD->table), deviceD->tools[i],
1, 2, i, i+1,
0, 0, 2, 2);
@ -838,7 +845,7 @@ device_status_create (void)
gtk_signal_connect (GTK_OBJECT (deviceD->foregrounds[i]),
"color_changed",
GTK_SIGNAL_FUNC (device_status_foreground_changed),
GUINT_TO_POINTER (device_info->device));
device_info);
gtk_table_attach (GTK_TABLE (deviceD->table),
deviceD->foregrounds[i],
2, 3, i, i+1,
@ -854,7 +861,7 @@ device_status_create (void)
gtk_signal_connect (GTK_OBJECT (deviceD->backgrounds[i]),
"color_changed",
GTK_SIGNAL_FUNC (device_status_background_changed),
GUINT_TO_POINTER (device_info->device));
device_info);
gtk_table_attach (GTK_TABLE (deviceD->table),
deviceD->backgrounds[i],
3, 4, i, i+1,
@ -878,7 +885,7 @@ device_status_create (void)
gimp_dnd_viewable_dest_set (deviceD->brushes[i],
GIMP_TYPE_BRUSH,
device_status_drop_brush,
GUINT_TO_POINTER (device_info->device));
device_info);
gtk_table_attach (GTK_TABLE (deviceD->table), deviceD->brushes[i],
4, 5, i, i+1,
0, 0, 2, 2);
@ -901,7 +908,7 @@ device_status_create (void)
gimp_dnd_viewable_dest_set (deviceD->patterns[i],
GIMP_TYPE_PATTERN,
device_status_drop_pattern,
GUINT_TO_POINTER (device_info->device));
device_info);
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->patterns[i],
5, 6, i, i+1,
0, 0, 2, 2);
@ -924,7 +931,7 @@ device_status_create (void)
gimp_dnd_viewable_dest_set (deviceD->gradients[i],
GIMP_TYPE_GRADIENT,
device_status_drop_gradient,
GUINT_TO_POINTER (device_info->device));
device_info);
gtk_table_attach (GTK_TABLE(deviceD->table), deviceD->gradients[i],
6, 7, i, i+1,
0, 0, 2, 2);
@ -932,7 +939,8 @@ device_status_create (void)
device_status_update (device_info->device);
}
deviceD->current = 0xffffffff; /* random, but doesn't matter */
deviceD->current = NULL;
device_status_update_current ();
gtk_signal_connect (GTK_OBJECT (deviceD->shell), "destroy",
@ -945,7 +953,7 @@ device_status_create (void)
static void
device_status_destroy_callback (void)
{
g_free (deviceD->ids);
g_free (deviceD->devices);
g_free (deviceD->frames);
g_free (deviceD->tools);
g_free (deviceD->foregrounds);
@ -985,10 +993,10 @@ device_status_update_current (void)
{
for (i = 0; i < deviceD->num_devices; i++)
{
if (deviceD->ids[i] == deviceD->current)
if (deviceD->devices[i] == deviceD->current)
gtk_frame_set_shadow_type (GTK_FRAME(deviceD->frames[i]),
GTK_SHADOW_OUT);
else if (deviceD->ids[i] == current_device)
else if (deviceD->devices[i] == current_device)
gtk_frame_set_shadow_type (GTK_FRAME(deviceD->frames[i]),
GTK_SHADOW_IN);
}
@ -998,9 +1006,8 @@ device_status_update_current (void)
}
void
device_status_update (guint32 deviceid)
device_status_update (GdkDevice *device)
{
GdkDeviceInfo *gdk_info;
DeviceInfo *device_info;
GimpRGB color;
guchar red, green, blue;
@ -1010,21 +1017,18 @@ device_status_update (guint32 deviceid)
if (!deviceD || suppress_update)
return;
if ((device_info = device_info_get_by_id (deviceid)) == NULL)
return;
if ((gdk_info = gdk_device_info_get_by_id (deviceid)) == NULL)
if ((device_info = device_info_get_by_device (device)) == NULL)
return;
for (i = 0; i < deviceD->num_devices; i++)
{
if (deviceD->ids[i] == deviceid)
if (deviceD->devices[i] == device)
break;
}
g_return_if_fail (i < deviceD->num_devices);
if (gdk_info->mode == GDK_MODE_DISABLED)
if (device->mode == GDK_MODE_DISABLED)
{
gtk_widget_hide (deviceD->frames[i]);
gtk_widget_hide (deviceD->tools[i]);
@ -1097,7 +1101,7 @@ device_status_drop_tool (GtkWidget *widget,
{
DeviceInfo *device_info;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_info = (DeviceInfo *) data;
if (device_info && device_info->is_present)
{
@ -1112,7 +1116,7 @@ device_status_foreground_changed (GtkWidget *widget,
DeviceInfo *device_info;
GimpRGB color;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_info = (DeviceInfo *) data;
if (device_info && device_info->is_present)
{
@ -1128,7 +1132,7 @@ device_status_background_changed (GtkWidget *widget,
DeviceInfo *device_info;
GimpRGB color;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_info = (DeviceInfo *) data;
if (device_info && device_info->is_present)
{
@ -1144,7 +1148,7 @@ device_status_drop_brush (GtkWidget *widget,
{
DeviceInfo *device_info;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_info = (DeviceInfo *) data;
if (device_info && device_info->is_present)
{
@ -1159,7 +1163,7 @@ device_status_drop_pattern (GtkWidget *widget,
{
DeviceInfo *device_info;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_info = (DeviceInfo *) data;
if (device_info && device_info->is_present)
{
@ -1174,7 +1178,7 @@ device_status_drop_gradient (GtkWidget *widget,
{
DeviceInfo *device_info;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_info = (DeviceInfo *) data;
if (device_info && device_info->is_present)
{
@ -1189,33 +1193,29 @@ device_status_data_changed (GimpContext *context,
gpointer dummy,
gpointer data)
{
DeviceInfo *device_info;
device_info = device_info_get_by_id (GPOINTER_TO_UINT (data));
device_status_update (device_info->device);
device_status_update ((GdkDevice *) data);
}
static void
device_status_context_connect (GimpContext *context,
guint32 deviceid)
GdkDevice *device)
{
gtk_signal_connect (GTK_OBJECT (context), "foreground_changed",
GTK_SIGNAL_FUNC (device_status_data_changed),
(gpointer) deviceid);
device);
gtk_signal_connect (GTK_OBJECT (context), "background_changed",
GTK_SIGNAL_FUNC (device_status_data_changed),
(gpointer) deviceid);
device);
gtk_signal_connect (GTK_OBJECT (context), "tool_changed",
GTK_SIGNAL_FUNC (device_status_data_changed),
(gpointer) deviceid);
device);
gtk_signal_connect (GTK_OBJECT (context), "brush_changed",
GTK_SIGNAL_FUNC (device_status_data_changed),
(gpointer) deviceid);
device);
gtk_signal_connect (GTK_OBJECT (context), "pattern_changed",
GTK_SIGNAL_FUNC (device_status_data_changed),
(gpointer) deviceid);
device);
gtk_signal_connect (GTK_OBJECT (context), "gradient_changed",
GTK_SIGNAL_FUNC (device_status_data_changed),
(gpointer) deviceid);
device);
}

6
app/devices.h
View File

@ -51,7 +51,7 @@ GtkWidget * device_status_create (void);
gint devices_check_change (GdkEvent *event);
/* Loads stored device settings (tool, cursor, ...) */
void select_device (guint32 device);
void select_device (GdkDevice *device);
/* Add information about one tool from rc file */
void devices_rc_update (gchar *name,
@ -72,8 +72,8 @@ void devices_rc_update (gchar *name,
void device_status_free (void);
/* Current device id */
extern gint current_device;
/* Current device */
extern GdkDevice *current_device;
#endif /* __DEVICES_H__ */

13
app/dialogs/about-dialog.c
View File

@ -120,15 +120,19 @@ about_dialog_create (void)
GtkWidget *aboutframe;
GtkWidget *label;
GtkWidget *alignment;
#if 0
GtkStyle *style;
GdkFont *font;
#endif
gint max_width;
gint i;
gchar *label_text;
if (! about_dialog)
{
about_dialog = gtk_window_new (GTK_WINDOW_DIALOG);
about_dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW (about_dialog),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_wmclass (GTK_WINDOW (about_dialog), "about_dialog", "Gimp");
gtk_window_set_title (GTK_WINDOW (about_dialog), _("About the GIMP"));
gtk_window_set_policy (GTK_WINDOW (about_dialog), FALSE, FALSE, FALSE);
@ -194,6 +198,10 @@ about_dialog_create (void)
gdk_window_set_background (logo_area->window, &logo_area->style->black);
/* this is a font, provide only one single font definition */
#ifdef __GNUC__
#warning FIXME: font description
#endif
#if 0
font = gdk_font_load (_("-*-helvetica-medium-r-normal--*-140-*-*-*-*-*-*"));
if (font)
{
@ -204,6 +212,7 @@ about_dialog_create (void)
gtk_widget_push_style (style);
gtk_style_unref (style);
}
#endif
label_text = g_strdup_printf (_("Version %s brought to you by"),
GIMP_VERSION);
label = gtk_label_new (label_text);
@ -216,7 +225,9 @@ about_dialog_create (void)
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
#if 0
gtk_widget_pop_style ();
#endif
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, TRUE, 0);

5
app/dialogs/color-dialog.c
View File

@ -821,13 +821,16 @@ color_notebook_page_switch (GtkWidget *widget,
guint page_num,
gpointer data)
{
GtkWidget *page_widget;
ColorNotebook *cnp;
ColorSelectorInstance *csel;
gint i;
cnp = (ColorNotebook *) data;
csel = gtk_object_get_data (GTK_OBJECT (page->child), "gimp_color_notebook");
page_widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (widget), page_num);
csel = g_object_get_data (G_OBJECT (page_widget), "gimp_color_notebook");
g_return_if_fail (cnp != NULL && csel != NULL);

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

@ -705,9 +705,9 @@ dialogs_path_list_view_new (GimpDialogFactory *factory,
view = paths_dialog_create ();
gtk_signal_connect (GTK_OBJECT (view), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&view);
g_signal_connect (G_OBJECT (view), "destroy",
G_CALLBACK (gtk_widget_destroyed),
&view);
dockable = dialogs_dockable_new (view,
"Path List", "Paths",
@ -738,9 +738,9 @@ dialogs_indexed_palette_new (GimpDialogFactory *factory,
dialogs_set_indexed_palette_context_func (GIMP_DOCKABLE (dockable), context);
gtk_signal_connect (GTK_OBJECT (view), "selected",
GTK_SIGNAL_FUNC (dialogs_indexed_palette_selected),
dockable);
g_signal_connect (G_OBJECT (view), "selected",
G_CALLBACK (dialogs_indexed_palette_selected),
dockable);
return dockable;
}
@ -812,8 +812,8 @@ dialogs_indexed_palette_selected (GimpColormapDialog *dialog,
{
GimpContext *context;
context = (GimpContext *) gtk_object_get_data (GTK_OBJECT (dialog),
"gimp-dialogs-context");
context = (GimpContext *) g_object_get_data (G_OBJECT (dialog),
"gimp-dialogs-context");
if (context)
{
@ -852,11 +852,10 @@ dialogs_brush_tab_func (GimpDockable *dockable,
size, size, 1,
FALSE, FALSE, FALSE);
gtk_signal_connect_object_while_alive
(GTK_OBJECT (context),
"brush_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (preview));
g_signal_connect_object (G_OBJECT (context), "brush_changed",
G_CALLBACK (gimp_preview_set_viewable),
G_OBJECT (preview),
G_CONNECT_SWAPPED);
return preview;
}
@ -876,11 +875,10 @@ dialogs_pattern_tab_func (GimpDockable *dockable,
size, size, 1,
FALSE, FALSE, FALSE);
gtk_signal_connect_object_while_alive
(GTK_OBJECT (context),
"pattern_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (preview));
g_signal_connect_object (G_OBJECT (context), "pattern_changed",
G_CALLBACK (gimp_preview_set_viewable),
G_OBJECT (preview),
G_CONNECT_SWAPPED);
return preview;
}
@ -900,11 +898,10 @@ dialogs_gradient_tab_func (GimpDockable *dockable,
size, size, 1,
FALSE, FALSE, FALSE);
gtk_signal_connect_object_while_alive
(GTK_OBJECT (context),
"gradient_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (preview));
g_signal_connect_object (G_OBJECT (context), "gradient_changed",
G_CALLBACK (gimp_preview_set_viewable),
G_OBJECT (preview),
G_CONNECT_SWAPPED);
return preview;
}
@ -924,11 +921,10 @@ dialogs_palette_tab_func (GimpDockable *dockable,
size, size, 1,
FALSE, FALSE, FALSE);
gtk_signal_connect_object_while_alive
(GTK_OBJECT (context),
"palette_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (preview));
g_signal_connect_object (G_OBJECT (context), "palette_changed",
G_CALLBACK (gimp_preview_set_viewable),
G_OBJECT (preview),
G_CONNECT_SWAPPED);
return preview;
}
@ -948,11 +944,10 @@ dialogs_tool_tab_func (GimpDockable *dockable,
size, size, 1,
FALSE, FALSE, FALSE);
gtk_signal_connect_object_while_alive
(GTK_OBJECT (context),
"tool_changed",
GTK_SIGNAL_FUNC (gimp_preview_set_viewable),
GTK_OBJECT (preview));
g_signal_connect_object (G_OBJECT (context), "tool_changed",
G_CALLBACK (gimp_preview_set_viewable),
G_OBJECT (preview),
G_CONNECT_SWAPPED);
return preview;
}
@ -963,8 +958,8 @@ dialogs_set_view_context_func (GimpDockable *dockable,
{
GimpContainerView *view;
view = (GimpContainerView *) gtk_object_get_data (GTK_OBJECT (dockable),
"gimp-dialogs-view");
view = (GimpContainerView *) g_object_get_data (G_OBJECT (dockable),
"gimp-dialogs-view");
if (view)
gimp_container_view_set_context (view, context);
@ -976,8 +971,10 @@ dialogs_set_editor_context_func (GimpDockable *dockable,
{
GimpContainerEditor *editor;
editor = (GimpContainerEditor *) gtk_object_get_data (GTK_OBJECT (dockable),
"gimp-dialogs-view");
editor = (GimpContainerEditor *) g_object_get_data (G_OBJECT (dockable),
"gimp-dialogs-view");
g_print ("dialogs_set_editor_context_func()\n");
if (editor)
gimp_container_view_set_context (editor->view, context);
@ -989,28 +986,23 @@ dialogs_set_drawable_context_func (GimpDockable *dockable,
{
GimpDrawableListView *view;
view = (GimpDrawableListView *) gtk_object_get_data (GTK_OBJECT (dockable),
"gimp-dialogs-view");
view = (GimpDrawableListView *) g_object_get_data (G_OBJECT (dockable),
"gimp-dialogs-view");
if (view)
{
GimpContext *old_context;
old_context = (GimpContext *) gtk_object_get_data (GTK_OBJECT (view),
"gimp-dialogs-context");
if (old_context)
if (dockable->context)
{
gtk_signal_disconnect_by_func (GTK_OBJECT (old_context),
GTK_SIGNAL_FUNC (dialogs_drawable_view_image_changed),
view);
g_signal_handlers_disconnect_by_func (G_OBJECT (dockable->context),
dialogs_drawable_view_image_changed,
view);
}
if (context)
{
gtk_signal_connect (GTK_OBJECT (context), "image_changed",
GTK_SIGNAL_FUNC (dialogs_drawable_view_image_changed),
view);
g_signal_connect (G_OBJECT (context), "image_changed",
G_CALLBACK (dialogs_drawable_view_image_changed),
view);
dialogs_drawable_view_image_changed (context,
gimp_context_get_image (context),
@ -1020,8 +1012,6 @@ dialogs_set_drawable_context_func (GimpDockable *dockable,
{
dialogs_drawable_view_image_changed (NULL, NULL, view);
}
gtk_object_set_data (GTK_OBJECT (view), "gimp-dialogs-context", context);
}
}
@ -1031,28 +1021,23 @@ dialogs_set_path_context_func (GimpDockable *dockable,
{
GtkWidget *view;
view = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (dockable),
"gimp-dialogs-view");
view = (GtkWidget *) g_object_get_data (G_OBJECT (dockable),
"gimp-dialogs-view");
if (view)
{
GimpContext *old_context;
old_context = (GimpContext *) gtk_object_get_data (GTK_OBJECT (view),
"gimp-dialogs-context");
if (old_context)
if (dockable->context)
{
gtk_signal_disconnect_by_func (GTK_OBJECT (old_context),
GTK_SIGNAL_FUNC (dialogs_path_view_image_changed),
view);
g_signal_handlers_disconnect_by_func (G_OBJECT (dockable->context),
dialogs_path_view_image_changed,
view);
}
if (context)
{
gtk_signal_connect (GTK_OBJECT (context), "image_changed",
GTK_SIGNAL_FUNC (dialogs_path_view_image_changed),
view);
g_signal_connect (G_OBJECT (context), "image_changed",
G_CALLBACK (dialogs_path_view_image_changed),
view);
dialogs_path_view_image_changed (context,
gimp_context_get_image (context),
@ -1062,8 +1047,6 @@ dialogs_set_path_context_func (GimpDockable *dockable,
{
dialogs_path_view_image_changed (NULL, NULL, view);
}
gtk_object_set_data (GTK_OBJECT (view), "gimp-dialogs-context", context);
}
}
@ -1073,28 +1056,23 @@ dialogs_set_indexed_palette_context_func (GimpDockable *dockable,
{
GimpColormapDialog *view;
view = (GimpColormapDialog *) gtk_object_get_data (GTK_OBJECT (dockable),
"gimp-dialogs-view");
view = (GimpColormapDialog *) g_object_get_data (G_OBJECT (dockable),
"gimp-dialogs-view");
if (view)
{
GimpContext *old_context;
old_context = (GimpContext *) gtk_object_get_data (GTK_OBJECT (view),
"gimp-dialogs-context");
if (old_context)
if (dockable->context)
{
gtk_signal_disconnect_by_func (GTK_OBJECT (old_context),
GTK_SIGNAL_FUNC (dialogs_indexed_palette_image_changed),
view);
g_signal_handlers_disconnect_by_func (G_OBJECT (dockable->context),
dialogs_indexed_palette_image_changed,
view);
}
if (context)
{
gtk_signal_connect (GTK_OBJECT (context), "image_changed",
GTK_SIGNAL_FUNC (dialogs_indexed_palette_image_changed),
view);
g_signal_connect (G_OBJECT (context), "image_changed",
G_CALLBACK (dialogs_indexed_palette_image_changed),
view);
dialogs_indexed_palette_image_changed (context,
gimp_context_get_image (context),
@ -1104,8 +1082,6 @@ dialogs_set_indexed_palette_context_func (GimpDockable *dockable,
{
dialogs_indexed_palette_image_changed (NULL, NULL, view);
}
gtk_object_set_data (GTK_OBJECT (view), "gimp-dialogs-context", context);
}
}
@ -1125,7 +1101,7 @@ dialogs_dockable_new (GtkWidget *widget,
gtk_container_add (GTK_CONTAINER (dockable), widget);
gtk_widget_show (widget);
gtk_object_set_data (GTK_OBJECT (dockable), "gimp-dialogs-view", widget);
g_object_set_data (G_OBJECT (dockable), "gimp-dialogs-view", widget);
return dockable;
}

6
app/dialogs/file-dialog-utils.c
View File

@ -68,9 +68,9 @@ file_dialog_update_name (PlugInProcDef *proc,
{
if (proc->extensions_list)
{
gchar *text;
gchar *last_dot;
GString *s;
const gchar *text;
gchar *last_dot;
GString *s;
text = gtk_entry_get_text (GTK_ENTRY (GTK_FILE_SELECTION (filesel)->selection_entry));
last_dot = strrchr (text, '.');

50
app/dialogs/file-open-dialog.c
View File

@ -63,8 +63,8 @@
/* local function prototypes */
static gint file_open_with_proc_and_display (gchar *filename,
gchar *raw_filename,
static gint file_open_with_proc_and_display (const gchar *filename,
const gchar *raw_filename,
PlugInProcDef *file_proc);
static void file_open_dialog_create (void);
static void file_open_genbutton_callback (GtkWidget *widget,
@ -156,7 +156,7 @@ file_open_dialog_show (void)
}
gint
file_open_with_display (gchar *filename)
file_open_with_display (const gchar *filename)
{
return file_open_with_proc_and_display (filename, filename, NULL);
}
@ -165,8 +165,8 @@ file_open_with_display (gchar *filename)
/* private functions */
static gint
file_open_with_proc_and_display (gchar *filename,
gchar *raw_filename,
file_open_with_proc_and_display (const gchar *filename,
const gchar *raw_filename,
PlugInProcDef *file_proc)
{
GimpImage *gimage;
@ -445,7 +445,7 @@ set_preview (const gchar *fullfname,
guchar *raw_thumb;
gint tnw,tnh, i;
gchar *pname;
gchar *fname;
const gchar *fname;
gchar *tname;
gchar *imginfo = NULL;
struct stat file_stat;
@ -581,7 +581,7 @@ static void
file_open_clistrow_callback (GtkWidget *widget,
gint row)
{
gchar *fullfname = NULL;
const gchar *fullfname;
fullfname = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fileload));
@ -602,7 +602,7 @@ file_open_genbutton_callback (GtkWidget *widget,
/* added for multi-file preview generation... */
GtkFileSelection *fs;
gchar *full_filename = NULL;
gchar *filedirname;
gchar *filedirname = NULL;
struct stat buf;
gint err;
@ -629,11 +629,12 @@ file_open_genbutton_callback (GtkWidget *widget,
/* Find a real base directory for the multiple selection */
gtk_file_selection_set_filename (fs, "");
filedirname= gtk_file_selection_get_filename (fs);
filedirname = g_strdup (gtk_file_selection_get_filename (fs));
if (filedirname[strlen (filedirname) - 1] == G_DIR_SEPARATOR)
filedirname[strlen (filedirname) - 1] = '\0';
while(list)
while (list)
{
full_filename = g_strconcat (filedirname, G_DIR_SEPARATOR_S,
(gchar *) list->data, NULL);
@ -641,7 +642,8 @@ file_open_genbutton_callback (GtkWidget *widget,
err = stat (full_filename, &buf);
if (! (err == 0 && (buf.st_mode & S_IFDIR)))
{ /* Is not directory. */
{
/* Is not directory. */
gint dummy;
gimage_to_be_thumbed = file_open_image (the_gimp,
@ -677,13 +679,13 @@ file_open_genbutton_callback (GtkWidget *widget,
}
}
g_free(full_filename);
list= g_slist_next(list);
g_free (full_filename);
list = g_slist_next (list);
}
for (list = toplist; list; list = g_slist_next (list))
{
if (!(g_slist_next (list)))
if (! g_slist_next (list))
{
full_filename = g_strconcat (filedirname, G_DIR_SEPARATOR_S,
(gchar *) list->data, NULL);
@ -696,6 +698,8 @@ file_open_genbutton_callback (GtkWidget *widget,
g_slist_free (toplist);
toplist = NULL;
g_free (filedirname);
}
gtk_widget_set_sensitive (GTK_WIDGET (fileload), TRUE);
@ -709,14 +713,15 @@ file_open_ok_callback (GtkWidget *widget,
GtkFileSelection *fs;
gchar *full_filename;
gchar *raw_filename;
gchar *filedirname;
const gchar *filedirname;
struct stat buf;
gint err;
gint status;
fs = GTK_FILE_SELECTION (data);
full_filename = gtk_file_selection_get_filename (fs);
raw_filename = gtk_entry_get_text (GTK_ENTRY(fs->selection_entry));
full_filename = g_strdup (gtk_file_selection_get_filename (fs));
raw_filename = g_strdup (gtk_entry_get_text (GTK_ENTRY(fs->selection_entry)));
g_assert (full_filename && raw_filename);
@ -771,12 +776,15 @@ file_open_ok_callback (GtkWidget *widget,
/* Find a real base directory for the multiple selection */
raw_filename = g_strdup(raw_filename);
raw_filename = g_strdup (raw_filename);
gtk_file_selection_set_filename (fs, "");
filedirname = gtk_file_selection_get_filename (fs);
while (list)
{
g_free (full_filename);
full_filename = g_strconcat (filedirname, G_DIR_SEPARATOR_S,
(gchar *) list->data, NULL);
@ -789,7 +797,7 @@ file_open_ok_callback (GtkWidget *widget,
{ /* Is not directory. */
status = file_open_with_proc_and_display (full_filename,
(gchar *) list->data,
(const gchar *) list->data,
load_file_proc);
if (status == GIMP_PDB_SUCCESS)
@ -803,7 +811,6 @@ file_open_ok_callback (GtkWidget *widget,
}
}
g_free (full_filename);
g_free (list->data);
list = g_slist_next (list);
}
@ -813,9 +820,10 @@ file_open_ok_callback (GtkWidget *widget,
}
gtk_file_selection_set_filename (fs, raw_filename);
g_free (raw_filename);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
g_free (full_filename);
g_free (raw_filename);
}
static GSList *

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