Commit 744bebc8 authored by Sven Neumann's avatar Sven Neumann Committed by Sven Neumann
Browse files

app/widgets/Makefile.am moved to libgimpwidgets.

2004-07-26  Sven Neumann  <sven@gimp.org>

	* app/widgets/Makefile.am
	* app/widgets/gimpcellrenderertoggle.[ch]: moved to libgimpwidgets.

	* app/widgets/gimpcomponenteditor.c
	* app/widgets/gimpcontainertreeview.c
	* app/widgets/gimpitemtreeview.c
	* app/widgets/gimplayertreeview.c
	* app/widgets/gimptoolview.c
	* app/widgets/widgets-types.h

	* libgimpwidgets/Makefile.am
	* libgimpwidgets/gimpwidgets.def
	* libgimpwidgets/gimpwidgets.h
	* libgimpwidgets/gimpwidgetsmarshal.list
	* libgimpwidgets/gimpwidgetstypes.h
	* libgimpwidgets/gimpcellrenderertoggle.[ch]: custom toggle cell
	renderer moved here from app/widgets.

	* libgimpwidgets/gimpcellrenderercolor.[ch]: unified code with the
	new toggle cell renderer.
parent a2b85a62
2004-07-26 Sven Neumann <sven@gimp.org>
* app/widgets/Makefile.am
* app/widgets/gimpcellrenderertoggle.[ch]: moved to libgimpwidgets.
* app/widgets/gimpcomponenteditor.c
* app/widgets/gimpcontainertreeview.c
* app/widgets/gimpitemtreeview.c
* app/widgets/gimplayertreeview.c
* app/widgets/gimptoolview.c
* app/widgets/widgets-types.h
* libgimpwidgets/Makefile.am
* libgimpwidgets/gimpwidgets.def
* libgimpwidgets/gimpwidgets.h
* libgimpwidgets/gimpwidgetsmarshal.list
* libgimpwidgets/gimpwidgetstypes.h
* libgimpwidgets/gimpcellrenderertoggle.[ch]: custom toggle cell
renderer moved here from app/widgets.
* libgimpwidgets/gimpcellrenderercolor.[ch]: unified code with the
new toggle cell renderer.
2004-07-26 Michael Natterer <mitch@gimp.org>
* app/pdb/procedural_db.[ch] (procedural_db_free_data): new
......
......@@ -37,8 +37,6 @@ libappwidgets_a_sources = \
gimpbufferview.h \
gimpcellrendereraccel.c \
gimpcellrendereraccel.h \
gimpcellrenderertoggle.c \
gimpcellrenderertoggle.h \
gimpcellrendererviewable.c \
gimpcellrendererviewable.h \
gimpchanneltreeview.c \
......
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcellrenderertoggle.c
* Copyright (C) 2003 Sven Neumann <sven@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <config.h>
#include <gtk/gtk.h>
#include "widgets-types.h"
#include "core/gimpmarshal.h"
#include "gimpcellrenderertoggle.h"
#define DEFAULT_ICON_SIZE GTK_ICON_SIZE_BUTTON
enum
{
CLICKED,
LAST_SIGNAL
};
enum
{
PROP_0,
PROP_STOCK_ID,
PROP_STOCK_SIZE
};
static void gimp_cell_renderer_toggle_class_init (GimpCellRendererToggleClass *klass);
static void gimp_cell_renderer_toggle_init (GimpCellRendererToggle *toggle);
static void gimp_cell_renderer_toggle_finalize (GObject *object);
static void gimp_cell_renderer_toggle_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec);
static void gimp_cell_renderer_toggle_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
GdkRectangle *rectangle,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height);
static void gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags);
static gboolean gimp_cell_renderer_toggle_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags);
static void gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *toggle,
GtkWidget *widget);
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 */
(GInstanceInitFunc) gimp_cell_renderer_toggle_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)
{
GObjectClass *object_class;
GtkCellRendererClass *cell_class;
object_class = G_OBJECT_CLASS (klass);
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),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpCellRendererToggleClass, clicked),
NULL, NULL,
gimp_marshal_VOID__STRING_FLAGS,
G_TYPE_NONE, 2,
G_TYPE_STRING,
GDK_TYPE_MODIFIER_TYPE);
object_class->finalize = gimp_cell_renderer_toggle_finalize;
object_class->get_property = gimp_cell_renderer_toggle_get_property;
object_class->set_property = gimp_cell_renderer_toggle_set_property;
cell_class->get_size = gimp_cell_renderer_toggle_get_size;
cell_class->render = gimp_cell_renderer_toggle_render;
cell_class->activate = gimp_cell_renderer_toggle_activate;
g_object_class_install_property (object_class,
PROP_STOCK_ID,
g_param_spec_string ("stock_id",
NULL, NULL,
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STOCK_SIZE,
g_param_spec_enum ("stock_size",
NULL, NULL,
GTK_TYPE_ICON_SIZE,
DEFAULT_ICON_SIZE,
G_PARAM_READWRITE));
}
static void
gimp_cell_renderer_toggle_init (GimpCellRendererToggle *cell)
{
GTK_CELL_RENDERER (cell)->xpad = 0;
GTK_CELL_RENDERER (cell)->ypad = 0;
cell->stock_id = NULL;
cell->stock_size = DEFAULT_ICON_SIZE;
}
static void
gimp_cell_renderer_toggle_finalize (GObject *object)
{
GimpCellRendererToggle *toggle;
toggle = GIMP_CELL_RENDERER_TOGGLE (object);
if (toggle->stock_id)
{
g_free (toggle->stock_id);
toggle->stock_id = NULL;
}
if (toggle->pixbuf)
{
g_object_unref (toggle->pixbuf);
toggle->pixbuf = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_cell_renderer_toggle_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GimpCellRendererToggle *toggle;
toggle = GIMP_CELL_RENDERER_TOGGLE (object);
switch (param_id)
{
case PROP_STOCK_ID:
g_value_set_string (value, toggle->stock_id);
break;
case PROP_STOCK_SIZE:
g_value_set_enum (value, toggle->stock_size);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
static void
gimp_cell_renderer_toggle_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GimpCellRendererToggle *toggle;
toggle = GIMP_CELL_RENDERER_TOGGLE (object);
switch (param_id)
{
case PROP_STOCK_ID:
if (toggle->stock_id)
g_free (toggle->stock_id);
toggle->stock_id = g_value_dup_string (value);
break;
case PROP_STOCK_SIZE:
toggle->stock_size = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
if (toggle->pixbuf)
{
g_object_unref (toggle->pixbuf);
toggle->pixbuf = NULL;
}
}
static void
gimp_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height)
{
GimpCellRendererToggle *toggle;
gint calc_width;
gint calc_height;
gint pixbuf_width;
gint pixbuf_height;
toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
if (!toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->get_size (cell,
widget,
cell_area,
x_offset, y_offset,
width, height);
return;
}
if (!toggle->pixbuf)
gimp_cell_renderer_toggle_create_pixbuf (toggle, widget);
pixbuf_width = gdk_pixbuf_get_width (toggle->pixbuf);
pixbuf_height = gdk_pixbuf_get_height (toggle->pixbuf);
calc_width = (pixbuf_width +
(gint) cell->xpad * 2 + widget->style->xthickness * 2);
calc_height = (pixbuf_height +
(gint) cell->ypad * 2 + widget->style->ythickness * 2);
if (x_offset) *x_offset = 0;
if (y_offset) *y_offset = 0;
if (cell_area)
{
if (x_offset)
{
*x_offset = (((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?
(1.0 - cell->xalign) : cell->xalign) *
(cell_area->width - calc_width));
*x_offset = MAX (*x_offset, 0);
}
if (y_offset)
{
*y_offset = cell->yalign * (cell_area->height - calc_height);
*y_offset = MAX (*y_offset, 0);
}
}
if (width) *width = calc_width;
if (height) *height = calc_height;
}
static void
gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags)
{
GimpCellRendererToggle *toggle;
GdkRectangle toggle_rect;
GdkRectangle draw_rect;
GtkStateType state;
gboolean active;
toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
if (!toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, window, widget,
background_area,
cell_area, expose_area,
flags);
return;
}
gimp_cell_renderer_toggle_get_size (cell, widget, cell_area,
&toggle_rect.x,
&toggle_rect.y,
&toggle_rect.width,
&toggle_rect.height);
toggle_rect.x += cell_area->x + cell->xpad;
toggle_rect.y += cell_area->y + cell->ypad;
toggle_rect.width -= cell->xpad * 2;
toggle_rect.height -= cell->ypad * 2;
if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
return;
active =
gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
if (GTK_WIDGET_HAS_FOCUS (widget))
state = GTK_STATE_SELECTED;
else
state = GTK_STATE_ACTIVE;
}
else
{
if (GTK_CELL_RENDERER_TOGGLE (cell)->activatable)
state = GTK_STATE_NORMAL;
else
state = GTK_STATE_INSENSITIVE;
}
if (gdk_rectangle_intersect (expose_area, cell_area, &draw_rect) &&
(flags & GTK_CELL_RENDERER_PRELIT))
gtk_paint_shadow (widget->style,
window,
state,
active ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
&draw_rect,
widget, NULL,
toggle_rect.x, toggle_rect.y,
toggle_rect.width, toggle_rect.height);
if (active)
{
toggle_rect.x += widget->style->xthickness;
toggle_rect.y += widget->style->ythickness;
toggle_rect.width -= widget->style->xthickness * 2;
toggle_rect.height -= widget->style->ythickness * 2;
if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
gdk_draw_pixbuf (window,
widget->style->black_gc,
toggle->pixbuf,
/* pixbuf 0, 0 is at toggle_rect.x, toggle_rect.y */
draw_rect.x - toggle_rect.x,
draw_rect.y - toggle_rect.y,
draw_rect.x,
draw_rect.y,
draw_rect.width,
draw_rect.height,
GDK_RGB_DITHER_NORMAL,
0, 0);
}
}
static gboolean
gimp_cell_renderer_toggle_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererToggle *celltoggle;
celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
if (celltoggle->activatable)
{
GdkModifierType state = 0;
if (event && ((GdkEventAny *) event)->type == GDK_BUTTON_PRESS)
state = ((GdkEventButton *) event)->state;
gimp_cell_renderer_toggle_clicked (GIMP_CELL_RENDERER_TOGGLE (cell),
path, state);
return TRUE;
}
return FALSE;
}
static void
gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *toggle,
GtkWidget *widget)
{
if (toggle->pixbuf)
g_object_unref (toggle->pixbuf);
toggle->pixbuf = gtk_widget_render_icon (widget,
toggle->stock_id,
toggle->stock_size, NULL);
}
GtkCellRenderer *
gimp_cell_renderer_toggle_new (const gchar *stock_id)
{
return g_object_new (GIMP_TYPE_CELL_RENDERER_TOGGLE,
"stock_id", stock_id,
NULL);
}
void
gimp_cell_renderer_toggle_clicked (GimpCellRendererToggle *cell,
const gchar *path,
GdkModifierType state)
{
g_return_if_fail (GIMP_IS_CELL_RENDERER_TOGGLE (cell));
g_return_if_fail (path != NULL);
g_signal_emit (cell, toggle_cell_signals[CLICKED], 0, path, state);
}
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcellrenderertoggle.h
* Copyright (C) 2003 Sven Neumann <sven@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_CELL_RENDERER_TOGGLE_H__
#define __GIMP_CELL_RENDERER_TOGGLE_H__
#include <gtk/gtkcellrenderertoggle.h>
#define GIMP_TYPE_CELL_RENDERER_TOGGLE (gimp_cell_renderer_toggle_get_type ())
#define GIMP_CELL_RENDERER_TOGGLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CELL_RENDERER_TOGGLE, GimpCellRendererToggle))
#define GIMP_CELL_RENDERER_TOGGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CELL_RENDERER_TOGGLE, GimpCellRendererToggleClass))
#define GIMP_IS_CELL_RENDERER_TOGGLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CELL_RENDERER_TOGGLE))
#define GIMP_IS_CELL_RENDERER_TOGGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CELL_RENDERER_TOGGLE))
#define GIMP_CELL_RENDERER_TOGGLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CELL_RENDERER_TOGGLE, GimpCellRendererToggleClass))
typedef struct _GimpCellRendererToggleClass GimpCellRendererToggleClass;
struct _GimpCellRendererToggle
{
GtkCellRendererToggle parent_instance;
gchar *stock_id;
GtkIconSize stock_size;
GdkPixbuf *pixbuf;
};
struct _GimpCellRendererToggleClass
{
GtkCellRendererToggleClass parent_class;
void (* clicked) (GimpCellRendererToggle *cell,
const gchar *path,
GdkModifierType state);
};
GType gimp_cell_renderer_toggle_get_type (void) G_GNUC_CONST;
GtkCellRenderer * gimp_cell_renderer_toggle_new (const gchar *stock_id);
void gimp_cell_renderer_toggle_clicked (GimpCellRendererToggle *cell,
const gchar *path,
GdkModifierType state);
#endif /* __GIMP_CELL_RENDERER_TOGGLE_H__ */
......@@ -30,7 +30,6 @@
#include "core/gimpchannel.h"
#include "core/gimpimage.h"
#include "gimpcellrenderertoggle.h"
#include "gimpcellrendererviewable.h"
#include "gimpcomponenteditor.h"
#include "gimpmenufactory.h"
......
......@@ -25,6 +25,8 @@
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "base/temp-buf.h"
......@@ -33,7 +35,6 @@
#include "core/gimpcontext.h"
#include "core/gimpviewable.h"
#include "gimpcellrenderertoggle.h"
#include "gimpcellrendererviewable.h"
#include "gimpcontainertreeview.h"
#include "gimpcontainertreeview-dnd.h"
......
......@@ -42,7 +42,6 @@
#include "vectors/gimpvectors.h"
#include "gimpchanneltreeview.h"
#include "gimpcellrenderertoggle.h"
#include "gimpcontainerview.h"
#include "gimpdnd.h"
#include "gimpdocked.h"
......
......@@ -45,7 +45,6 @@
#include "file/file-open.h"
#include "file/file-utils.h"
#include "gimpcellrenderertoggle.h"
#include "gimpcellrendererviewable.h"
#include "gimpcontainerview.h"
#include "gimpdnd.h"
......
......@@ -32,7 +32,6 @@
#include "core/gimpcontext.h"