void grab_keys(int mk, int uk, int dk,
int mm, int um, int dm,
int step) {
Display* disp = GDK_DISPLAY();
// ungrab any previous keys
XUngrabKey(disp, AnyKey, AnyModifier, GDK_ROOT_WINDOW());
volMuteKey = mk;
volUpKey = uk;
volDownKey = dk;
volMuteMods = mm;
volUpMods = um;
volDownMods = dm;
volStep = step;
if (mk < 0 &&
uk < 0 &&
dk < 0)
return;
xErr = 0;
errBuf = g_malloc(errBufSize*sizeof(gchar));
printBuf = errBuf + snprintf(errBuf,errBufSize,_("Could not bind the following hotkeys:\n"));
errBufSize -= (printBuf - errBuf);
if (muteSymStr) g_free(muteSymStr);
if (upSymStr) g_free(upSymStr);
if (downSymStr) g_free(downSymStr);
muteSymStr = gtk_accelerator_name(XkbKeycodeToKeysym(GDK_DISPLAY(), volMuteKey, 0, 0),volMuteMods);
upSymStr = gtk_accelerator_name(XkbKeycodeToKeysym(GDK_DISPLAY(),volUpKey,0, 0),volUpMods);
downSymStr = gtk_accelerator_name(XkbKeycodeToKeysym(GDK_DISPLAY(), volDownKey, 0, 0),volDownMods);
XErrorHandler old_hdlr = XSetErrorHandler(errhdl);
if (volMuteKey > 0) {
muteSerial = NextRequest(disp);
XGrabKey(disp,volMuteKey,volMuteMods,GDK_ROOT_WINDOW(),1,GrabModeAsync,GrabModeAsync);
}
if (volUpKey > 0) {
upSerial = NextRequest(disp);
XGrabKey(disp,volUpKey,volUpMods,GDK_ROOT_WINDOW(),1,GrabModeAsync,GrabModeAsync);
}
if (volDownKey > 0) {
downSerial = NextRequest(disp);
XGrabKey(disp,volDownKey,volDownMods,GDK_ROOT_WINDOW(),1,GrabModeAsync,GrabModeAsync);
}
XFlush(disp);
XSync(disp, False);
(void) XSetErrorHandler(old_hdlr);
if (xErr)
g_idle_add(idle_report_error, NULL);
else
g_free(errBuf);
}
static void
accel_map_print (gpointer data,
const gchar *accel_path,
guint accel_key,
GdkModifierType accel_mods,
gboolean changed)
{
GString *gstring = g_string_new (changed ? NULL : "; ");
gint fd = GPOINTER_TO_INT (data);
gchar *tmp, *name;
g_string_append (gstring, "(gtk_accel_path \"");
tmp = g_strescape (accel_path, NULL);
g_string_append (gstring, tmp);
g_free (tmp);
g_string_append (gstring, "\" \"");
name = gtk_accelerator_name (accel_key, accel_mods);
tmp = g_strescape (name, NULL);
g_free (name);
g_string_append (gstring, tmp);
g_free (tmp);
g_string_append (gstring, "\")\n");
write_all (fd, gstring->str, gstring->len);
g_string_free (gstring, TRUE);
}
static void
on_key_shortcut_edited (GsdWacomKeyShortcutButton *shortcut_button,
CcWacomButtonRow *row)
{
GsdWacomTabletButton *button;
char *custom_key;
guint keyval;
GdkModifierType mask;
button = row->priv->button;
if (button == NULL)
return;
change_button_action_type (row, GSD_WACOM_ACTION_TYPE_CUSTOM);
g_object_get (row->priv->key_shortcut_button,
"key-value", &keyval,
"key-mods", &mask,
NULL);
mask &= ~GDK_LOCK_MASK;
custom_key = gtk_accelerator_name (keyval, mask);
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING)
{
assign_custom_key_to_dir_button (row, custom_key);
}
else
g_settings_set_string (button->settings, CUSTOM_ACTION_KEY, custom_key);
g_free (custom_key);
}
static void
key_dialog_load (GtkListStore *store)
{
struct key_binding *kb = NULL;
char *label_text, *accel_text;
GtkTreeIter iter;
GSList *list = keybind_list;
while (list)
{
kb = (struct key_binding*)list->data;
label_text = gtk_accelerator_get_label (kb->keyval, kb->mod);
accel_text = gtk_accelerator_name (kb->keyval, kb->mod);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
KEY_COLUMN, label_text,
ACCEL_COLUMN, accel_text,
ACTION_COLUMN, key_actions[kb->action].name,
D1_COLUMN, kb->data1,
D2_COLUMN, kb->data2, -1);
g_free (accel_text);
g_free (label_text);
list = g_slist_next (list);
}
}
void visit( const char* name, Accelerator& accelerator ){
m_file << name << "=";
const char* key = gtk_accelerator_name( accelerator.key, accelerator.modifiers );
m_file << key;
m_file << "\n";
}
/* Caller responsible for freeing return string of meta_ui_accelerator_name! */
gchar*
meta_ui_accelerator_name (unsigned int keysym,
MetaVirtualModifier mask)
{
GdkModifierType mods = 0;
if (keysym == 0 && mask == 0)
{
return g_strdup ("disabled");
}
if (mask & META_VIRTUAL_SHIFT_MASK)
mods |= GDK_SHIFT_MASK;
if (mask & META_VIRTUAL_CONTROL_MASK)
mods |= GDK_CONTROL_MASK;
if (mask & META_VIRTUAL_ALT_MASK)
mods |= GDK_MOD1_MASK;
if (mask & META_VIRTUAL_MOD2_MASK)
mods |= GDK_MOD2_MASK;
if (mask & META_VIRTUAL_MOD3_MASK)
mods |= GDK_MOD3_MASK;
if (mask & META_VIRTUAL_MOD4_MASK)
mods |= GDK_MOD4_MASK;
if (mask & META_VIRTUAL_MOD5_MASK)
mods |= GDK_MOD5_MASK;
if (mask & META_VIRTUAL_SUPER_MASK)
mods |= GDK_SUPER_MASK;
if (mask & META_VIRTUAL_HYPER_MASK)
mods |= GDK_HYPER_MASK;
if (mask & META_VIRTUAL_META_MASK)
mods |= GDK_META_MASK;
return gtk_accelerator_name (keysym, mods);
}
/* --- loading and saving rc file --- */
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include "topconfig.h" /* BST_VERSION */
#include <sfi/sfistore.h> /* we rely on internal API here */
static void
accel_map_print (gpointer data,
const gchar *accel_path,
guint accel_key,
guint accel_mods,
gboolean changed)
{
GString *gstring = g_string_new (changed ? NULL : "; ");
SfiWStore *wstore = data;
gchar *tmp, *name;
g_string_append (gstring, "(gtk_accel_path \"");
tmp = g_strescape (accel_path, NULL);
g_string_append (gstring, tmp);
g_free (tmp);
g_string_append (gstring, "\" \"");
name = gtk_accelerator_name (accel_key, accel_mods);
tmp = g_strescape (name, NULL);
g_free (name);
g_string_append (gstring, tmp);
g_free (tmp);
g_string_append (gstring, "\")");
sfi_wstore_break (wstore);
sfi_wstore_puts (wstore, gstring->str);
g_string_free (gstring, TRUE);
}
static gchar *
convert_keysym_state_to_string (GtkCellRendererAccel *accel,
guint keysym,
GdkModifierType mask,
guint keycode)
{
if (keysym == 0 && keycode == 0)
/* This label is displayed in a treeview cell displaying
* a disabled accelerator key combination.
*/
return g_strdup (C_("Accelerator", "Disabled"));
else
{
if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
return gtk_accelerator_get_label (keysym, mask);
else
{
gchar *name;
name = gtk_accelerator_name (keysym, mask);
if (keysym == 0)
{
gchar *tmp;
tmp = name;
name = g_strdup_printf ("%s0x%02x", tmp, keycode);
g_free (tmp);
}
return name;
}
}
}
int main(int argc, char **argv) {
gtk_init(&argc, &argv);
printf("%s\n", gtk_accelerator_name(GDK_q, GDK_CONTROL_MASK));
printf("%s\n", gtk_accelerator_get_label(GDK_q, GDK_CONTROL_MASK));
return 0;
}
static char*
binding_name (guint keyval,
GdkModifierType mask)
{
if (keyval != 0)
return gtk_accelerator_name (keyval, mask);
return g_strdup ("disabled");
}
static void set_label_for_keycode(GtkWidget* label,gint code, GdkModifierType mods) {
int keysym;
gchar *key_text;
if (code < 0) return;
keysym = XkbKeycodeToKeysym(GDK_DISPLAY(), code, 0, 0);
key_text = gtk_accelerator_name (keysym, mods);
gtk_label_set_text(GTK_LABEL(label),key_text);
g_free(key_text);
}
static G_CONST_RETURN gchar*
gail_combo_box_get_keybinding (AtkAction *action,
gint i)
{
GailComboBox *combo_box;
gchar *return_value = NULL;
switch (i)
{
case 0:
{
GtkWidget *widget;
GtkWidget *label;
AtkRelationSet *set;
AtkRelation *relation;
GPtrArray *target;
gpointer target_object;
guint key_val;
combo_box = GAIL_COMBO_BOX (action);
widget = GTK_ACCESSIBLE (combo_box)->widget;
if (widget == NULL)
return NULL;
set = atk_object_ref_relation_set (ATK_OBJECT (action));
if (!set)
return NULL;
label = NULL;
relation = atk_relation_set_get_relation_by_type (set, ATK_RELATION_LABELLED_BY);
if (relation)
{
target = atk_relation_get_target (relation);
target_object = g_ptr_array_index (target, 0);
if (GTK_IS_ACCESSIBLE (target_object))
{
label = GTK_ACCESSIBLE (target_object)->widget;
}
}
g_object_unref (set);
if (GTK_IS_LABEL (label))
{
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
if (key_val != GDK_VoidSymbol)
return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
}
g_free (combo_box->press_keybinding);
combo_box->press_keybinding = return_value;
break;
}
default:
break;
}
return return_value;
}
GClosure* global_accel_group_find( Accelerator accelerator ){
guint numEntries = 0;
GtkAccelGroupEntry* entry = gtk_accel_group_query( global_accel, accelerator.key, accelerator.modifiers, &numEntries );
if ( numEntries != 0 ) {
if ( numEntries != 1 ) {
char* name = gtk_accelerator_name( accelerator.key, accelerator.modifiers );
globalErrorStream() << "accelerator already in-use: " << name << "\n";
g_free( name );
}
return entry->closure;
}
return 0;
}
int
clip_GTK_ACCELERATORNAME(ClipMachine * ClipMachineMemory)
{
guint keyval = _clip_parni(ClipMachineMemory, 1);
GdkModifierType modifiers = _clip_parni(ClipMachineMemory, 2);
CHECKARG(1, NUMERIC_type_of_ClipVarType);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
_clip_retc(ClipMachineMemory, gtk_accelerator_name(keyval, modifiers));
return 0;
err:
return 1;
}
static void
change_button_action_type (CcWacomButtonRow *row,
GsdWacomActionType type)
{
GsdWacomTabletButton *button;
GsdWacomActionType current_type;
button = row->priv->button;
if (button == NULL)
return;
current_type = g_settings_get_enum (button->settings, ACTION_TYPE_KEY);
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING)
{
if (type == GSD_WACOM_ACTION_TYPE_NONE)
assign_custom_key_to_dir_button (row, "");
else if (type == GSD_WACOM_ACTION_TYPE_CUSTOM)
{
guint keyval;
GdkModifierType mask;
char *custom_key;
g_object_get (row->priv->key_shortcut_button,
"key-value", &keyval,
"key-mods", &mask,
NULL);
mask &= ~GDK_LOCK_MASK;
custom_key = gtk_accelerator_name (keyval, mask);
assign_custom_key_to_dir_button (row, custom_key);
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, type);
g_free (custom_key);
}
}
else if (current_type != type)
{
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, type);
}
gtk_widget_set_sensitive (GTK_WIDGET (row->priv->key_shortcut_button),
type == GSD_WACOM_ACTION_TYPE_CUSTOM);
}
static void
mnemonic_hash_free_foreach (gpointer key,
gpointer value,
gpointer user)
{
guint keyval = GPOINTER_TO_UINT (key);
GSList *targets = value;
gchar *name = gtk_accelerator_name (keyval, 0);
g_warning ("mnemonic \"%s\" wasn't removed for widget (%p)",
name, targets->data);
g_free (name);
g_slist_free (targets);
}
static gboolean key_pressed(GtkWidget *window, GdkEventKey *key, gpointer pointer)
{
GtkTreeIter iter;
GtkTreeView *treeview = (GtkTreeView *)pointer;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
gchar *str = NULL;
switch(key->keyval)
{
case GDK_KEY_Shift_L:
case GDK_KEY_Shift_R:
case GDK_KEY_Control_L:
case GDK_KEY_Control_R:
case GDK_KEY_Caps_Lock:
case GDK_KEY_Shift_Lock:
case GDK_KEY_Meta_L:
case GDK_KEY_Meta_R:
case GDK_KEY_Alt_L:
case GDK_KEY_Alt_R:
case GDK_KEY_Super_L:
case GDK_KEY_Super_R:
case GDK_KEY_Hyper_L:
case GDK_KEY_Hyper_R:
case GDK_KEY_Mode_switch:
return FALSE;
default:
break;
}
if(gtk_tree_selection_get_selected(selection, NULL, &iter))
{
gint i;
GtkTreePath *path;
path = gtk_tree_model_get_path(model, &iter);
i = gtk_tree_path_get_indices(path)[0];
str = gtk_accelerator_name(key->keyval, key->state & ~GDK_MOD2_MASK);
gtk_list_store_set(GTK_LIST_STORE (model), &iter, COLUMN_SHORTCUT, str, -1);
gtk_tree_path_free(path);
g_free(str);
g_signal_handlers_disconnect_by_func(window, G_CALLBACK(key_pressed), pointer);
}
return FALSE;
}
static G_CONST_RETURN gchar*
gail_expander_get_keybinding (AtkAction *action,
gint i)
{
GailExpander *expander;
gchar *return_value = NULL;
switch (i)
{
case 0:
{
/*
* We look for a mnemonic on the label
*/
GtkWidget *widget;
GtkWidget *label;
expander = GAIL_EXPANDER (action);
widget = GTK_ACCESSIBLE (expander)->widget;
if (widget == NULL)
/*
* State is defunct
*/
return NULL;
g_return_val_if_fail (GTK_IS_EXPANDER (widget), NULL);
label = gtk_expander_get_label_widget (GTK_EXPANDER (widget));
if (GTK_IS_LABEL (label))
{
guint key_val;
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
if (key_val != GDK_VoidSymbol)
return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
g_free (expander->activate_keybinding);
expander->activate_keybinding = return_value;
}
break;
}
default:
break;
}
return return_value;
}
/**
* games_settings_set_keyval:
* @settings: a #GSettings
* @key: the key name
* @keyval: the value to store
* @modifiers: key modifiers with @keyval
*
* Associates @keyval with the key @key in group @group.
*
* It is a programmer error to pass a key that isn't valid for settings.
*
* Returns: TRUE if setting the key succeeded, FALSE if the key was not writable
*/
gboolean
games_settings_set_keyval (GSettings *settings,
const char *key,
guint keyval,
GdkModifierType modifiers)
{
char *value;
gboolean rv;
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
g_return_val_if_fail (key != NULL && key[0] != '\0', FALSE);
value = gtk_accelerator_name (keyval, modifiers);
rv = g_settings_set_string (settings, key, value);
g_free (value);
return rv;
}
static const gchar *
gtk_combo_box_accessible_get_keybinding (AtkAction *action,
gint i)
{
GtkComboBoxAccessible *combo_box;
GtkWidget *widget;
GtkWidget *label;
AtkRelationSet *set;
AtkRelation *relation;
GPtrArray *target;
gpointer target_object;
guint key_val;
gchar *return_value = NULL;
if (i != 0)
return NULL;
combo_box = GTK_COMBO_BOX_ACCESSIBLE (action);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (combo_box));
if (widget == NULL)
return NULL;
set = atk_object_ref_relation_set (ATK_OBJECT (action));
if (set == NULL)
return NULL;
label = NULL;
relation = atk_relation_set_get_relation_by_type (set, ATK_RELATION_LABELLED_BY);
if (relation)
{
target = atk_relation_get_target (relation);
target_object = g_ptr_array_index (target, 0);
label = gtk_accessible_get_widget (GTK_ACCESSIBLE (target_object));
}
g_object_unref (set);
if (GTK_IS_LABEL (label))
{
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (label));
if (key_val != GDK_KEY_VoidSymbol)
return_value = gtk_accelerator_name (key_val, GDK_MOD1_MASK);
}
return return_value;
}
static int
key_save_kbs (void)
{
int fd;
char buf[512];
char *accel_text;
GSList *list = keybind_list;
struct key_binding *kb;
fd = hexchat_open_file ("keybindings.conf", O_CREAT | O_TRUNC | O_WRONLY,
0x180, XOF_DOMODE);
if (fd < 0)
return 1;
write (fd, buf, g_snprintf (buf, 510, "# HexChat key bindings config file\n\n"));
while (list)
{
kb = list->data;
accel_text = gtk_accelerator_name (kb->keyval, kb->mod);
g_snprintf (buf, 510, "ACCEL=%s\n%s\n", accel_text, key_actions[kb->action].name);
write (fd, buf, strlen (buf));
g_free (accel_text);
if (kb->data1 && kb->data1[0])
write (fd, buf, g_snprintf (buf, 510, "D1:%s\n", kb->data1));
else
write (fd, "D1!\n", 4);
if (kb->data2 && kb->data2[0])
write (fd, buf, g_snprintf (buf, 510, "D2:%s\n", kb->data2));
else
write (fd, "D2!\n", 4);
write (fd, "\n", 1);
list = g_slist_next (list);
}
close (fd);
return 0;
}
gboolean hotkey_pressed(GtkWidget *dialog,
GdkEventKey *ev,
PrefsData *data) {
gchar *key_text;
guint keyval;
GdkModifierType state,consumed;
state = ev->state;
gdk_keymap_translate_keyboard_state(gdk_keymap_get_default(),
ev->hardware_keycode,
state,
ev->group,
&keyval,
NULL,NULL,&consumed);
state &= ~consumed;
state &= gtk_accelerator_get_default_mod_mask();
key_text = gtk_accelerator_name (keyval, state);
gtk_label_set_text(GTK_LABEL(data->hotkey_key_label),key_text);
g_free(key_text);
return FALSE;
}
/* This is not used to save in the glade file... and its a one-way conversion.
* its only usefull to show the values in the UI.
*/
gchar *
glade_accels_make_string (GList * accels)
{
GladeAccelInfo *info;
GString *string;
GList *list;
gchar *accel_text;
string = g_string_new ("");
for (list = accels; list; list = list->next)
{
info = list->data;
accel_text = gtk_accelerator_name (info->key, info->modifiers);
g_string_append (string, accel_text);
g_free (accel_text);
if (list->next)
g_string_append (string, ", ");
}
return g_string_free (string, FALSE);
}
static gboolean accel_button_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer userdata)
{
char *accelerator;
if(!accel_button_is_recording(GTK_BUTTON(widget))) {
return FALSE;
}
if(event->type==GDK_KEY_RELEASE) {
if(event->keyval==GDK_BackSpace || event->keyval==GDK_Escape || event->keyval==GDK_Delete) {
accel_button_set_label(GTK_BUTTON(widget));
} else {
if(!IsModifierKey(event->keyval)) {
accelerator= gtk_accelerator_name(event->keyval, event->state);
gconf_client_set_string(ocha_gconf_get_client(),
OCHA_GCONF_ACCELERATOR_KEY,
accelerator,
NULL/*err*/);
g_free(accelerator);
}
}
}
return TRUE;
}
static void
key_dialog_set_key (GtkCellRendererAccel *accel, gchar *pathstr, guint accel_key,
GdkModifierType accel_mods, guint hardware_keycode, gpointer userdata)
{
GtkTreeModel *model = get_store ();
GtkTreePath *path = gtk_tree_path_new_from_string (pathstr);
GtkTreeIter iter;
gchar *label_name, *accel_name;
/* Shift tab requires an exception, hopefully that list ends here.. */
if (accel_key == GDK_KEY_Tab && accel_mods & GDK_SHIFT_MASK)
accel_key = GDK_KEY_ISO_Left_Tab;
label_name = gtk_accelerator_get_label (accel_key, key_modifier_get_valid (accel_mods));
accel_name = gtk_accelerator_name (accel_key, key_modifier_get_valid (accel_mods));
gtk_tree_model_get_iter (model, &iter, path);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, KEY_COLUMN, label_name,
ACCEL_COLUMN, accel_name, -1);
gtk_tree_path_free (path);
g_free (label_name);
g_free (accel_name);
}
static void
accel_edited_callback (GtkCellRendererText *cell,
const char *path_string,
guint keyval,
GdkModifierType mask,
guint keycode,
CcWacomPage *page)
{
GtkTreeModel *model;
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
GtkTreeView *view;
GtkTreeIter iter;
CcWacomPagePrivate *priv;
CsdWacomTabletButton *button;
GtkDirectionType dir;
char *str;
priv = page->priv;
view = GTK_TREE_VIEW (MWID("shortcut_treeview"));
model = gtk_tree_view_get_model (view);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
MAPPING_BUTTON_COLUMN, &button,
MAPPING_BUTTON_DIRECTION, &dir,
-1);
/* sanity check */
if (button == NULL)
return;
/* CapsLock isn't supported as a keybinding modifier, so keep it from confusing us */
mask &= ~GDK_LOCK_MASK;
str = gtk_accelerator_name (keyval, mask);
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING) {
char *strs[3];
char **strv;
strs[2] = NULL;
strs[0] = strs[1] = "";
strv = g_settings_get_strv (button->settings, KEY_CUSTOM_ELEVATOR_ACTION);
if (strv != NULL) {
if (g_strv_length (strv) >= 1)
strs[0] = strv[0];
if (g_strv_length (strv) >= 2)
strs[1] = strv[1];
}
if (dir == GTK_DIR_UP)
strs[0] = str;
else
strs[1] = str;
g_settings_set_strv (button->settings, KEY_CUSTOM_ELEVATOR_ACTION, (const gchar * const*) strs);
if (strv != NULL)
g_strfreev (strv);
} else {
g_settings_set_string (button->settings, CUSTOM_ACTION_KEY, str);
}
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, CSD_WACOM_ACTION_TYPE_CUSTOM);
g_free (str);
}
void
accel_edited (GtkCellRendererAccel * accel,
gchar * path_string,
guint accel_key,
GdkModifierType accel_mods,
guint hardware_keycode, GladeEPropAccel * eprop_accel)
{
gboolean key_was_set;
GtkTreeIter iter, parent_iter, new_iter;
gchar *accel_text;
GladePropertyClass *pclass;
GladeWidgetAdaptor *adaptor;
gboolean is_action;
pclass = glade_editor_property_get_pclass (GLADE_EDITOR_PROPERTY (eprop_accel));
adaptor = glade_property_class_get_adaptor (pclass);
if (!gtk_tree_model_get_iter_from_string (eprop_accel->model,
&iter, path_string))
return;
is_action = (glade_widget_adaptor_get_object_type (adaptor) == GTK_TYPE_ACTION ||
g_type_is_a (glade_widget_adaptor_get_object_type (adaptor), GTK_TYPE_ACTION));
gtk_tree_model_get (eprop_accel->model, &iter,
ACCEL_COLUMN_KEY_ENTERED, &key_was_set, -1);
accel_text = gtk_accelerator_name (accel_key, accel_mods);
gtk_tree_store_set
(GTK_TREE_STORE (eprop_accel->model), &iter,
ACCEL_COLUMN_KEY_ENTERED, TRUE,
ACCEL_COLUMN_STYLE, PANGO_STYLE_NORMAL,
ACCEL_COLUMN_FOREGROUND, "Black",
ACCEL_COLUMN_TEXT, accel_text,
ACCEL_COLUMN_KEYCODE, accel_key, ACCEL_COLUMN_MODIFIERS, accel_mods, -1);
g_free (accel_text);
/* Append a new one if needed
*/
if (is_action == FALSE && key_was_set == FALSE &&
gtk_tree_model_iter_parent (eprop_accel->model, &parent_iter, &iter))
{
gchar *signal, *real_signal;
gtk_tree_model_get (eprop_accel->model, &iter,
ACCEL_COLUMN_SIGNAL, &signal,
ACCEL_COLUMN_REAL_SIGNAL, &real_signal, -1);
/* Append a new empty slot at the end */
gtk_tree_store_insert_after (GTK_TREE_STORE (eprop_accel->model),
&new_iter, &parent_iter, &iter);
gtk_tree_store_set (GTK_TREE_STORE (eprop_accel->model), &new_iter,
ACCEL_COLUMN_SIGNAL, signal,
ACCEL_COLUMN_REAL_SIGNAL, real_signal,
ACCEL_COLUMN_TEXT, _("<choose a key>"),
ACCEL_COLUMN_WEIGHT, PANGO_WEIGHT_NORMAL,
ACCEL_COLUMN_STYLE, PANGO_STYLE_ITALIC,
ACCEL_COLUMN_FOREGROUND, "Grey",
ACCEL_COLUMN_VISIBLE, TRUE,
ACCEL_COLUMN_KEYCODE, 0,
ACCEL_COLUMN_MODIFIERS, 0,
ACCEL_COLUMN_KEY_ENTERED, FALSE, -1);
g_free (signal);
g_free (real_signal);
}
}
static G_CONST_RETURN gchar*
gail_menu_item_get_keybinding (AtkAction *action,
gint i)
{
/*
* This function returns a string of the form A;B;C where
* A is the keybinding for the widget; B is the keybinding to traverse
* from the menubar and C is the accelerator.
* The items in the keybinding to traverse from the menubar are separated
* by ":".
*/
GailMenuItem *gail_menu_item;
gchar *keybinding = NULL;
gchar *item_keybinding = NULL;
gchar *full_keybinding = NULL;
gchar *accelerator = NULL;
gail_menu_item = GAIL_MENU_ITEM (action);
if (i == 0)
{
GtkWidget *item;
GtkWidget *temp_item;
GtkWidget *child;
GtkWidget *parent;
item = GTK_ACCESSIBLE (action)->widget;
if (item == NULL)
/* State is defunct */
return NULL;
temp_item = item;
while (TRUE)
{
GdkModifierType mnemonic_modifier = 0;
guint key_val;
gchar *key, *temp_keybinding;
child = gtk_bin_get_child (GTK_BIN (temp_item));
if (child == NULL)
{
/* Possibly a tear off menu item; it could also be a menu
* separator generated by gtk_item_factory_create_items()
*/
return NULL;
}
parent = gtk_widget_get_parent (temp_item);
if (!parent)
{
/*
* parent can be NULL when activating a window from the panel
*/
return NULL;
}
g_return_val_if_fail (GTK_IS_MENU_SHELL (parent), NULL);
if (GTK_IS_MENU_BAR (parent))
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (parent);
if (toplevel && GTK_IS_WINDOW (toplevel))
mnemonic_modifier = gtk_window_get_mnemonic_modifier (
GTK_WINDOW (toplevel));
}
if (GTK_IS_LABEL (child))
{
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (child));
if (key_val != GDK_VoidSymbol)
{
key = gtk_accelerator_name (key_val, mnemonic_modifier);
if (full_keybinding)
temp_keybinding = g_strconcat (key, ":", full_keybinding, NULL);
else
temp_keybinding = g_strconcat (key, NULL);
if (temp_item == item)
{
item_keybinding = g_strdup (key);
}
g_free (key);
g_free (full_keybinding);
full_keybinding = temp_keybinding;
}
else
{
/* No keybinding */
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
if (GTK_IS_MENU_BAR (parent))
/* We have reached the menu bar so we are finished */
break;
g_return_val_if_fail (GTK_IS_MENU (parent), NULL);
temp_item = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (temp_item))
{
/*
* Menu is attached to something other than a menu item;
* probably an option menu
*/
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
parent = gtk_widget_get_parent (item);
if (GTK_IS_MENU (parent))
{
GtkAccelGroup *group;
GtkAccelKey *key;
group = gtk_menu_get_accel_group (GTK_MENU (parent));
if (group)
{
key = gtk_accel_group_find (group, find_accel, item);
}
else
{
/*
* If the menu item is created using GtkAction and GtkUIManager
* we get here.
*/
key = NULL;
child = GTK_BIN (item)->child;
if (GTK_IS_ACCEL_LABEL (child))
{
GtkAccelLabel *accel_label;
accel_label = GTK_ACCEL_LABEL (child);
if (accel_label->accel_closure)
{
key = gtk_accel_group_find (accel_label->accel_group,
find_accel_new,
accel_label->accel_closure);
}
}
}
if (key)
{
accelerator = gtk_accelerator_name (key->accel_key,
key->accel_mods);
}
}
}
/*
* Concatenate the bindings
*/
if (item_keybinding || full_keybinding || accelerator)
{
gchar *temp;
if (item_keybinding)
{
keybinding = g_strconcat (item_keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (item_keybinding);
}
else
keybinding = g_strconcat (KEYBINDING_SEPARATOR, NULL);
if (full_keybinding)
{
temp = g_strconcat (keybinding, full_keybinding,
KEYBINDING_SEPARATOR, NULL);
g_free (full_keybinding);
}
else
temp = g_strconcat (keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (keybinding);
keybinding = temp;
if (accelerator)
{
temp = g_strconcat (keybinding, accelerator, NULL);
g_free (accelerator);
g_free (keybinding);
keybinding = temp;
}
}
g_free (gail_menu_item->click_keybinding);
gail_menu_item->click_keybinding = keybinding;
return keybinding;
}
static void
gimp_device_info_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpDeviceInfo *info = GIMP_DEVICE_INFO (object);
switch (property_id)
{
case PROP_DEVICE:
g_value_set_object (value, info->device);
break;
case PROP_DISPLAY:
g_value_set_object (value, info->display);
break;
case PROP_MODE:
g_value_set_enum (value, gimp_device_info_get_mode (info));
break;
case PROP_AXES:
{
GimpValueArray *array;
GValue enum_value = { 0, };
gint n_axes;
gint i;
array = gimp_value_array_new (6);
g_value_init (&enum_value, GDK_TYPE_AXIS_USE);
n_axes = gimp_device_info_get_n_axes (info);
for (i = 0; i < n_axes; i++)
{
g_value_set_enum (&enum_value,
gimp_device_info_get_axis_use (info, i));
gimp_value_array_append (array, &enum_value);
}
g_value_unset (&enum_value);
g_value_take_boxed (value, array);
}
break;
case PROP_KEYS:
{
GimpValueArray *array;
GValue string_value = { 0, };
gint n_keys;
gint i;
array = gimp_value_array_new (32);
g_value_init (&string_value, G_TYPE_STRING);
n_keys = gimp_device_info_get_n_keys (info);
for (i = 0; i < n_keys; i++)
{
guint keyval;
GdkModifierType modifiers;
gimp_device_info_get_key (info, i, &keyval, &modifiers);
if (keyval)
{
gchar *accel;
gchar *escaped;
accel = gtk_accelerator_name (keyval, modifiers);
escaped = g_strescape (accel, NULL);
g_free (accel);
g_value_set_string (&string_value, escaped);
g_free (escaped);
}
else
{
g_value_set_string (&string_value, "");
}
gimp_value_array_append (array, &string_value);
}
g_value_unset (&string_value);
g_value_take_boxed (value, array);
}
break;
case PROP_PRESSURE_CURVE:
g_value_set_object (value, info->pressure_curve);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/* This function returns a string of the form A;B;C where A is
* the keybinding for the widget; B is the keybinding to traverse
* from the menubar and C is the accelerator. The items in the
* keybinding to traverse from the menubar are separated by ":".
*/
static const gchar *
gtk_menu_item_accessible_get_keybinding (AtkAction *action,
gint i)
{
gchar *keybinding = NULL;
gchar *item_keybinding = NULL;
gchar *full_keybinding = NULL;
gchar *accelerator = NULL;
GtkWidget *item;
GtkWidget *temp_item;
GtkWidget *child;
GtkWidget *parent;
item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
if (item == NULL)
return NULL;
if (i != 0)
return NULL;
temp_item = item;
while (TRUE)
{
GdkModifierType mnemonic_modifier = 0;
guint key_val;
gchar *key, *temp_keybinding;
child = gtk_bin_get_child (GTK_BIN (temp_item));
if (child == NULL)
return NULL;
parent = gtk_widget_get_parent (temp_item);
if (!parent)
/* parent can be NULL when activating a window from the panel */
return NULL;
if (GTK_IS_MENU_BAR (parent))
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (parent);
if (toplevel && GTK_IS_WINDOW (toplevel))
mnemonic_modifier =
gtk_window_get_mnemonic_modifier (GTK_WINDOW (toplevel));
}
if (GTK_IS_LABEL (child))
{
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (child));
if (key_val != GDK_KEY_VoidSymbol)
{
key = gtk_accelerator_name (key_val, mnemonic_modifier);
if (full_keybinding)
temp_keybinding = g_strconcat (key, ":", full_keybinding, NULL);
else
temp_keybinding = g_strdup (key);
if (temp_item == item)
item_keybinding = g_strdup (key);
g_free (key);
g_free (full_keybinding);
full_keybinding = temp_keybinding;
}
else
{
/* No keybinding */
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
/* We have reached the menu bar so we are finished */
if (GTK_IS_MENU_BAR (parent))
break;
g_return_val_if_fail (GTK_IS_MENU (parent), NULL);
temp_item = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (temp_item))
{
/* Menu is attached to something other than a menu item;
* probably an option menu
*/
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
parent = gtk_widget_get_parent (item);
if (GTK_IS_MENU (parent))
{
GtkAccelGroup *group;
GtkAccelKey *key;
group = gtk_menu_get_accel_group (GTK_MENU (parent));
if (group)
key = gtk_accel_group_find (group, find_accel_by_widget, item);
else
{
key = NULL;
child = gtk_bin_get_child (GTK_BIN (item));
if (GTK_IS_ACCEL_LABEL (child))
{
GtkAccelLabel *accel_label;
GClosure *accel_closure;
accel_label = GTK_ACCEL_LABEL (child);
g_object_get (accel_label, "accel-closure", &accel_closure, NULL);
if (accel_closure)
{
key = gtk_accel_group_find (gtk_accel_group_from_accel_closure (accel_closure),
find_accel_by_closure,
accel_closure);
g_closure_unref (accel_closure);
}
}
}
if (key)
accelerator = gtk_accelerator_name (key->accel_key, key->accel_mods);
}
/* Concatenate the bindings */
if (item_keybinding || full_keybinding || accelerator)
{
gchar *temp;
if (item_keybinding)
{
keybinding = g_strconcat (item_keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (item_keybinding);
}
else
keybinding = g_strdup (KEYBINDING_SEPARATOR);
if (full_keybinding)
{
temp = g_strconcat (keybinding, full_keybinding,
KEYBINDING_SEPARATOR, NULL);
g_free (full_keybinding);
}
else
temp = g_strconcat (keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (keybinding);
keybinding = temp;
if (accelerator)
{
temp = g_strconcat (keybinding, accelerator, NULL);
g_free (accelerator);
g_free (keybinding);
keybinding = temp;
}
}
return keybinding;
}