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

libgimp/*.c libgimpconfig/*.c libgimpmodule/*.c libgimpthumb/*.c port to 

2005-12-20  Michael Natterer  <mitch@gimp.org>

	* libgimp/*.c
	* libgimpconfig/*.c
	* libgimpmodule/*.c
	* libgimpthumb/*.c
	* libgimpwidgets/*.c: port to G_DEFINE_TYPE() and friends. Some
	related cleanup.
This commit is contained in:
Michael Natterer 2005-12-20 20:35:23 +00:00 committed by Michael Natterer
parent a4c54f7aa8
commit 33ae55f873
42 changed files with 375 additions and 1620 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,12 @@
2005-12-20 Michael Natterer <mitch@gimp.org>
* libgimp/*.c
* libgimpconfig/*.c
* libgimpmodule/*.c
* libgimpthumb/*.c
* libgimpwidgets/*.c: port to G_DEFINE_TYPE() and friends. Some
related cleanup.
2005-12-20 Sven Neumann <sven@gimp.org>
* libgimpwidgets/gimpscrolledpreview.c: removed unused variable.

46
libgimp/gimpaspectpreview.c
View File

@ -34,46 +34,18 @@
#include "gimpaspectpreview.h"
static void gimp_aspect_preview_class_init (GimpAspectPreviewClass *klass);
static void gimp_aspect_preview_init (GimpAspectPreview *preview);
static void gimp_aspect_preview_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_aspect_preview_draw (GimpPreview *preview);
static void gimp_aspect_preview_draw_buffer (GimpPreview *preview,
const guchar *buffer,
gint rowstride);
static void gimp_aspect_preview_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_aspect_preview_draw (GimpPreview *preview);
static void gimp_aspect_preview_draw_buffer (GimpPreview *preview,
const guchar *buffer,
gint rowstride);
static GimpPreviewClass *parent_class = NULL;
G_DEFINE_TYPE (GimpAspectPreview, gimp_aspect_preview, GIMP_TYPE_PREVIEW);
GType
gimp_aspect_preview_get_type (void)
{
static GType preview_type = 0;
#define parent_class gimp_aspect_preview_parent_class
if (! preview_type)
{
static const GTypeInfo preview_info =
{
sizeof (GimpAspectPreviewClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_aspect_preview_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpAspectPreview),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_aspect_preview_init,
};
preview_type = g_type_register_static (GIMP_TYPE_PREVIEW,
"GimpAspectPreview",
&preview_info, 0);
}
return preview_type;
}
static void
gimp_aspect_preview_class_init (GimpAspectPreviewClass *klass)
@ -81,8 +53,6 @@ gimp_aspect_preview_class_init (GimpAspectPreviewClass *klass)
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpPreviewClass *preview_class = GIMP_PREVIEW_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
widget_class->style_set = gimp_aspect_preview_style_set;
preview_class->draw = gimp_aspect_preview_draw;

67
libgimp/gimpdrawablepreview.c
View File

@ -40,59 +40,32 @@ typedef struct
gboolean update;
} PreviewSettings;
static void gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass);
static void gimp_drawable_preview_init (GimpDrawablePreview *preview);
static void gimp_drawable_preview_destroy (GtkObject *object);
static void gimp_drawable_preview_destroy (GtkObject *object);
static void gimp_drawable_preview_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_drawable_preview_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_drawable_preview_draw_original (GimpPreview *preview);
static void gimp_drawable_preview_draw_thumb (GimpPreview *preview,
GimpPreviewArea *area,
gint width,
gint height);
static void gimp_drawable_preview_draw_buffer (GimpPreview *preview,
const guchar *buffer,
gint rowstride);
static gboolean gimp_drawable_preview_get_bounds (GimpDrawable *drawable,
gint *xmin,
gint *ymin,
gint *xmax,
gint *ymax);
static void gimp_drawable_preview_draw_original (GimpPreview *preview);
static void gimp_drawable_preview_draw_thumb (GimpPreview *preview,
GimpPreviewArea *area,
gint width,
gint height);
static void gimp_drawable_preview_draw_buffer (GimpPreview *preview,
const guchar *buffer,
gint rowstride);
static gboolean gimp_drawable_preview_get_bounds (GimpDrawable *drawable,
gint *xmin,
gint *ymin,
gint *xmax,
gint *ymax);
static GimpScrolledPreviewClass *parent_class = NULL;
G_DEFINE_TYPE (GimpDrawablePreview, gimp_drawable_preview,
GIMP_TYPE_SCROLLED_PREVIEW);
#define parent_class gimp_drawable_preview_parent_class
GType
gimp_drawable_preview_get_type (void)
{
static GType preview_type = 0;
if (!preview_type)
{
static const GTypeInfo drawable_preview_info =
{
sizeof (GimpDrawablePreviewClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_drawable_preview_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpDrawablePreview),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_drawable_preview_init
};
preview_type = g_type_register_static (GIMP_TYPE_SCROLLED_PREVIEW,
"GimpDrawablePreview",
&drawable_preview_info, 0);
}
return preview_type;
}
static void
gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass)
@ -101,8 +74,6 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass)
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpPreviewClass *preview_class = GIMP_PREVIEW_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_drawable_preview_destroy;
widget_class->style_set = gimp_drawable_preview_style_set;

39
libgimp/gimpprocbrowserdialog.c
View File

@ -67,11 +67,6 @@ enum
};
/* local function prototypes */
static void gimp_proc_browser_dialog_class_init (GimpProcBrowserDialogClass *klass);
static void gimp_proc_browser_dialog_init (GimpProcBrowserDialog *dialog);
static void browser_selection_changed (GtkTreeSelection *sel,
GimpProcBrowserDialog *dialog);
static void browser_row_activated (GtkTreeView *treeview,
@ -86,43 +81,17 @@ static void browser_search (GimpBrowser *browser,
GimpProcBrowserDialog *dialog);
static GimpDialogClass *parent_class = NULL;
static guint dialog_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE (GimpProcBrowserDialog, gimp_proc_browser_dialog,
GIMP_TYPE_DIALOG);
#define parent_class gimp_proc_browser_dialog_parent_class
GType
gimp_proc_browser_dialog_get_type (void)
{
static GType type = 0;
static guint dialog_signals[LAST_SIGNAL] = { 0, };
if (! type)
{
static const GTypeInfo info =
{
sizeof (GimpProcBrowserDialogClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_proc_browser_dialog_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpProcBrowserDialog),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_proc_browser_dialog_init,
};
type = g_type_register_static (GIMP_TYPE_DIALOG,
"GimpProcBrowserDialog",
&info, 0);
}
return type;
}
static void
gimp_proc_browser_dialog_class_init (GimpProcBrowserDialogClass *klass)
{
parent_class = g_type_class_peek_parent (klass);
/**
* GimpProcBrowserDialog::selection-changed:
* @dialog: the object that received the signal

57
libgimp/gimpprogressbar.c
View File

@ -39,61 +39,30 @@
#include "gimpprogressbar.h"
static void gimp_progress_bar_class_init (GimpProgressBarClass *klass);
static void gimp_progress_bar_init (GimpProgressBar *bar);
static void gimp_progress_bar_destroy (GtkObject *object);
static void gimp_progress_bar_destroy (GtkObject *object);
static void gimp_progress_bar_start (const gchar *message,
gboolean cancelable,
gpointer user_data);
static void gimp_progress_bar_end (gpointer user_data);
static void gimp_progress_bar_set_text (const gchar *message,
gpointer user_data);
static void gimp_progress_bar_set_value (gdouble percentage,
gpointer user_data);
static void gimp_progress_bar_pulse (gpointer user_data);
static guint32 gimp_progress_bar_get_window (gpointer user_data);
static void gimp_progress_bar_start (const gchar *message,
gboolean cancelable,
gpointer user_data);
static void gimp_progress_bar_end (gpointer user_data);
static void gimp_progress_bar_set_text (const gchar *message,
gpointer user_data);
static void gimp_progress_bar_set_value (gdouble percentage,
gpointer user_data);
static void gimp_progress_bar_pulse (gpointer user_data);
static guint32 gimp_progress_bar_get_window (gpointer user_data);
static GtkProgressBarClass *parent_class = NULL;
G_DEFINE_TYPE (GimpProgressBar, gimp_progress_bar, GTK_TYPE_PROGRESS_BAR);
#define parent_class gimp_progress_bar_parent_class
GType
gimp_progress_bar_get_type (void)
{
static GType bar_type = 0;
if (! bar_type)
{
static const GTypeInfo bar_info =
{
sizeof (GimpProgressBarClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_progress_bar_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpProgressBar),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_progress_bar_init,
};
bar_type = g_type_register_static (GTK_TYPE_PROGRESS_BAR,
"GimpProgressBar",
&bar_info, 0);
}
return bar_type;
}
static void
gimp_progress_bar_class_init (GimpProgressBarClass *klass)
{
GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_progress_bar_destroy;
}

76
libgimpconfig/gimpcolorconfig.c
View File

@ -84,70 +84,29 @@ enum
};
static void gimp_color_config_class_init (GimpColorConfigClass *klass);
static void gimp_color_config_finalize (GObject *object);
static void gimp_color_config_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_color_config_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_color_config_finalize (GObject *object);
static void gimp_color_config_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_color_config_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static GObjectClass *parent_class = NULL;
G_DEFINE_TYPE_WITH_CODE (GimpColorConfig, gimp_color_config, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL)
gimp_type_set_translation_domain (g_define_type_id,
GETTEXT_PACKAGE "-libgimp"));
#define parent_class gimp_color_config_parent_class
GType
gimp_color_config_get_type (void)
{
static GType config_type = 0;
if (! config_type)
{
static const GTypeInfo config_info =
{
sizeof (GimpColorConfigClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_color_config_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorConfig),
0, /* n_preallocs */
NULL /* instance_init */
};
static const GInterfaceInfo config_iface_info =
{
NULL, /* iface_init */
NULL, /* iface_finalize */
NULL /* iface_data */
};
config_type = g_type_register_static (G_TYPE_OBJECT,
"GimpColorConfig",
&config_info, 0);
g_type_add_interface_static (config_type,
GIMP_TYPE_CONFIG, &config_iface_info);
gimp_type_set_translation_domain (config_type,
GETTEXT_PACKAGE "-libgimp");
}
return config_type;
}
static void
gimp_color_config_class_init (GimpColorConfigClass *klass)
{
GObjectClass *object_class;
parent_class = g_type_class_peek_parent (klass);
object_class = G_OBJECT_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_color_config_finalize;
object_class->set_property = gimp_color_config_set_property;
@ -217,6 +176,11 @@ gimp_color_config_class_init (GimpColorConfigClass *klass)
#endif
}
static void
gimp_color_config_init (GimpColorConfig *config)
{
}
static void
gimp_color_config_finalize (GObject *object)
{

51
libgimpmodule/gimpmodule.c
View File

@ -40,52 +40,23 @@ enum
};
static void gimp_module_class_init (GimpModuleClass *klass);
static void gimp_module_init (GimpModule *module);
static void gimp_module_finalize (GObject *object);
static void gimp_module_finalize (GObject *object);
static gboolean gimp_module_load (GTypeModule *module);
static void gimp_module_unload (GTypeModule *module);
static gboolean gimp_module_load (GTypeModule *module);
static void gimp_module_unload (GTypeModule *module);
static gboolean gimp_module_open (GimpModule *module);
static gboolean gimp_module_close (GimpModule *module);
static void gimp_module_set_last_error (GimpModule *module,
const gchar *error_str);
static gboolean gimp_module_open (GimpModule *module);
static gboolean gimp_module_close (GimpModule *module);
static void gimp_module_set_last_error (GimpModule *module,
const gchar *error_str);
G_DEFINE_TYPE (GimpModule, gimp_module, G_TYPE_TYPE_MODULE);
#define parent_class gimp_module_parent_class
static guint module_signals[LAST_SIGNAL];
static GTypeModuleClass *parent_class = NULL;
GType
gimp_module_get_type (void)
{
static GType module_type = 0;
if (! module_type)
{
static const GTypeInfo module_info =
{
sizeof (GimpModuleClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_module_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpModule),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_module_init,
};
module_type = g_type_register_static (G_TYPE_TYPE_MODULE,
"GimpModule",
&module_info, 0);
}
return module_type;
}
static void
gimp_module_class_init (GimpModuleClass *klass)
@ -93,8 +64,6 @@ gimp_module_class_init (GimpModuleClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
module_signals[MODIFIED] =
g_signal_new ("modified",
G_TYPE_FROM_CLASS (klass),

37
libgimpmodule/gimpmoduledb.c
View File

@ -43,9 +43,6 @@ enum
/* #define DUMP_DB 1 */
static void gimp_module_db_class_init (GimpModuleDBClass *klass);
static void gimp_module_db_init (GimpModuleDB *db);
static void gimp_module_db_finalize (GObject *object);
static void gimp_module_db_module_initialize (const GimpDatafileData *file_data,
@ -67,46 +64,18 @@ static void gimp_module_db_module_modified (GimpModule *module,
GimpModuleDB *db);
static GObjectClass *parent_class = NULL;
G_DEFINE_TYPE (GimpModuleDB, gimp_module_db, G_TYPE_OBJECT);
static guint db_signals[LAST_SIGNAL] = { 0 };
#define parent_class gimp_module_db_parent_class
static guint db_signals[LAST_SIGNAL] = { 0 };
GType
gimp_module_db_get_type (void)
{
static GType db_type = 0;
if (! db_type)
{
static const GTypeInfo db_info =
{
sizeof (GimpModuleDBClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_module_db_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpModuleDB),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_module_db_init,
};
db_type = g_type_register_static (G_TYPE_OBJECT,
"GimpModuleDB",
&db_info, 0);
}
return db_type;
}
static void
gimp_module_db_class_init (GimpModuleDBClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
db_signals[ADD] =
g_signal_new ("add",
G_TYPE_FROM_CLASS (klass),

80
libgimpthumb/gimpthumbnail.c
View File

@ -89,74 +89,42 @@ enum
};
static void gimp_thumbnail_class_init (GimpThumbnailClass *klass);
static void gimp_thumbnail_init (GimpThumbnail *thumbnail);
static void gimp_thumbnail_finalize (GObject *object);
static void gimp_thumbnail_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_thumbnail_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_thumbnail_reset_info (GimpThumbnail *thumbnail);
static void gimp_thumbnail_finalize (GObject *object);
static void gimp_thumbnail_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_thumbnail_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_thumbnail_reset_info (GimpThumbnail *thumbnail);
static void gimp_thumbnail_update_image (GimpThumbnail *thumbnail);
static void gimp_thumbnail_update_thumb (GimpThumbnail *thumbnail,
GimpThumbSize size);
static void gimp_thumbnail_update_image (GimpThumbnail *thumbnail);
static void gimp_thumbnail_update_thumb (GimpThumbnail *thumbnail,
GimpThumbSize size);
static gboolean gimp_thumbnail_save (GimpThumbnail *thumbnail,
GimpThumbSize size,
const gchar *filename,
GdkPixbuf *pixbuf,
const gchar *software,
GError **error);
static gboolean gimp_thumbnail_save (GimpThumbnail *thumbnail,
GimpThumbSize size,
const gchar *filename,
GdkPixbuf *pixbuf,
const gchar *software,
GError **error);
#ifdef GIMP_THUMB_DEBUG
static void gimp_thumbnail_debug_notify (GObject *object,
GParamSpec *pspec);
static void gimp_thumbnail_debug_notify (GObject *object,
GParamSpec *pspec);
#endif
static GObjectClass *parent_class = NULL;
G_DEFINE_TYPE (GimpThumbnail, gimp_thumbnail, G_TYPE_OBJECT);
#define parent_class gimp_thumbnail_parent_class
GType
gimp_thumbnail_get_type (void)
{
static GType thumbnail_type = 0;
if (!thumbnail_type)
{
static const GTypeInfo thumbnail_info =
{
sizeof (GimpThumbnailClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_thumbnail_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpThumbnail),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_thumbnail_init,
};
thumbnail_type = g_type_register_static (G_TYPE_OBJECT,
"GimpThumbnail",
&thumbnail_info, 0);
}
return thumbnail_type;
}
static void
gimp_thumbnail_class_init (GimpThumbnailClass *klass)
{
GObjectClass *object_class;
parent_class = g_type_class_peek_parent (klass);
object_class = G_OBJECT_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_thumbnail_finalize;
object_class->set_property = gimp_thumbnail_set_property;

45
libgimpwidgets/gimpbrowser.c
View File

@ -41,56 +41,25 @@ enum
};
static void gimp_browser_class_init (GimpBrowserClass *klass);
static void gimp_browser_init (GimpBrowser *browser);
static void gimp_browser_destroy (GtkObject *object);
static void gimp_browser_destroy (GtkObject *object);
static void gimp_browser_entry_changed (GtkEditable *editable,
GimpBrowser *browser);
static gboolean gimp_browser_search_timeout (gpointer data);
static void gimp_browser_entry_changed (GtkEditable *editable,
GimpBrowser *browser);
static gboolean gimp_browser_search_timeout (gpointer data);
static GtkHPanedClass *parent_class = NULL;
G_DEFINE_TYPE (GimpBrowser, gimp_browser, GTK_TYPE_HPANED);
#define parent_class gimp_browser_parent_class
static guint browser_signals[LAST_SIGNAL] = { 0 };
GType
gimp_browser_get_type (void)
{
static GType type = 0;
if (! type)
{
static const GTypeInfo info =
{
sizeof (GimpBrowserClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_browser_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpBrowser),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_browser_init,
};
type = g_type_register_static (GTK_TYPE_HPANED,
"GimpBrowser",
&info, 0);
}
return type;
}
static void
gimp_browser_class_init (GimpBrowserClass *klass)
{
GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
browser_signals[SEARCH] =
g_signal_new ("search",
G_TYPE_FROM_CLASS (klass),

45
libgimpwidgets/gimpbutton.c
View File

@ -36,55 +36,24 @@ enum
};
static void gimp_button_class_init (GimpButtonClass *klass);
static void gimp_button_init (GimpButton *button);
static gboolean gimp_button_button_press (GtkWidget *widget,
GdkEventButton *event);
static gboolean gimp_button_button_release (GtkWidget *widget,
GdkEventButton *event);
static gboolean gimp_button_button_press (GtkWidget *widget,
GdkEventButton *event);
static gboolean gimp_button_button_release (GtkWidget *widget,
GdkEventButton *event);
G_DEFINE_TYPE (GimpButton, gimp_button, GTK_TYPE_BUTTON);
#define parent_class gimp_button_parent_class
static guint button_signals[LAST_SIGNAL] = { 0 };
static GtkButtonClass *parent_class = NULL;
GType
gimp_button_get_type (void)
{
static GType button_type = 0;
if (! button_type)
{
static const GTypeInfo button_info =
{
sizeof (GimpButtonClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_button_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpButton),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_button_init,
};
button_type = g_type_register_static (GTK_TYPE_BUTTON,
"GimpButton",
&button_info, 0);
}
return button_type;
}
static void
gimp_button_class_init (GimpButtonClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
button_signals[EXTENDED_CLICKED] =
g_signal_new ("extended-clicked",
G_TYPE_FROM_CLASS (klass),

36
libgimpwidgets/gimpcellrenderercolor.c
View File

@ -44,9 +44,6 @@ enum
};
static void gimp_cell_renderer_color_class_init (GimpCellRendererColorClass *klass);
static void gimp_cell_renderer_color_init (GimpCellRendererColor *cell);
static void gimp_cell_renderer_color_get_property (GObject *object,
guint param_id,
GValue *value,
@ -71,36 +68,11 @@ static void gimp_cell_renderer_color_render (GtkCellRenderer *cell,
GtkCellRendererState flags);
static GtkCellRendererClass *parent_class = NULL;
G_DEFINE_TYPE (GimpCellRendererColor, gimp_cell_renderer_color,
GTK_TYPE_CELL_RENDERER);
#define parent_class gimp_cell_renderer_color_parent_class
GType
gimp_cell_renderer_color_get_type (void)
{
static GType cell_type = 0;
if (! cell_type)
{
static const GTypeInfo cell_info =
{
sizeof (GimpCellRendererColorClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_cell_renderer_color_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpCellRendererColor),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_cell_renderer_color_init,
};
cell_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
"GimpCellRendererColor",
&cell_info, 0);
}
return cell_type;
}
static void
gimp_cell_renderer_color_class_init (GimpCellRendererColorClass *klass)
@ -108,8 +80,6 @@ gimp_cell_renderer_color_class_init (GimpCellRendererColorClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->get_property = gimp_cell_renderer_color_get_property;
object_class->set_property = gimp_cell_renderer_color_set_property;

44
libgimpwidgets/gimpcellrenderertoggle.c
View File

@ -47,8 +47,6 @@ enum
};
static void gimp_cell_renderer_toggle_class_init (GimpCellRendererToggleClass *klass);
static void gimp_cell_renderer_toggle_finalize (GObject *object);
static void gimp_cell_renderer_toggle_get_property (GObject *object,
guint param_id,
@ -83,38 +81,13 @@ static void gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *tog
GtkWidget *widget);
G_DEFINE_TYPE (GimpCellRendererToggle, gimp_cell_renderer_toggle,
GTK_TYPE_CELL_RENDERER_TOGGLE);
#define parent_class gimp_cell_renderer_toggle_parent_class
static guint toggle_cell_signals[LAST_SIGNAL] = { 0 };
static GtkCellRendererToggleClass *parent_class = NULL;
GType
gimp_cell_renderer_toggle_get_type (void)
{
static GType cell_type = 0;
if (! cell_type)
{
static const GTypeInfo cell_info =
{
sizeof (GimpCellRendererToggleClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_cell_renderer_toggle_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpCellRendererToggle),
0, /* n_preallocs */
NULL /* instance_init */
};
cell_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TOGGLE,
"GimpCellRendererToggle",
&cell_info, 0);
}
return cell_type;
}
static void
gimp_cell_renderer_toggle_class_init (GimpCellRendererToggleClass *klass)
@ -122,8 +95,6 @@ gimp_cell_renderer_toggle_class_init (GimpCellRendererToggleClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
toggle_cell_signals[CLICKED] =
g_signal_new ("clicked",
G_OBJECT_CLASS_TYPE (object_class),
@ -160,6 +131,11 @@ gimp_cell_renderer_toggle_class_init (GimpCellRendererToggleClass *klass)
G_PARAM_CONSTRUCT));
}
static void
gimp_cell_renderer_toggle_init (GimpCellRendererToggle *toggle)
{
}
static void
gimp_cell_renderer_toggle_finalize (GObject *object)
{

51
libgimpwidgets/gimpchainbutton.c
View File

@ -35,15 +35,18 @@ enum
};
static void gimp_chain_button_class_init (GimpChainButtonClass *klass);
static void gimp_chain_button_init (GimpChainButton *button);
static void gimp_chain_button_clicked_callback (GtkWidget *widget,
GimpChainButton *button);
static gboolean gimp_chain_button_draw_lines (GtkWidget *widget,
GdkEventExpose *eevent,
GimpChainButton *button);
static void gimp_chain_button_clicked_callback (GtkWidget *widget,
GimpChainButton *button);
static gboolean gimp_chain_button_draw_lines (GtkWidget *widget,
GdkEventExpose *eevent,
GimpChainButton *button);
G_DEFINE_TYPE (GimpChainButton, gimp_chain_button, GTK_TYPE_TABLE);
#define parent_class gimp_chain_button_parent_class
static guint gimp_chain_button_signals[LAST_SIGNAL] = { 0 };
static const gchar *gimp_chain_stock_items[] =
{
@ -54,43 +57,9 @@ static const gchar *gimp_chain_stock_items[] =
};
static guint gimp_chain_button_signals[LAST_SIGNAL] = { 0 };
static GtkTableClass *parent_class = NULL;
GType
gimp_chain_button_get_type (void)
{
static GType button_type = 0;
if (! button_type)
{
static const GTypeInfo button_info =
{
sizeof (GimpChainButtonClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_chain_button_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpChainButton),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_chain_button_init,
};
button_type = g_type_register_static (GTK_TYPE_TABLE, "GimpChainButton",
&button_info, 0);
}
return button_type;
}
static void
gimp_chain_button_class_init (GimpChainButtonClass *klass)
{
parent_class = g_type_class_peek_parent (klass);
gimp_chain_button_signals[TOGGLED] =
g_signal_new ("toggled",
G_TYPE_FROM_CLASS (klass),

39
libgimpwidgets/gimpcolorarea.c
View File

@ -52,9 +52,6 @@ enum
};
static void gimp_color_area_class_init (GimpColorAreaClass *klass);
static void gimp_color_area_init (GimpColorArea *area);
static void gimp_color_area_get_property (GObject *object,
guint property_id,
GValue *value,
@ -91,41 +88,15 @@ static void gimp_color_area_drag_data_get (GtkWidget *widget,
guint time);
static const GtkTargetEntry target = { "application/x-color", 0 };
G_DEFINE_TYPE (GimpColorArea, gimp_color_area, GTK_TYPE_DRAWING_AREA);
#define parent_class gimp_color_area_parent_class
static guint gimp_color_area_signals[LAST_SIGNAL] = { 0 };
static GtkDrawingAreaClass * parent_class = NULL;
static const GtkTargetEntry target = { "application/x-color", 0 };
GType
gimp_color_area_get_type (void)
{
static GType area_type = 0;
if (! area_type)
{
static const GTypeInfo area_info =
{
sizeof (GimpColorAreaClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_area_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorArea),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_area_init,
};
area_type = g_type_register_static (GTK_TYPE_DRAWING_AREA,
"GimpColorArea",
&area_info, 0);
}
return area_type;
}
static void
gimp_color_area_class_init (GimpColorAreaClass *klass)
{
@ -133,8 +104,6 @@ gimp_color_area_class_init (GimpColorAreaClass *klass)
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpRGB color;
parent_class = g_type_class_peek_parent (klass);
gimp_color_area_signals[COLOR_CHANGED] =
g_signal_new ("color-changed",
G_TYPE_FROM_CLASS (klass),

67
libgimpwidgets/gimpcolordisplay.c
View File

@ -48,67 +48,29 @@ enum
};
static void gimp_color_display_class_init (GimpColorDisplayClass *klass);
static void gimp_color_display_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_color_display_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_color_display_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_color_display_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static GObjectClass *parent_class = NULL;
G_DEFINE_TYPE_WITH_CODE (GimpColorDisplay, gimp_color_display, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL));
static guint display_signals[LAST_SIGNAL] = { 0 };
#define parent_class gimp_color_display_parent_class
static guint display_signals[LAST_SIGNAL] = { 0 };
GType
gimp_color_display_get_type (void)
{
static GType display_type = 0;
if (! display_type)
{
static const GTypeInfo display_info =
{
sizeof (GimpColorDisplayClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_display_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorDisplay),
0, /* n_preallocs */
NULL /* instance_init */
};
static const GInterfaceInfo display_iface_info =
{
NULL, /* iface_init */
NULL, /* iface_finalize */
NULL /* iface_data */
};
display_type = g_type_register_static (G_TYPE_OBJECT,
"GimpColorDisplay",
&display_info, 0);
g_type_add_interface_static (display_type,
GIMP_TYPE_CONFIG, &display_iface_info);
}
return display_type;
}
static void
gimp_color_display_class_init (GimpColorDisplayClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->set_property = gimp_color_display_set_property;
object_class->get_property = gimp_color_display_get_property;
@ -139,6 +101,11 @@ gimp_color_display_class_init (GimpColorDisplayClass *klass)
klass->changed = NULL;
}
static void
gimp_color_display_init (GimpColorDisplay *display)
{
}
static void
gimp_color_display_set_property (GObject *object,
guint property_id,

37
libgimpwidgets/gimpcolordisplaystack.c
View File

@ -43,9 +43,6 @@ enum
};
static void gimp_color_display_stack_class_init (GimpColorDisplayStackClass *klass);
static void gimp_color_display_stack_init (GimpColorDisplayStack *stack);
static void gimp_color_display_stack_finalize (GObject *object);
static void gimp_color_display_stack_display_changed (GimpColorDisplay *display,
@ -55,46 +52,18 @@ static void gimp_color_display_stack_display_enabled (GimpColorDisplay *d
GimpColorDisplayStack *stack);
static GObjectClass *parent_class = NULL;
G_DEFINE_TYPE (GimpColorDisplayStack, gimp_color_display_stack, G_TYPE_OBJECT);
static guint stack_signals[LAST_SIGNAL] = { 0 };
#define parent_class gimp_color_display_stack_parent_class
static guint stack_signals[LAST_SIGNAL] = { 0 };
GType
gimp_color_display_stack_get_type (void)
{
static GType display_type = 0;
if (! display_type)
{
static const GTypeInfo display_info =
{
sizeof (GimpColorDisplayStackClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_display_stack_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorDisplayStack),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_display_stack_init,
};
display_type = g_type_register_static (G_TYPE_OBJECT,
"GimpColorDisplayStack",
&display_info, 0);
}
return display_type;
}
static void
gimp_color_display_stack_class_init (GimpColorDisplayStackClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
stack_signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),

32
libgimpwidgets/gimpcolorhexentry.c
View File

@ -49,8 +49,6 @@ enum
};
static void gimp_color_hex_entry_class_init (GimpColorHexEntryClass *klass);
static void gimp_color_hex_entry_init (GimpColorHexEntry *entry);
static gboolean gimp_color_hex_entry_events (GtkWidget *widget,
GdkEvent *event);
@ -60,36 +58,12 @@ static gboolean gimp_color_hex_entry_matched (GtkEntryCompletion *completion
GimpColorHexEntry *entry);
static guint entry_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (GimpColorHexEntry, gimp_color_hex_entry, GTK_TYPE_ENTRY);
#define parent_class gimp_color_hex_entry_parent_class
GType
gimp_color_hex_entry_get_type (void)
{
static GType entry_type = 0;
static guint entry_signals[LAST_SIGNAL] = { 0 };
if (! entry_type)
{
static const GTypeInfo entry_info =
{
sizeof (GimpColorHexEntryClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_hex_entry_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorHexEntry),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_hex_entry_init,
};
entry_type = g_type_register_static (GTK_TYPE_ENTRY,
"GimpColorHexEntry",
&entry_info, 0);
}
return entry_type;
}
static void
gimp_color_hex_entry_class_init (GimpColorHexEntryClass *klass)

36
libgimpwidgets/gimpcolornotebook.c
View File

@ -42,9 +42,6 @@
#define DEFAULT_TAB_ICON_SIZE GTK_ICON_SIZE_BUTTON
static void gimp_color_notebook_class_init (GimpColorNotebookClass *klass);
static void gimp_color_notebook_init (GimpColorNotebook *notebook);
static void gimp_color_notebook_finalize (GObject *object);
static void gimp_color_notebook_style_set (GtkWidget *widget,
@ -78,36 +75,11 @@ static GtkWidget * gimp_color_notebook_add_page (GimpColorNotebook *notebook,
GType page_type);
static GimpColorSelectorClass *parent_class = NULL;
G_DEFINE_TYPE (GimpColorNotebook, gimp_color_notebook,
GIMP_TYPE_COLOR_SELECTOR);
#define parent_class gimp_color_notebook_parent_class
GType
gimp_color_notebook_get_type (void)
{
static GType notebook_type = 0;
if (! notebook_type)
{
static const GTypeInfo notebook_info =
{
sizeof (GimpColorNotebookClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_notebook_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorNotebook),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_notebook_init,
};
notebook_type = g_type_register_static (GIMP_TYPE_COLOR_SELECTOR,
"GimpColorNotebook",
&notebook_info, 0);
}
return notebook_type;
}
static void
gimp_color_notebook_class_init (GimpColorNotebookClass *klass)
@ -116,8 +88,6 @@ gimp_color_notebook_class_init (GimpColorNotebookClass *klass)
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpColorSelectorClass *selector_class = GIMP_COLOR_SELECTOR_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_color_notebook_finalize;
widget_class->style_set = gimp_color_notebook_style_set;

34
libgimpwidgets/gimpcolorscale.c
View File

@ -37,9 +37,6 @@
#define SHADOW 1
static void gimp_color_scale_class_init (GimpColorScaleClass *klass);
static void gimp_color_scale_init (GimpColorScale *scale);
static void gimp_color_scale_destroy (GtkObject *object);
static void gimp_color_scale_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
@ -53,35 +50,10 @@ static void gimp_color_scale_render_alpha (GimpColorScale *scale);
static void gimp_color_scale_render_stipple (GimpColorScale *scale);
static GtkScaleClass * parent_class = NULL;
G_DEFINE_TYPE (GimpColorScale, gimp_color_scale, GTK_TYPE_SCALE);
#define parent_class gimp_color_scale_parent_class
GType
gimp_color_scale_get_type (void)
{
static GType scale_type = 0;
if (! scale_type)
{
static const GTypeInfo scale_info =
{
sizeof (GimpColorScaleClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_scale_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorScale),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_scale_init,
};
scale_type = g_type_register_static (GTK_TYPE_SCALE,
"GimpColorScale", &scale_info, 0);
}
return scale_type;
}
static void
gimp_color_scale_class_init (GimpColorScaleClass *klass)
@ -89,8 +61,6 @@ gimp_color_scale_class_init (GimpColorScaleClass *klass)
GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gimp_color_scale_destroy;
widget_class->size_allocate = gimp_color_scale_size_allocate;

35
libgimpwidgets/gimpcolorscales.c
View File

@ -64,9 +64,6 @@ struct _GimpColorScalesClass
};
static void gimp_color_scales_class_init (GimpColorScalesClass *klass);
static void gimp_color_scales_init (GimpColorScales *scales);
static void gimp_color_scales_togg_sensitive (GimpColorSelector *selector,
gboolean sensitive);
static void gimp_color_scales_togg_visible (GimpColorSelector *selector,
@ -88,44 +85,16 @@ static void gimp_color_scales_scale_update (GtkAdjustment *adjustment,
GimpColorScales *scales);
static GimpColorSelectorClass *parent_class = NULL;
G_DEFINE_TYPE (GimpColorScales, gimp_color_scales, GIMP_TYPE_COLOR_SELECTOR);
#define parent_class gimp_color_scales_parent_class
GType
gimp_color_scales_get_type (void)
{
static GType scales_type = 0;
if (! scales_type)
{
static const GTypeInfo scales_info =
{
sizeof (GimpColorScalesClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_scales_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorScales),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_scales_init,
};
scales_type = g_type_register_static (GIMP_TYPE_COLOR_SELECTOR,
"GimpColorScales",
&scales_info, 0);
}
return scales_type;
}
static void
gimp_color_scales_class_init (GimpColorScalesClass *klass)
{
GimpColorSelectorClass *selector_class = GIMP_COLOR_SELECTOR_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
selector_class->name = _("Scales");
selector_class->help_id = "gimp-colorselector-scales";
selector_class->stock_id = GIMP_STOCK_TOOL_OPTIONS;

37
libgimpwidgets/gimpcolorselect.c
View File

@ -122,9 +122,6 @@ struct _ColorSelectFill
};
static void gimp_color_select_class_init (GimpColorSelectClass *klass);
static void gimp_color_select_init (GimpColorSelect *select);
static void gimp_color_select_unrealize (GtkWidget *widget);
static void gimp_color_select_togg_visible (GimpColorSelector *selector,
@ -196,9 +193,9 @@ static void color_select_update_hue_value (ColorSelectFill *csf);
static void color_select_update_saturation_value (ColorSelectFill *csf);
/* static variables */
G_DEFINE_TYPE (GimpColorSelect, gimp_color_select, GIMP_TYPE_COLOR_SELECTOR);
static GimpColorSelectorClass *parent_class = NULL;
#define parent_class gimp_color_select_parent_class
static ColorSelectFillUpdateProc update_procs[] =
{
@ -218,42 +215,12 @@ static ColorSelectFillUpdateProc update_procs[] =
};
GType
gimp_color_select_get_type (void)
{
static GType select_type = 0;
if (! select_type)
{
static const GTypeInfo select_info =
{
sizeof (GimpColorSelectClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_select_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorSelect),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_select_init,
};
select_type = g_type_register_static (GIMP_TYPE_COLOR_SELECTOR,
"GimpColorSelect",
&select_info, 0);
}
return select_type;
}
static void
gimp_color_select_class_init (GimpColorSelectClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpColorSelectorClass *selector_class = GIMP_COLOR_SELECTOR_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
widget_class->unrealize = gimp_color_select_unrealize;
selector_class->name = "GIMP";

37
libgimpwidgets/gimpcolorselection.c
View File

@ -66,9 +66,6 @@ enum
};
static void gimp_color_selection_class_init (GimpColorSelectionClass *klass);
static void gimp_color_selection_init (GimpColorSelection *selection);
static void gimp_color_selection_switch_page (GtkWidget *widget,
GtkNotebookPage *page,
guint page_num,
@ -96,44 +93,16 @@ static void gimp_color_selection_update (GimpColorSelection *select
UpdateType update);
static GtkVBoxClass *parent_class = NULL;
G_DEFINE_TYPE (GimpColorSelection, gimp_color_selection, GTK_TYPE_VBOX);
static guint selection_signals[LAST_SIGNAL] = { 0 };
#define parent_class gimp_color_selection_parent_class
static guint selection_signals[LAST_SIGNAL] = { 0 };
GType
gimp_color_selection_get_type (void)
{
static GType selection_type = 0;
if (! selection_type)
{
static const GTypeInfo selection_info =
{
sizeof (GimpColorSelectionClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_selection_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorSelection),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_selection_init,
};
selection_type = g_type_register_static (GTK_TYPE_VBOX,
"GimpColorSelection",
&selection_info, 0);
}
return selection_type;
}
static void
gimp_color_selection_class_init (GimpColorSelectionClass *klass)
{
parent_class = g_type_class_peek_parent (klass);
selection_signals[COLOR_CHANGED] =
g_signal_new ("color-changed",
G_TYPE_FROM_CLASS (klass),

38
libgimpwidgets/gimpcolorselector.c
View File

@ -44,48 +44,16 @@ enum
};
static void gimp_color_selector_class_init (GimpColorSelectorClass *klass);
static void gimp_color_selector_init (GimpColorSelector *selector);
G_DEFINE_TYPE (GimpColorSelector, gimp_color_selector, GTK_TYPE_VBOX);
#define parent_class gimp_color_selector_parent_class
static GtkVBoxClass *parent_class = NULL;
static guint selector_signals[LAST_SIGNAL] = { 0 };
static guint selector_signals[LAST_SIGNAL] = { 0 };
GType
gimp_color_selector_get_type (void)
{
static GType selector_type = 0;
if (! selector_type)
{
static const GTypeInfo selector_info =
{
sizeof (GimpColorSelectorClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_color_selector_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpColorSelector),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_color_selector_init,
};
selector_type = g_type_register_static (GTK_TYPE_VBOX,
"GimpColorSelector",
&selector_info, 0);
}
return selector_type;
}
static void
gimp_color_selector_class_init (GimpColorSelectorClass *klass)
{
parent_class = g_type_class_peek_parent (klass);
selector_signals[COLOR_CHANGED] =
g_signal_new ("color-changed",
G_TYPE_FROM_CLASS (klass),

83
libgimpwidgets/gimpcontroller.c
View File

@ -48,60 +48,24 @@ enum
};
static void gimp_controller_class_init (GimpControllerClass *klass);
static void gimp_controller_finalize (GObject *object);
static void gimp_controller_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_controller_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_controller_finalize (GObject *object);
static void gimp_controller_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_controller_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static GObjectClass *parent_class = NULL;
G_DEFINE_TYPE_WITH_CODE (GimpController, gimp_controller, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL));
static guint controller_signals[LAST_SIGNAL] = { 0 };
#define parent_class gimp_controller_parent_class
static guint controller_signals[LAST_SIGNAL] = { 0 };
GType
gimp_controller_get_type (void)
{
static GType controller_type = 0;
if (! controller_type)
{
static const GTypeInfo controller_info =
{
sizeof (GimpControllerClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_controller_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpController),
0, /* n_preallocs */
NULL /* instance_init */
};
static const GInterfaceInfo controller_iface_info =
{
NULL, /* iface_init */
NULL, /* iface_finalize */
NULL /* iface_data */
};
controller_type = g_type_register_static (G_TYPE_OBJECT,
"GimpController",
&controller_info, 0);
g_type_add_interface_static (controller_type,
GIMP_TYPE_CONFIG, &controller_iface_info);
}
return controller_type;
}
gboolean
gimp_controller_boolean_handled_accumulator (GSignalInvocationHint *ihint,
@ -124,12 +88,18 @@ gimp_controller_class_init (GimpControllerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_controller_finalize;
object_class->set_property = gimp_controller_set_property;
object_class->get_property = gimp_controller_get_property;
klass->name = "Unnamed";
klass->help_domain = NULL;
klass->help_id = NULL;
klass->get_n_events = NULL;
klass->get_event_name = NULL;
klass->event = NULL;
g_object_class_install_property (object_class, PROP_NAME,
g_param_spec_string ("name", NULL, NULL,
"Unnamed Controller",
@ -151,14 +121,11 @@ gimp_controller_class_init (GimpControllerClass *klass)
_gimp_widgets_marshal_BOOLEAN__POINTER,
G_TYPE_BOOLEAN, 1,
G_TYPE_POINTER);
}
klass->name = "Unnamed";
klass->help_domain = NULL;
klass->help_id = NULL;
klass->get_n_events = NULL;
klass->get_event_name = NULL;
klass->event = NULL;
static void
gimp_controller_init (GimpController *controller)
{
}
static void

48
libgimpwidgets/gimpdialog.c
View File

@ -38,9 +38,6 @@ enum
};
static void gimp_dialog_class_init (GimpDialogClass *klass);
static void gimp_dialog_init (GimpDialog *dialog);
static GObject * gimp_dialog_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
@ -60,37 +57,12 @@ static void gimp_dialog_close (GtkDialog *dialog);
static void gimp_dialog_help (GObject *dialog);
static GtkDialogClass *parent_class = NULL;
static gboolean show_help_button = TRUE;
G_DEFINE_TYPE (GimpDialog, gimp_dialog, GTK_TYPE_DIALOG);
#define parent_class gimp_dialog_parent_class
GType
gimp_dialog_get_type (void)
{
static GType dialog_type = 0;
static gboolean show_help_button = TRUE;
if (! dialog_type)
{
static const GTypeInfo dialog_info =
{
sizeof (GimpDialogClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_dialog_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpDialog),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_dialog_init,
};
dialog_type = g_type_register_static (GTK_TYPE_DIALOG,
"GimpDialog",
&dialog_info, 0);
}
return dialog_type;
}
static void
gimp_dialog_class_init (GimpDialogClass *klass)
@ -99,8 +71,6 @@ gimp_dialog_class_init (GimpDialogClass *klass)
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GtkDialogClass *dialog_class = GTK_DIALOG_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->constructor = gimp_dialog_constructor;
object_class->dispose = gimp_dialog_dispose;
object_class->set_property = gimp_dialog_set_property;
@ -132,6 +102,12 @@ gimp_dialog_class_init (GimpDialogClass *klass)
G_PARAM_CONSTRUCT_ONLY));
}
static void
gimp_dialog_init (GimpDialog *dialog)
{
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
}
static GObject *
gimp_dialog_constructor (GType type,
guint n_params,
@ -234,12 +210,6 @@ gimp_dialog_get_property (GObject *object,
}
}
static void
gimp_dialog_init (GimpDialog *dialog)
{
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
}
static gboolean
gimp_dialog_delete_event (GtkWidget *widget,
GdkEventAny *event)

35
libgimpwidgets/gimpenumcombobox.c
View File

@ -39,8 +39,6 @@ enum
};
static void gimp_enum_combo_box_class_init (GimpEnumComboBoxClass *klass);
static void gimp_enum_combo_box_set_property (GObject *object,
guint prop_id,
const GValue *value,
@ -51,33 +49,11 @@ static void gimp_enum_combo_box_get_property (GObject *object,
GParamSpec *pspec);
GType
gimp_enum_combo_box_get_type (void)
{
static GType enum_combo_box_type = 0;
G_DEFINE_TYPE (GimpEnumComboBox, gimp_enum_combo_box,
GIMP_TYPE_INT_COMBO_BOX);
if (!enum_combo_box_type)
{
static const GTypeInfo enum_combo_box_info =
{
sizeof (GimpEnumComboBoxClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_enum_combo_box_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpEnumComboBox),
0, /* n_preallocs */
NULL /* instance_init */
};
#define parent_class gimp_enum_combo_box_parent_class
enum_combo_box_type = g_type_register_static (GIMP_TYPE_INT_COMBO_BOX,
"GimpEnumComboBox",
&enum_combo_box_info, 0);
}
return enum_combo_box_type;
}
static void
gimp_enum_combo_box_class_init (GimpEnumComboBoxClass *klass)
@ -95,6 +71,11 @@ gimp_enum_combo_box_class_init (GimpEnumComboBoxClass *klass)
G_PARAM_READWRITE));
}
static void
gimp_enum_combo_box_init (GimpEnumComboBox *combo_box)
{
}
static void
gimp_enum_combo_box_set_property (GObject *object,
guint prop_id,

40
libgimpwidgets/gimpenumlabel.c
View File

@ -31,51 +31,27 @@
#include "gimpenumlabel.h"
static void gimp_enum_label_class_init (GimpEnumLabelClass *klass);
static void gimp_enum_label_finalize (GObject *object);
static void gimp_enum_label_finalize (GObject *object);
static GtkLabelClass *parent_class = NULL;
G_DEFINE_TYPE (GimpEnumLabel, gimp_enum_label, GTK_TYPE_LABEL);
#define parent_class gimp_enum_label_parent_class
GType
gimp_enum_label_get_type (void)
{
static GType enum_label_type = 0;
if (!enum_label_type)
{
static const GTypeInfo enum_label_info =
{
sizeof (GimpEnumLabelClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_enum_label_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpEnumLabel),
0, /* n_preallocs */
NULL /* instance_init */
};
enum_label_type = g_type_register_static (GTK_TYPE_LABEL,
"GimpEnumLabel",
&enum_label_info, 0);
}
return enum_label_type;
}
static void
gimp_enum_label_class_init (GimpEnumLabelClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_enum_label_finalize;
}
static void
gimp_enum_label_init (GimpEnumLabel *enum_label)
{
}
static void
gimp_enum_label_finalize (GObject *object)
{

45
libgimpwidgets/gimpenumstore.c
View File

@ -31,55 +31,30 @@
#include "gimpenumstore.h"
static void gimp_enum_store_class_init (GimpEnumStoreClass *klass);
static void gimp_enum_store_finalize (GObject *object);
static void gimp_enum_store_finalize (GObject *object);
static void gimp_enum_store_add_value (GtkListStore *store,
GEnumValue *value);
static void gimp_enum_store_add_value (GtkListStore *store,
GEnumValue *value);
static GimpEnumStoreClass *parent_class = NULL;
G_DEFINE_TYPE (GimpEnumStore, gimp_enum_store, GIMP_TYPE_INT_STORE);
#define parent_class gimp_enum_store_parent_class
GType
gimp_enum_store_get_type (void)
{
static GType enum_store_type = 0;
if (!enum_store_type)
{
static const GTypeInfo enum_store_info =
{
sizeof (GimpEnumStoreClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_enum_store_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpEnumStore),
0, /* n_preallocs */
NULL /* instance_init */
};
enum_store_type = g_type_register_static (GIMP_TYPE_INT_STORE,
"GimpEnumStore",
&enum_store_info, 0);
}
return enum_store_type;
}
static void
gimp_enum_store_class_init (GimpEnumStoreClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_enum_store_finalize;
}
static void
gimp_enum_store_init (GimpEnumStore *store)
{
}
static void
gimp_enum_store_finalize (GObject *object)
{

55
libgimpwidgets/gimpfileentry.c
View File

@ -40,61 +40,30 @@ enum
};
static void gimp_file_entry_class_init (GimpFileEntryClass *klass);
static void gimp_file_entry_init (GimpFileEntry *entry);
static void gimp_file_entry_destroy (GtkObject *object);
static void gimp_file_entry_destroy (GtkObject *object);
static void gimp_file_entry_entry_activate (GtkWidget *widget,
GimpFileEntry *entry);
static gint gimp_file_entry_entry_focus_out (GtkWidget *widget,
GdkEvent *event,
GimpFileEntry *entry);
static void gimp_file_entry_browse_clicked (GtkWidget *widget,
GimpFileEntry *entry);
static void gimp_file_entry_check_filename (GimpFileEntry *entry);
static void gimp_file_entry_entry_activate (GtkWidget *widget,
GimpFileEntry *entry);
static gint gimp_file_entry_entry_focus_out (GtkWidget *widget,
GdkEvent *event,
GimpFileEntry *entry);
static void gimp_file_entry_browse_clicked (GtkWidget *widget,
GimpFileEntry *entry);
static void gimp_file_entry_check_filename (GimpFileEntry *entry);
G_DEFINE_TYPE (GimpFileEntry, gimp_file_entry, GTK_TYPE_HBOX);
#define parent_class gimp_file_entry_parent_class
static guint gimp_file_entry_signals[LAST_SIGNAL] = { 0 };
static GtkHBoxClass *parent_class = NULL;
GType
gimp_file_entry_get_type (void)
{
static GType entry_type = 0;
if (! entry_type)
{
static const GTypeInfo entry_info =
{
sizeof (GimpFileEntryClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_file_entry_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpFileEntry),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_file_entry_init,
};
entry_type = g_type_register_static (GTK_TYPE_HBOX,
"GimpFileEntry",
&entry_info, 0);
}
return entry_type;
}
static void
gimp_file_entry_class_init (GimpFileEntryClass *klass)
{
GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
/**
* GimpFileEntry::filename-changed:
*

36
libgimpwidgets/gimpframe.c
View File

@ -38,9 +38,6 @@
#define GIMP_FRAME_IN_EXPANDER_KEY "gimp-frame-in-expander"
static void gimp_frame_class_init (GimpFrameClass *klass);
static void gimp_frame_init (GimpFrame *frame);
static void gimp_frame_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gimp_frame_size_allocate (GtkWidget *widget,
@ -56,37 +53,10 @@ static gint gimp_frame_get_indent (GtkWidget *widget);
static gint gimp_frame_get_label_spacing (GtkFrame *frame);
static GtkFrameClass *parent_class = NULL;
G_DEFINE_TYPE (GimpFrame, gimp_frame, GTK_TYPE_FRAME);
#define parent_class gimp_frame_parent_class
GType
gimp_frame_get_type (void)
{
static GType frame_type = 0;
if (! frame_type)
{
static const GTypeInfo frame_info =
{
sizeof (GimpFrameClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_frame_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpFrame),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_frame_init,
NULL /* value_table */
};
frame_type = g_type_register_static (GTK_TYPE_FRAME,
"GimpFrame",
&frame_info, 0);
}
return frame_type;
}
static void
gimp_frame_class_init (GimpFrameClass *klass)
@ -94,8 +64,6 @@ gimp_frame_class_init (GimpFrameClass *klass)
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GtkFrameClass *frame_class = GTK_FRAME_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
widget_class->size_request = gimp_frame_size_request;
widget_class->size_allocate = gimp_frame_size_allocate;
widget_class->style_set = gimp_frame_style_set;

91
libgimpwidgets/gimpintcombobox.c
View File

@ -53,9 +53,6 @@ typedef struct
#define GIMP_INT_COMBO_BOX_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIMP_TYPE_INT_COMBO_BOX, GimpIntComboBoxPrivate))
static void gimp_int_combo_box_class_init (GimpIntComboBoxClass *klass);
static void gimp_int_combo_box_init (GimpIntComboBox *combo_box);
static void gimp_int_combo_box_finalize (GObject *object);
static void gimp_int_combo_box_set_property (GObject *object,
guint property_id,
@ -73,44 +70,16 @@ static void gimp_int_combo_box_data_func (GtkCellLayout *layout,
gpointer data);
static GtkComboBoxClass *parent_class = NULL;
G_DEFINE_TYPE (GimpIntComboBox, gimp_int_combo_box, GTK_TYPE_COMBO_BOX);
#define parent_class gimp_int_combo_box_parent_class
GType
gimp_int_combo_box_get_type (void)
{
static GType box_type = 0;
if (! box_type)
{
static const GTypeInfo box_info =
{
sizeof (GimpIntComboBoxClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_int_combo_box_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpIntComboBox),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_int_combo_box_init
};
box_type = g_type_register_static (GTK_TYPE_COMBO_BOX,
"GimpIntComboBox",
&box_info, 0);
}
return box_type;
}
static void
gimp_int_combo_box_class_init (GimpIntComboBoxClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->set_property = gimp_int_combo_box_set_property;
object_class->get_property = gimp_int_combo_box_get_property;
object_class->finalize = gimp_int_combo_box_finalize;
@ -134,6 +103,34 @@ gimp_int_combo_box_class_init (GimpIntComboBoxClass *klass)
g_type_class_add_private (object_class, sizeof (GimpIntComboBoxPrivate));
}
static void
gimp_int_combo_box_init (GimpIntComboBox *combo_box)
{
GimpIntComboBoxPrivate *priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
GtkListStore *store;
GtkCellRenderer *cell;
store = gimp_int_store_new ();
gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
g_object_unref (store);
priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
priv->pixbuf_renderer = cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"stock_id", GIMP_INT_STORE_STOCK_ID,
"pixbuf", GIMP_INT_STORE_PIXBUF,
NULL);
priv->text_renderer = cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"text", GIMP_INT_STORE_LABEL,
NULL);
}
static void
gimp_int_combo_box_finalize (GObject *object)
{
@ -190,34 +187,6 @@ gimp_int_combo_box_get_property (GObject *object,
}
}
static void
gimp_int_combo_box_init (GimpIntComboBox *combo_box)
{
GimpIntComboBoxPrivate *priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
GtkListStore *store;
GtkCellRenderer *cell;
store = gimp_int_store_new ();
gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
g_object_unref (store);
priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
priv->pixbuf_renderer = cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"stock_id", GIMP_INT_STORE_STOCK_ID,
"pixbuf", GIMP_INT_STORE_PIXBUF,
NULL);
priv->text_renderer = cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"text", GIMP_INT_STORE_LABEL,
NULL);
}
/**
* gimp_int_combo_box_new:

64
libgimpwidgets/gimpintstore.c
View File

@ -33,9 +33,7 @@
#include "libgimp/libgimp-intl.h"
static void gimp_int_store_class_init (GimpIntStoreClass *klass);
static void gimp_int_store_tree_model_init (GtkTreeModelIface *iface);
static void gimp_int_store_init (GimpIntStore *store);
static void gimp_int_store_finalize (GObject *object);
static void gimp_int_store_row_inserted (GtkTreeModel *model,
GtkTreePath *path,
@ -43,65 +41,23 @@ static void gimp_int_store_row_inserted (GtkTreeModel *model,
static void gimp_int_store_add_empty (GimpIntStore *store);
static GtkListStoreClass *parent_class = NULL;
G_DEFINE_TYPE_WITH_CODE (GimpIntStore, gimp_int_store, GTK_TYPE_LIST_STORE,
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
gimp_int_store_tree_model_init));
#define parent_class gimp_int_store_parent_class
static GtkTreeModelIface *parent_iface = NULL;
GType
gimp_int_store_get_type (void)
{
static GType store_type = 0;
if (! store_type)
{
static const GTypeInfo store_info =
{
sizeof (GimpIntStoreClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_int_store_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpIntStore),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_int_store_init
};
static const GInterfaceInfo iface_info =
{
(GInterfaceInitFunc) gimp_int_store_tree_model_init,
NULL, /* iface_finalize */
NULL /* iface_data */
};
store_type = g_type_register_static (GTK_TYPE_LIST_STORE,
"GimpIntStore",
&store_info, 0);
g_type_add_interface_static (store_type, GTK_TYPE_TREE_MODEL,
&iface_info);
}
return store_type;
}
static void
gimp_int_store_class_init (GimpIntStoreClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_int_store_finalize;
}
static void
gimp_int_store_tree_model_init (GtkTreeModelIface *iface)
{
parent_iface = g_type_interface_peek_parent (iface);
iface->row_inserted = gimp_int_store_row_inserted;
}
static void
gimp_int_store_init (GimpIntStore *store)
{
@ -121,6 +77,14 @@ gimp_int_store_init (GimpIntStore *store)
gimp_int_store_add_empty (store);
}
static void
gimp_int_store_tree_model_init (GtkTreeModelIface *iface)
{
parent_iface = g_type_interface_peek_parent (iface);
iface->row_inserted = gimp_int_store_row_inserted;
}
static void
gimp_int_store_finalize (GObject *object)
{

53
libgimpwidgets/gimpmemsizeentry.c
View File

@ -38,58 +38,31 @@ enum
LAST_SIGNAL
};
static void gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass);
static void gimp_memsize_entry_init (GimpMemsizeEntry *entry);
static void gimp_memsize_entry_finalize (GObject *object);
static void gimp_memsize_entry_adj_callback (GtkAdjustment *adj,
GimpMemsizeEntry *entry);
static void gimp_memsize_entry_unit_callback (GtkWidget *widget,
GimpMemsizeEntry *entry);
static void gimp_memsize_entry_finalize (GObject *object);
static void gimp_memsize_entry_adj_callback (GtkAdjustment *adj,
GimpMemsizeEntry *entry);
static void gimp_memsize_entry_unit_callback (GtkWidget *widget,
GimpMemsizeEntry *entry);
static guint gimp_memsize_entry_signals[LAST_SIGNAL] = { 0 };
static GtkHBoxClass *parent_class = NULL;
G_DEFINE_TYPE (GimpMemsizeEntry, gimp_memsize_entry, GTK_TYPE_HBOX);
#define parent_class gimp_memsize_entry_parent_class
GType
gimp_memsize_entry_get_type (void)
{
static GType entry_type = 0;
static guint gimp_memsize_entry_signals[LAST_SIGNAL] = { 0 };
if (! entry_type)
{
static const GTypeInfo entry_info =
{
sizeof (GimpMemsizeEntryClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_memsize_entry_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpMemsizeEntry),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_memsize_entry_init,
};
entry_type = g_type_register_static (GTK_TYPE_HBOX, "GimpMemsizeEntry",
&entry_info, 0);
}
return entry_type;
}
static void
gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass)
{
GObjectClass *object_class;
parent_class = g_type_class_peek_parent (klass);
object_class = G_OBJECT_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_memsize_entry_finalize;
klass->value_changed = NULL;
gimp_memsize_entry_signals[VALUE_CHANGED] =
g_signal_new ("value-changed",
G_TYPE_FROM_CLASS (klass),
@ -98,8 +71,6 @@ gimp_memsize_entry_class_init (GimpMemsizeEntryClass *klass)
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
klass->value_changed = NULL;
}
static void

51
libgimpwidgets/gimpoffsetarea.c
View File

@ -40,58 +40,27 @@ enum
};
static void gimp_offset_area_class_init (GimpOffsetAreaClass *klass);
static void gimp_offset_area_init (GimpOffsetArea *area);
static void gimp_offset_area_resize (GimpOffsetArea *area);
static void gimp_offset_area_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gboolean gimp_offset_area_event (GtkWidget *widget,
GdkEvent *event);
static gboolean gimp_offset_area_expose_event (GtkWidget *widget,
GdkEventExpose *eevent);
static void gimp_offset_area_resize (GimpOffsetArea *area);
static void gimp_offset_area_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gboolean gimp_offset_area_event (GtkWidget *widget,
GdkEvent *event);
static gboolean gimp_offset_area_expose_event (GtkWidget *widget,
GdkEventExpose *eevent);
G_DEFINE_TYPE (GimpOffsetArea, gimp_offset_area, GTK_TYPE_DRAWING_AREA);
#define parent_class gimp_offset_area_parent_class
static guint gimp_offset_area_signals[LAST_SIGNAL] = { 0 };
static GtkDrawingAreaClass *parent_class = NULL;
GType
gimp_offset_area_get_type (void)
{
static GType area_type = 0;
if (! area_type)
{
static const GTypeInfo area_info =
{
sizeof (GimpOffsetAreaClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_offset_area_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpOffsetArea),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_offset_area_init,
};
area_type = g_type_register_static (GTK_TYPE_DRAWING_AREA,
"GimpOffsetArea",
&area_info, 0);
}
return area_type;
}
static void
gimp_offset_area_class_init (GimpOffsetAreaClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
gimp_offset_area_signals[OFFSETS_CHANGED] =
g_signal_new ("offsets-changed",
G_TYPE_FROM_CLASS (klass),

36
libgimpwidgets/gimppageselector.c
View File

@ -83,9 +83,6 @@ struct _GimpPageSelectorPrivate
#define GIMP_PAGE_SELECTOR_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIMP_TYPE_PAGE_SELECTOR, GimpPageSelectorPrivate))
static void gimp_page_selector_class_init (GimpPageSelectorClass *klass);
static void gimp_page_selector_init (GimpPageSelector *selector);
static void gimp_page_selector_dispose (GObject *object);
static void gimp_page_selector_finalize (GObject *object);
static void gimp_page_selector_get_property (GObject *object,
@ -122,37 +119,12 @@ static GdkPixbuf * gimp_page_selector_add_frame (GtkWidget *widget,
GdkPixbuf *pixbuf);
static guint selector_signals[LAST_SIGNAL] = { 0 };
static GtkVBoxClass *parent_class = NULL;
G_DEFINE_TYPE (GimpPageSelector, gimp_page_selector, GTK_TYPE_VBOX);
#define parent_class gimp_page_selector_parent_class
GType
gimp_page_selector_get_type (void)
{
static GType selector_type = 0;
static guint selector_signals[LAST_SIGNAL] = { 0 };
if (!selector_type)
{
static const GTypeInfo selector_info =
{
sizeof (GimpPageSelectorClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_page_selector_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPageSelector),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_page_selector_init,
};
selector_type = g_type_register_static (GTK_TYPE_VBOX,
"GimpPageSelector",
&selector_info, 0);
}
return selector_type;
}
static void
gimp_page_selector_class_init (GimpPageSelectorClass *klass)
@ -160,8 +132,6 @@ gimp_page_selector_class_init (GimpPageSelectorClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->dispose = gimp_page_selector_dispose;
object_class->finalize = gimp_page_selector_finalize;
object_class->get_property = gimp_page_selector_get_property;

63
libgimpwidgets/gimppatheditor.c
View File

@ -52,62 +52,31 @@ enum
};
static void gimp_path_editor_class_init (GimpPathEditorClass *klass);
static void gimp_path_editor_init (GimpPathEditor *editor);
static void gimp_path_editor_new_clicked (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_move_clicked (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_delete_clicked (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_file_entry_changed (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_selection_changed (GtkTreeSelection *sel,
GimpPathEditor *editor);
static void gimp_path_editor_writable_toggled (GtkCellRendererToggle *toggle,
gchar *path_str,
GimpPathEditor *editor);
static void gimp_path_editor_new_clicked (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_move_clicked (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_delete_clicked (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_file_entry_changed (GtkWidget *widget,
GimpPathEditor *editor);
static void gimp_path_editor_selection_changed (GtkTreeSelection *sel,
GimpPathEditor *editor);
static void gimp_path_editor_writable_toggled (GtkCellRendererToggle *toggle,
gchar *path_str,
GimpPathEditor *editor);
G_DEFINE_TYPE (GimpPathEditor, gimp_path_editor, GTK_TYPE_VBOX);
#define parent_class gimp_path_editor_parent_class
static guint gimp_path_editor_signals[LAST_SIGNAL] = { 0 };
static GtkVBoxClass *parent_class = NULL;
GType
gimp_path_editor_get_type (void)
{
static GType type = 0;
if (! type)
{
static const GTypeInfo info =
{
sizeof (GimpPathEditorClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_path_editor_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPathEditor),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_path_editor_init,
};
type = g_type_register_static (GTK_TYPE_VBOX,
"GimpPathEditor",
&info, 0);
}
return type;
}
static void
gimp_path_editor_class_init (GimpPathEditorClass *klass)
{
parent_class = g_type_class_peek_parent (klass);
/**
* GimpPathEditor::path-changed:
*

37
libgimpwidgets/gimppickbutton.c
View File

@ -40,9 +40,6 @@ enum
};
static void gimp_pick_button_class_init (GimpPickButtonClass *klass);
static void gimp_pick_button_init (GimpPickButton *editor);
static void gimp_pick_button_destroy (GtkObject *object);
static void gimp_pick_button_clicked (GtkButton *button);
@ -66,38 +63,12 @@ static void gimp_pick_button_pick (GdkScreen *screen,
GimpPickButton *button);
static guint pick_button_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (GimpPickButton, gimp_pick_button, GTK_TYPE_BUTTON);
static GtkButtonClass *parent_class = NULL;
#define parent_class gimp_pick_button_parent_class
static guint pick_button_signals[LAST_SIGNAL] = { 0 };
GType
gimp_pick_button_get_type (void)
{
static GType button_type = 0;
if (! button_type)
{
static const GTypeInfo button_info =
{
sizeof (GimpPickButtonClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_pick_button_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPickButton),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_pick_button_init,
};
button_type = g_type_register_static (GTK_TYPE_BUTTON,
"GimpPickButton",
&button_info, 0);
}
return button_type;
}
static void
gimp_pick_button_class_init (GimpPickButtonClass* klass)
@ -105,8 +76,6 @@ gimp_pick_button_class_init (GimpPickButtonClass* klass)
GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
pick_button_signals[COLOR_PICKED] =
g_signal_new ("color-picked",
G_TYPE_FROM_CLASS (klass),

39
libgimpwidgets/gimppixmap.c
View File

@ -30,51 +30,20 @@
#include "gimppixmap.h"
static void gimp_pixmap_class_init (GimpPixmapClass *klass);
static void gimp_pixmap_init (GimpPixmap *pixmap);
static void gimp_pixmap_realize (GtkWidget *widget);
static void gimp_pixmap_create_from_xpm_d (GimpPixmap *pixmap);
static void gimp_pixmap_realize (GtkWidget *widget);
static void gimp_pixmap_create_from_xpm_d (GimpPixmap *pixmap);
static GtkImageClass *parent_class = NULL;
G_DEFINE_TYPE (GimpPixmap, gimp_pixmap, GTK_TYPE_IMAGE);
#define parent_class gimp_pixmap_parent_class
GType
gimp_pixmap_get_type (void)
{
static GType pixmap_type = 0;
if (! pixmap_type)
{
static const GTypeInfo pixmap_info =
{
sizeof (GimpPixmapClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_pixmap_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPixmap),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_pixmap_init,
};
pixmap_type = g_type_register_static (GTK_TYPE_IMAGE,
"GimpPixmap",
&pixmap_info, 0);
}
return pixmap_type;
}
static void
gimp_pixmap_class_init (GimpPixmapClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
widget_class->realize = gimp_pixmap_realize;
}

42
libgimpwidgets/gimppreviewarea.c
View File

@ -43,9 +43,10 @@ enum
#define DEFAULT_CHECK_SIZE GIMP_CHECK_SIZE_MEDIUM_CHECKS
#define DEFAULT_CHECK_TYPE GIMP_CHECK_TYPE_GRAY_CHECKS
#define CHECK_COLOR(area, row, col) \
(((((area)->offset_y + (row)) & size) ^ \
(((area)->offset_x + (col)) & size)) ? dark : light)
static void gimp_preview_area_class_init (GimpPreviewAreaClass *klass);
static void gimp_preview_area_init (GimpPreviewArea *area);
static void gimp_preview_area_finalize (GObject *object);
static void gimp_preview_area_set_property (GObject *object,
@ -70,41 +71,10 @@ static void gimp_preview_area_queue_draw (GimpPreviewArea *area,
static gint gimp_preview_area_image_type_bytes (GimpImageType type);
static GtkDrawingAreaClass *parent_class = NULL;
G_DEFINE_TYPE (GimpPreviewArea, gimp_preview_area, GTK_TYPE_DRAWING_AREA);
#define parent_class gimp_preview_area_parent_class
#define CHECK_COLOR(area, row, col) \
(((((area)->offset_y + (row)) & size) ^ \
(((area)->offset_x + (col)) & size)) ? dark : light)
GType
gimp_preview_area_get_type (void)
{
static GType view_type = 0;
if (! view_type)
{
static const GTypeInfo view_info =
{
sizeof (GimpPreviewAreaClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_preview_area_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpPreviewArea),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_preview_area_init,
};
view_type = g_type_register_static (GTK_TYPE_DRAWING_AREA,
"GimpPreviewArea",
&view_info, 0);
}
return view_type;
}
static void
gimp_preview_area_class_init (GimpPreviewAreaClass *klass)
@ -112,8 +82,6 @@ gimp_preview_area_class_init (GimpPreviewAreaClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gimp_preview_area_finalize;
object_class->set_property = gimp_preview_area_set_property;
object_class->get_property = gimp_preview_area_get_property;

49
libgimpwidgets/gimpsizeentry.c
View File

@ -71,9 +71,6 @@ struct _GimpSizeEntryField
};
static void gimp_size_entry_class_init (GimpSizeEntryClass *class);
static void gimp_size_entry_init (GimpSizeEntry *gse);
static void gimp_size_entry_finalize (GObject *object);
static void gimp_size_entry_update_value (GimpSizeEntryField *gsef,
@ -90,47 +87,17 @@ static void gimp_size_entry_unit_callback (GtkWidget *widget,
GimpSizeEntry *sizeentry);
G_DEFINE_TYPE (GimpSizeEntry, gimp_size_entry, GTK_TYPE_TABLE);
#define parent_class gimp_size_entry_parent_class
static guint gimp_size_entry_signals[LAST_SIGNAL] = { 0 };
static GtkTableClass *parent_class = NULL;
GType
gimp_size_entry_get_type (void)
{
static GType gse_type = 0;
if (! gse_type)
{
static const GTypeInfo gse_info =
{
sizeof (GimpSizeEntryClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_size_entry_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpSizeEntry),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_size_entry_init,
};
gse_type = g_type_register_static (GTK_TYPE_TABLE,
"GimpSizeEntry",
&gse_info, 0);
}
return gse_type;
}
static void
gimp_size_entry_class_init (GimpSizeEntryClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
gimp_size_entry_signals[VALUE_CHANGED] =
g_signal_new ("value-changed",
@ -182,11 +149,7 @@ gimp_size_entry_init (GimpSizeEntry *gse)
static void
gimp_size_entry_finalize (GObject *object)
{
GimpSizeEntry *gse;
g_return_if_fail (GIMP_IS_SIZE_ENTRY (object));
gse = GIMP_SIZE_ENTRY (object);
GimpSizeEntry *gse = GIMP_SIZE_ENTRY (object);
if (gse->fields)
{

53
libgimpwidgets/gimpunitmenu.c
View File

@ -51,57 +51,26 @@ enum
};
static void gimp_unit_menu_class_init (GimpUnitMenuClass *klass);
static void gimp_unit_menu_init (GimpUnitMenu *menu);
static void gimp_unit_menu_finalize (GObject *object);
static void gimp_unit_menu_finalize (GObject *object);
static const gchar * gimp_unit_menu_build_string (const gchar *format,
GimpUnit unit);
static void gimp_unit_menu_callback (GtkWidget *widget,
gpointer data);
static const gchar * gimp_unit_menu_build_string (const gchar *format,
GimpUnit unit);
static void gimp_unit_menu_callback (GtkWidget *widget,
gpointer data);
G_DEFINE_TYPE (GimpUnitMenu, gimp_unit_menu, GTK_TYPE_OPTION_MENU);
#define parent_class gimp_unit_menu_parent_class
static guint gimp_unit_menu_signals[LAST_SIGNAL] = { 0 };
static GtkOptionMenuClass *parent_class = NULL;
GType
gimp_unit_menu_get_type (void)
{
static GType menu_type = 0;
if (! menu_type)
{
static const GTypeInfo menu_info =
{
sizeof (GimpUnitMenuClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gimp_unit_menu_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpUnitMenu),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_unit_menu_init,
};
menu_type = g_type_register_static (GTK_TYPE_OPTION_MENU,
"GimpUnitMenu",
&menu_info, 0);
}
return menu_type;
}
static void
gimp_unit_menu_class_init (GimpUnitMenuClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
/**
* GimpUnitMenu::unit-changed:
*
@ -136,11 +105,7 @@ gimp_unit_menu_init (GimpUnitMenu *menu)
static void
gimp_unit_menu_finalize (GObject *object)
{
GimpUnitMenu *menu;
g_return_if_fail (GIMP_IS_UNIT_MENU (object));
menu = GIMP_UNIT_MENU (object);
GimpUnitMenu *menu = GIMP_UNIT_MENU (object);
if (menu->format)
{