callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

app/widgets/Makefile.am app/widgets/widgets-types.h remove

Browse Source 
2007-04-16  Michael Natterer  <mitch@gimp.org>

	* app/widgets/Makefile.am
	* app/widgets/widgets-types.h
	* app/widgets/gimpcellrendereraccel.[ch]: remove GimpCellRenererAccel.

	* app/widgets/gimpactionview.c: use GtkCellRendererAccel instead.
	If an action has no label, use its name as label. Always show the
	"Name" column because there are too many actions with confusingly
	similar names.


svn path=/trunk/; revision=22256
This commit is contained in:
Michael Natterer
2007-04-16 13:43:31 +00:00
committed by Michael Natterer
parent 467581b790
commit dfd1309b19
6 changed files with 163 additions and 704 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
ChangeLog
View File

@ -1,3 +1,14 @@
2007-04-16 Michael Natterer <mitch@gimp.org>
* app/widgets/Makefile.am
* app/widgets/widgets-types.h
* app/widgets/gimpcellrendereraccel.[ch]: remove GimpCellRenererAccel.
* app/widgets/gimpactionview.c: use GtkCellRendererAccel instead.
If an action has no label, use its name as label. Always show the
"Name" column because there are too many actions with confusingly
similar names.
2007-04-16 Sven Neumann <sven@gimp.org>
* INSTALL

2
app/widgets/Makefile.am
View File

@ -37,8 +37,6 @@ libappwidgets_a_sources = \
gimpbrushselect.h \
gimpbufferview.c \
gimpbufferview.h \
gimpcellrendereraccel.c \
gimpcellrendereraccel.h \
gimpcellrendererdashes.c \
gimpcellrendererdashes.h \
gimpcellrendererviewable.c \

271
app/widgets/gimpactionview.c
View File

@ -35,7 +35,6 @@
#include "gimpaction.h"
#include "gimpactiongroup.h"
#include "gimpactionview.h"
#include "gimpcellrendereraccel.h"
#include "gimpmessagebox.h"
#include "gimpmessagedialog.h"
#include "gimpuimanager.h"
@ -56,11 +55,14 @@ static void gimp_action_view_accel_changed (GtkAccelGroup *accel_group,
GdkModifierType unused2,
GClosure *accel_closure,
GimpActionView *view);
static void gimp_action_view_accel_edited (GimpCellRendererAccel *accel,
static void gimp_action_view_accel_edited (GtkCellRendererAccel *accel,
const char *path_string,
gboolean delete,
guint accel_key,
GdkModifierType accel_mask,
guint hardware_keycode,
GimpActionView *view);
static void gimp_action_view_accel_cleared (GtkCellRendererAccel *accel,
const char *path_string,
GimpActionView *view);
@ -241,6 +243,12 @@ gimp_action_view_new (GimpUIManager *manager,
label = gimp_strip_uline (tmp);
g_free (tmp);
if (! (label && strlen (label)))
{
g_free (label);
label = g_strdup (name);
}
if (show_shortcuts)
{
accel_closure = gtk_action_get_accel_closure (action);
@ -333,37 +341,38 @@ gimp_action_view_new (GimpUIManager *manager,
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut"));
cell = gimp_cell_renderer_accel_new ();
cell = gtk_cell_renderer_accel_new ();
cell->mode = GTK_CELL_RENDERER_MODE_EDITABLE;
GTK_CELL_RENDERER_TEXT (cell)->editable = TRUE;
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"accel-key",
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
"accel-mask",
"accel-mods",
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
NULL);
g_signal_connect (cell, "accel-edited",
G_CALLBACK (gimp_action_view_accel_edited),
view);
g_signal_connect (cell, "accel-cleared",
G_CALLBACK (gimp_action_view_accel_cleared),
view);
gtk_tree_view_append_column (view, column);
}
else
{
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_NAME,
NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
gtk_tree_view_append_column (view, column);
}
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_NAME,
NULL);
gtk_tree_view_append_column (view, column);
if (select_path)
{
@ -560,13 +569,10 @@ gimp_action_view_conflict_confirm (GimpActionView *view,
gtk_widget_show (dialog);
}
static void
gimp_action_view_accel_edited (GimpCellRendererAccel *accel,
const char *path_string,
gboolean delete,
guint accel_key,
GdkModifierType accel_mask,
GimpActionView *view)
static const gchar *
gimp_action_view_get_accel_action (GimpActionView *view,
const gchar *path_string,
GtkAction **action_return)
{
GtkTreeModel *model;
GtkTreePath *path;
@ -574,15 +580,13 @@ gimp_action_view_accel_edited (GimpCellRendererAccel *accel,
model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
if (! model)
return;
return NULL;
path = gtk_tree_path_new_from_string (path_string);
if (gtk_tree_model_get_iter (model, &iter, path))
{
GtkAction *action;
GtkActionGroup *group;
const gchar *accel_path;
GtkAction *action;
gtk_tree_model_get (model, &iter,
GIMP_ACTION_VIEW_COLUMN_ACTION, &action,
@ -591,100 +595,129 @@ gimp_action_view_accel_edited (GimpCellRendererAccel *accel,
if (! action)
goto done;
g_object_get (action, "action-group", &group, NULL);
if (! group)
{
g_object_unref (action);
goto done;
}
accel_path = gtk_action_get_accel_path (action);
if (delete)
{
if (! gtk_accel_map_change_entry (accel_path, 0, 0, FALSE))
{
gimp_message (view->manager->gimp, G_OBJECT (view),
GIMP_MESSAGE_ERROR,
_("Removing shortcut failed."));
}
}
else if (! accel_key)
{
gimp_message (view->manager->gimp, G_OBJECT (view),
GIMP_MESSAGE_ERROR,
_("Invalid shortcut."));
}
else if (! gtk_accel_map_change_entry (accel_path,
accel_key, accel_mask, FALSE))
{
GtkAction *conflict_action = NULL;
GtkTreeIter iter;
gboolean iter_valid;
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
GtkTreeIter child_iter;
gboolean child_valid;
for (child_valid = gtk_tree_model_iter_children (model,
&child_iter,
&iter);
child_valid;
child_valid = gtk_tree_model_iter_next (model, &child_iter))
{
guint child_accel_key;
GdkModifierType child_accel_mask;
gtk_tree_model_get (model, &child_iter,
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
&child_accel_key,
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
&child_accel_mask,
-1);
if (accel_key == child_accel_key &&
accel_mask == child_accel_mask)
{
gtk_tree_model_get (model, &child_iter,
GIMP_ACTION_VIEW_COLUMN_ACTION,
&conflict_action,
-1);
break;
}
}
if (conflict_action)
break;
}
if (conflict_action != action)
{
if (conflict_action)
{
gimp_action_view_conflict_confirm (view, conflict_action,
accel_key,
accel_mask,
accel_path);
g_object_unref (conflict_action);
}
else
{
gimp_message (view->manager->gimp, G_OBJECT (view),
GIMP_MESSAGE_ERROR,
_("Changing shortcut failed."));
}
}
}
g_object_unref (group);
gtk_tree_path_free (path);
g_object_unref (action);
*action_return = action;
return gtk_action_get_accel_path (action);
}
done:
gtk_tree_path_free (path);
return NULL;
}
static void
gimp_action_view_accel_edited (GtkCellRendererAccel *accel,
const char *path_string,
guint accel_key,
GdkModifierType accel_mask,
guint hardware_keycode,
GimpActionView *view)
{
GtkAction *action;
const gchar *accel_path;
accel_path = gimp_action_view_get_accel_action (view, path_string,
&action);
if (! accel_path)
return;
if (! accel_key)
{
gimp_message (view->manager->gimp, G_OBJECT (view),
GIMP_MESSAGE_ERROR,
_("Invalid shortcut."));
}
else if (! gtk_accel_map_change_entry (accel_path,
accel_key, accel_mask, FALSE))
{
GtkTreeModel *model;
GtkAction *conflict_action = NULL;
GtkTreeIter iter;
gboolean iter_valid;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
GtkTreeIter child_iter;
gboolean child_valid;
for (child_valid = gtk_tree_model_iter_children (model,
&child_iter,
&iter);
child_valid;
child_valid = gtk_tree_model_iter_next (model, &child_iter))
{
guint child_accel_key;
GdkModifierType child_accel_mask;
gtk_tree_model_get (model, &child_iter,
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
&child_accel_key,
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
&child_accel_mask,
-1);
if (accel_key == child_accel_key &&
accel_mask == child_accel_mask)
{
gtk_tree_model_get (model, &child_iter,
GIMP_ACTION_VIEW_COLUMN_ACTION,
&conflict_action,
-1);
break;
}
}
if (conflict_action)
break;
}
if (conflict_action != action)
{
if (conflict_action)
{
gimp_action_view_conflict_confirm (view, conflict_action,
accel_key,
accel_mask,
accel_path);
g_object_unref (conflict_action);
}
else
{
gimp_message (view->manager->gimp, G_OBJECT (view),
GIMP_MESSAGE_ERROR,
_("Changing shortcut failed."));
}
}
}
}
static void
gimp_action_view_accel_cleared (GtkCellRendererAccel *accel,
const char *path_string,
GimpActionView *view)
{
GtkAction *action;
const gchar *accel_path;
accel_path = gimp_action_view_get_accel_action (view, path_string,
&action);
if (! accel_path)
return;
if (! gtk_accel_map_change_entry (accel_path, 0, 0, FALSE))
{
gimp_message (view->manager->gimp, G_OBJECT (view),
GIMP_MESSAGE_ERROR,
_("Removing shortcut failed."));
}
}

502
app/widgets/gimpcellrendereraccel.c
View File

@ -1,502 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcellrendereraccel.c
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
*
* Derived from: libegg/libegg/treeviewutils/eggcellrendererkeys.c
* Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
*
* 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 <gdk/gdkkeysyms.h>
#include <gdk/gdkkeysyms.h>
#include "widgets-types.h"
#include "core/gimpmarshal.h"
#include "gimpcellrendereraccel.h"
#include "gimpwidgets-utils.h"
#include "gimp-intl.h"
enum
{
ACCEL_EDITED,
LAST_SIGNAL
};
enum
{
PROP_0,
PROP_ACCEL_KEY,
PROP_ACCEL_MASK
};
#define GIMP_CELL_RENDERER_ACCEL_PATH "gimp-cell-renderer-accel-path"
static void gimp_cell_renderer_accel_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_cell_renderer_accel_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec);
static void gimp_cell_renderer_accel_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height);
static GtkCellEditable *
gimp_cell_renderer_accel_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags);
G_DEFINE_TYPE (GimpCellRendererAccel, gimp_cell_renderer_accel,
GTK_TYPE_CELL_RENDERER_TEXT)
#define parent_class gimp_cell_renderer_accel_parent_class
static guint accel_cell_signals[LAST_SIGNAL] = { 0 };
static void
gimp_cell_renderer_accel_class_init (GimpCellRendererAccelClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
accel_cell_signals[ACCEL_EDITED] =
g_signal_new ("accel-edited",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpCellRendererAccelClass, accel_edited),
NULL, NULL,
gimp_marshal_VOID__STRING_BOOLEAN_UINT_FLAGS,
G_TYPE_NONE, 4,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_UINT,
GDK_TYPE_MODIFIER_TYPE);
object_class->set_property = gimp_cell_renderer_accel_set_property;
object_class->get_property = gimp_cell_renderer_accel_get_property;
cell_class->get_size = gimp_cell_renderer_accel_get_size;
cell_class->start_editing = gimp_cell_renderer_accel_start_editing;
g_object_class_install_property (object_class, PROP_ACCEL_KEY,
g_param_spec_uint ("accel-key", NULL, NULL,
0, G_MAXINT, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, PROP_ACCEL_MASK,
g_param_spec_flags ("accel-mask", NULL, NULL,
GDK_TYPE_MODIFIER_TYPE,
0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
}
static void
gimp_cell_renderer_accel_init (GimpCellRendererAccel *cell)
{
}
static void
gimp_cell_renderer_accel_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GimpCellRendererAccel *accel = GIMP_CELL_RENDERER_ACCEL (object);
switch (param_id)
{
case PROP_ACCEL_KEY:
gimp_cell_renderer_accel_set_accelerator (accel,
g_value_get_uint (value),
accel->accel_mask);
break;
case PROP_ACCEL_MASK:
gimp_cell_renderer_accel_set_accelerator (accel,
accel->accel_key,
g_value_get_flags (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
}
}
static void
gimp_cell_renderer_accel_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GimpCellRendererAccel *accel = GIMP_CELL_RENDERER_ACCEL (object);
switch (param_id)
{
case PROP_ACCEL_KEY:
g_value_set_uint (value, accel->accel_key);
break;
case PROP_ACCEL_MASK:
g_value_set_flags (value, accel->accel_mask);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
}
}
static void
gimp_cell_renderer_accel_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height)
{
GimpCellRendererAccel *accel = GIMP_CELL_RENDERER_ACCEL (cell);
GtkRequisition requisition;
if (! accel->sizing_label)
accel->sizing_label = gtk_label_new (_("Type a new accelerator, "
"or press Backspace to clear"));
gtk_widget_size_request (accel->sizing_label, &requisition);
GTK_CELL_RENDERER_CLASS (parent_class)->get_size (cell, widget, cell_area,
x_offset, y_offset,
width, height);
/* FIXME: need to take the cell_area et al. into account */
if (width)
*width = MAX (*width, requisition.width);
if (height)
*height = MAX (*height, requisition.height);
}
/* FIXME: Currently we don't differentiate between a 'bogus' key (like tab in
* GTK mode) and a removed key.
*/
static gboolean
grab_key_callback (GtkWidget *widget,
GdkEventKey *event,
GimpCellRendererAccel *accel)
{
GdkDisplay *display;
guint accel_key;
GdkModifierType accel_mods;
gchar *path;
gboolean delete = FALSE;
gboolean edited = FALSE;
GdkModifierType consumed_modifiers;
switch (event->keyval)
{
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Control_L:
case GDK_Control_R:
case GDK_Alt_L:
case GDK_Alt_R:
return TRUE;
case GDK_Delete:
case GDK_KP_Delete:
case GDK_BackSpace:
delete = TRUE;
break;
default:
break;
}
display = gtk_widget_get_display (widget);
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
event->hardware_keycode,
event->state,
event->group,
NULL, NULL, NULL, &consumed_modifiers);
accel_key = gdk_keyval_to_lower (event->keyval);
accel_mods = (event->state &
gtk_accelerator_get_default_mod_mask () &
~consumed_modifiers);
if (accel_key == GDK_ISO_Left_Tab)
accel_key = GDK_Tab;
/* If lowercasing affects the keysym, then we need to include SHIFT
* in the modifiers, We re-upper case when we match against the
* keyval, but display and save in caseless form.
*/
if (accel_key != event->keyval)
accel_mods |= GDK_SHIFT_MASK;
if (accel_key != GDK_Escape)
{
if (delete || ! gtk_accelerator_valid (accel_key, accel_mods))
{
accel_key = 0;
accel_mods = 0;
}
edited = TRUE;
}
path = g_strdup (g_object_get_data (G_OBJECT (accel->edit_widget),
GIMP_CELL_RENDERER_ACCEL_PATH));
gdk_display_keyboard_ungrab (display, event->time);
gdk_display_pointer_ungrab (display, event->time);
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (accel->edit_widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (accel->edit_widget));
accel->edit_widget = NULL;
accel->grab_widget = NULL;
if (edited)
g_signal_emit (accel, accel_cell_signals[ACCEL_EDITED], 0,
path, delete, accel_key, accel_mods);
g_free (path);
return TRUE;
}
static void
ungrab_stuff (GtkWidget *widget,
GimpCellRendererAccel *accel)
{
GdkDisplay *display = gtk_widget_get_display (widget);
gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
g_signal_handlers_disconnect_by_func (accel->grab_widget,
G_CALLBACK (grab_key_callback),
accel);
}
static void
pointless_eventbox_start_editing (GtkCellEditable *cell_editable,
GdkEvent *event)
{
/* do nothing, because we are pointless */
}
static void
pointless_eventbox_cell_editable_init (GtkCellEditableIface *iface)
{
iface->start_editing = pointless_eventbox_start_editing;
}
static GType
pointless_eventbox_subclass_get_type (void)
{
static GType type = 0;
if (! type)
{
const GTypeInfo info =
{
sizeof (GtkEventBoxClass),
NULL, /* base_init */
NULL, /* base_finalize */
NULL, /* class_init */
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GtkEventBox),
0, /* n_preallocs */
NULL /* instance init */
};
const GInterfaceInfo editable_info =
{
(GInterfaceInitFunc) pointless_eventbox_cell_editable_init,
NULL, NULL
};
type = g_type_register_static (GTK_TYPE_EVENT_BOX,
"GimpCellEditableEventBox",
&info, 0);
g_type_add_interface_static (type, GTK_TYPE_CELL_EDITABLE,
&editable_info);
}
return type;
}
static GtkCellEditable *
gimp_cell_renderer_accel_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
GimpCellRendererAccel *accel = GIMP_CELL_RENDERER_ACCEL (cell);
GtkWidget *label;
GtkWidget *eventbox;
if (! celltext->editable)
return NULL;
g_return_val_if_fail (widget->window != NULL, NULL);
if (gdk_keyboard_grab (widget->window, FALSE,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
return NULL;
if (gdk_pointer_grab (widget->window, FALSE,
GDK_BUTTON_PRESS_MASK,
NULL, NULL,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
{
gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
gdk_event_get_time (event));
return NULL;
}
accel->grab_widget = widget;
g_signal_connect (widget, "key-press-event",
G_CALLBACK (grab_key_callback),
accel);
eventbox = g_object_new (pointless_eventbox_subclass_get_type (), NULL);
accel->edit_widget = eventbox;
g_object_add_weak_pointer (G_OBJECT (accel->edit_widget),
(gpointer) &accel->edit_widget);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL,
&widget->style->bg[GTK_STATE_SELECTED]);
gtk_widget_modify_fg (label, GTK_STATE_NORMAL,
&widget->style->fg[GTK_STATE_SELECTED]);
if (accel->accel_key != 0)
gtk_label_set_text (GTK_LABEL (label),
_("Type a new accelerator, or press Backspace to clear"));
else
gtk_label_set_text (GTK_LABEL (label),
_("Type a new accelerator"));
gtk_container_add (GTK_CONTAINER (eventbox), label);
g_object_set_data_full (G_OBJECT (accel->edit_widget),
GIMP_CELL_RENDERER_ACCEL_PATH,
g_strdup (path), g_free);
gtk_widget_show_all (accel->edit_widget);
g_signal_connect (accel->edit_widget, "unrealize",
G_CALLBACK (ungrab_stuff),
accel);
accel->edit_key = accel->accel_key;
return GTK_CELL_EDITABLE (accel->edit_widget);
}
/* public functions */
GtkCellRenderer *
gimp_cell_renderer_accel_new (void)
{
return g_object_new (GIMP_TYPE_CELL_RENDERER_ACCEL, NULL);
}
void
gimp_cell_renderer_accel_set_accelerator (GimpCellRendererAccel *accel,
guint accel_key,
GdkModifierType accel_mask)
{
gboolean changed = FALSE;
g_return_if_fail (GIMP_IS_CELL_RENDERER_ACCEL (accel));
g_object_freeze_notify (G_OBJECT (accel));
if (accel_key != accel->accel_key)
{
accel->accel_key = accel_key;
g_object_notify (G_OBJECT (accel), "accel-key");
changed = TRUE;
}
if (accel_mask != accel->accel_mask)
{
accel->accel_mask = accel_mask;
g_object_notify (G_OBJECT (accel), "accel-mask");
changed = TRUE;
}
g_object_thaw_notify (G_OBJECT (accel));
if (changed)
{
gchar *text = gimp_get_accel_string (accel->accel_key,
accel->accel_mask);
g_object_set (accel, "text", text, NULL);
g_free (text);
}
}
void
gimp_cell_renderer_accel_get_accelerator (GimpCellRendererAccel *accel,
guint *accel_key,
GdkModifierType *accel_mask)
{
g_return_if_fail (GIMP_IS_CELL_RENDERER_ACCEL (accel));
if (accel_key)
*accel_key = accel->accel_key;
if (accel_mask)
*accel_mask = accel->accel_mask;
}

80
app/widgets/gimpcellrendereraccel.h
View File

@ -1,80 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcellrendereraccel.h
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
*
* Derived from: libegg/libegg/treeviewutils/eggcellrendererkeys.h
* Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
*
* 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_ACCEL_H__
#define __GIMP_CELL_RENDERER_ACCEL_H__
#include <gtk/gtkcellrenderertext.h>
#define GIMP_TYPE_CELL_RENDERER_ACCEL (gimp_cell_renderer_accel_get_type ())
#define GIMP_CELL_RENDERER_ACCEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CELL_RENDERER_ACCEL, GimpCellRendererAccel))
#define GIMP_CELL_RENDERER_ACCEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CELL_RENDERER_ACCEL, GimpCellRendererAccelClass))
#define GIMP_IS_CELL_RENDERER_ACCEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CELL_RENDERER_ACCEL))
#define GIMP_IS_CELL_RENDERER_ACCEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CELL_RENDERER_ACCEL))
#define GIMP_CELL_RENDERER_ACCEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_CELL_RENDERER_ACCEL, GimpCellRendererAccelClass))
typedef struct _GimpCellRendererAccelClass GimpCellRendererAccelClass;
struct _GimpCellRendererAccel
{
GtkCellRendererText parent_instance;
guint accel_key;
GdkModifierType accel_mask;
GtkWidget *edit_widget;
GtkWidget *grab_widget;
guint edit_key;
GtkWidget *sizing_label;
};
struct _GimpCellRendererAccelClass
{
GtkCellRendererTextClass parent_class;
void (* accel_edited) (GimpCellRendererAccel *accel,
const char *path_string,
gboolean delete,
guint accel_key,
GdkModifierType accel_mask);
};
GType gimp_cell_renderer_accel_get_type (void) G_GNUC_CONST;
GtkCellRenderer * gimp_cell_renderer_accel_new (void);
void gimp_cell_renderer_accel_set_accelerator (GimpCellRendererAccel *accel,
guint accel_kaey,
GdkModifierType accel_mask);
void gimp_cell_renderer_accel_get_accelerator (GimpCellRendererAccel *accel,
guint *accel_key,
GdkModifierType *accel_mask);
#endif /* __GIMP_CELL_RENDERER_ACCEL_H__ */

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

@ -198,7 +198,6 @@ typedef struct _GimpViewRendererVectors GimpViewRendererVectors;
/* cell renderers */
typedef struct _GimpCellRendererAccel GimpCellRendererAccel;
typedef struct _GimpCellRendererDashes GimpCellRendererDashes;
typedef struct _GimpCellRendererViewable GimpCellRendererViewable;