2 Copyright (C) 2001-2006, William Joseph.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "accelerator.h"
24 #include "debugging/debugging.h"
28 #include <gtk/gtkwindow.h>
29 #include <gtk/gtkaccelgroup.h>
31 #include "generic/callback.h"
32 #include "generic/bitfield.h"
33 #include "string/string.h"
38 #include <gdk/gdkkeysyms.h>
42 const char* global_keys_find(unsigned int key)
47 s = gdk_keyval_name(key);
53 unsigned int global_keys_find(const char* name)
58 k = gdk_keyval_from_name(name);
59 if(k == GDK_VoidSymbol)
64 void accelerator_write(const Accelerator& accelerator, TextOutputStream& ostream)
67 if(accelerator.modifiers & GDK_SHIFT_MASK)
69 ostream << "Shift + ";
71 if(accelerator.modifiers & GDK_MOD1_MASK)
75 if(accelerator.modifiers & GDK_CONTROL_MASK)
77 ostream << "Control + ";
80 const char* keyName = global_keys_find(accelerator.key);
81 if(!string_empty(keyName))
87 ostream << static_cast<char>(accelerator.key);
90 ostream << gtk_accelerator_get_label(accelerator.key, accelerator.modifiers);
93 typedef std::map<Accelerator, Callback> AcceleratorMap;
94 typedef std::set<Accelerator> AcceleratorSet;
96 bool accelerator_map_insert(AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback& callback)
98 if(accelerator.key != 0)
100 return acceleratorMap.insert(AcceleratorMap::value_type(accelerator, callback)).second;
105 bool accelerator_map_erase(AcceleratorMap& acceleratorMap, Accelerator accelerator)
107 if(accelerator.key != 0)
109 AcceleratorMap::iterator i = acceleratorMap.find(accelerator);
110 if(i == acceleratorMap.end())
114 acceleratorMap.erase(i);
119 Accelerator accelerator_for_event_key(guint keyval, guint state)
121 keyval = gdk_keyval_to_upper(keyval);
122 if(keyval == GDK_ISO_Left_Tab)
124 return Accelerator(keyval, (GdkModifierType)(state & gtk_accelerator_get_default_mod_mask()));
127 bool AcceleratorMap_activate(const AcceleratorMap& acceleratorMap, const Accelerator& accelerator)
129 AcceleratorMap::const_iterator i = acceleratorMap.find(accelerator);
130 if(i != acceleratorMap.end())
139 static gboolean accelerator_key_event(GtkWindow* window, GdkEventKey* event, AcceleratorMap* acceleratorMap)
141 return AcceleratorMap_activate(*acceleratorMap, accelerator_for_event_key(event->keyval, event->state));
145 AcceleratorMap g_special_accelerators;
148 namespace MouseButton
158 typedef unsigned int ButtonMask;
160 void print_buttons(ButtonMask mask)
162 globalOutputStream() << "button state: ";
163 if((mask & MouseButton::Left) != 0)
165 globalOutputStream() << "Left ";
167 if((mask & MouseButton::Right) != 0)
169 globalOutputStream() << "Right ";
171 if((mask & MouseButton::Middle) != 0)
173 globalOutputStream() << "Middle ";
175 globalOutputStream() << "\n";
178 ButtonMask ButtonMask_for_event_button(guint button)
183 return MouseButton::Left;
185 return MouseButton::Middle;
187 return MouseButton::Right;
192 bool window_has_accel(GtkWindow* toplevel)
194 return g_slist_length(gtk_accel_groups_from_object(G_OBJECT(toplevel))) != 0;
199 bool g_accel_enabled = true;
202 bool global_accel_enabled()
204 return g_accel_enabled;
208 GClosure* accel_group_add_accelerator(GtkAccelGroup* group, Accelerator accelerator, const Callback& callback);
209 void accel_group_remove_accelerator(GtkAccelGroup* group, Accelerator accelerator);
211 AcceleratorMap g_queuedAcceleratorsAdd;
212 AcceleratorSet g_queuedAcceleratorsRemove;
214 void globalQueuedAccelerators_add(Accelerator accelerator, const Callback& callback)
216 if(!g_queuedAcceleratorsAdd.insert(AcceleratorMap::value_type(accelerator, callback)).second)
218 globalErrorStream() << "globalQueuedAccelerators_add: accelerator already queued: " << accelerator << "\n";
222 void globalQueuedAccelerators_remove(Accelerator accelerator)
224 if(g_queuedAcceleratorsAdd.erase(accelerator) == 0)
226 if(!g_queuedAcceleratorsRemove.insert(accelerator).second)
228 globalErrorStream() << "globalQueuedAccelerators_remove: accelerator already queued: " << accelerator << "\n";
233 void globalQueuedAccelerators_commit()
235 for(AcceleratorSet::const_iterator i = g_queuedAcceleratorsRemove.begin(); i != g_queuedAcceleratorsRemove.end(); ++i)
237 //globalOutputStream() << "removing: " << (*i).first << "\n";
238 accel_group_remove_accelerator(global_accel, *i);
240 g_queuedAcceleratorsRemove.clear();
241 for(AcceleratorMap::const_iterator i = g_queuedAcceleratorsAdd.begin(); i != g_queuedAcceleratorsAdd.end(); ++i)
243 //globalOutputStream() << "adding: " << (*i).first << "\n";
244 accel_group_add_accelerator(global_accel, (*i).first, (*i).second);
246 g_queuedAcceleratorsAdd.clear();
249 void accel_group_test(GtkWindow* toplevel, GtkAccelGroup* accel)
252 gtk_accel_group_query(accel, '4', (GdkModifierType)0, &n_entries);
253 globalOutputStream() << "grid4: " << n_entries << "\n";
254 globalOutputStream() << "toplevel accelgroups: " << g_slist_length(gtk_accel_groups_from_object(G_OBJECT(toplevel))) << "\n";
257 typedef std::set<GtkWindow*> WindowSet;
258 WindowSet g_accel_windows;
260 bool Buttons_press(ButtonMask& buttons, guint button, guint state)
262 if(buttons == 0 && bitfield_enable(buttons, ButtonMask_for_event_button(button)) != 0)
264 ASSERT_MESSAGE(g_accel_enabled, "Buttons_press: accelerators not enabled");
265 g_accel_enabled = false;
266 for(WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i)
268 GtkWindow* toplevel = *i;
269 ASSERT_MESSAGE(window_has_accel(toplevel), "ERROR");
270 ASSERT_MESSAGE(GTK_WIDGET_TOPLEVEL(toplevel), "disabling accel for non-toplevel window");
271 gtk_window_remove_accel_group(toplevel, global_accel);
273 globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": disabled global accelerators\n";
276 accel_group_test(toplevel, global_accel);
280 buttons = bitfield_enable(buttons, ButtonMask_for_event_button(button));
282 globalOutputStream() << "Buttons_press: ";
283 print_buttons(buttons);
288 bool Buttons_release(ButtonMask& buttons, guint button, guint state)
290 if(buttons != 0 && bitfield_disable(buttons, ButtonMask_for_event_button(button)) == 0)
292 ASSERT_MESSAGE(!g_accel_enabled, "Buttons_release: accelerators are enabled");
293 g_accel_enabled = true;
294 for(WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i)
296 GtkWindow* toplevel = *i;
297 ASSERT_MESSAGE(!window_has_accel(toplevel), "ERROR");
298 ASSERT_MESSAGE(GTK_WIDGET_TOPLEVEL(toplevel), "enabling accel for non-toplevel window");
299 gtk_window_add_accel_group(toplevel, global_accel);
301 globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": enabled global accelerators\n";
304 accel_group_test(toplevel, global_accel);
307 globalQueuedAccelerators_commit();
309 buttons = bitfield_disable(buttons, ButtonMask_for_event_button(button));
311 globalOutputStream() << "Buttons_release: ";
312 print_buttons(buttons);
317 bool Buttons_releaseAll(ButtonMask& buttons)
319 Buttons_release(buttons, MouseButton::Left | MouseButton::Middle | MouseButton::Right, 0);
323 struct PressedButtons
327 PressedButtons() : buttons(0)
332 gboolean PressedButtons_button_press(GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed)
334 if(event->type == GDK_BUTTON_PRESS)
336 return Buttons_press(pressed->buttons, event->button, event->state);
341 gboolean PressedButtons_button_release(GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed)
343 if(event->type == GDK_BUTTON_RELEASE)
345 return Buttons_release(pressed->buttons, event->button, event->state);
350 gboolean PressedButtons_focus_out(GtkWidget* widget, GdkEventFocus* event, PressedButtons* pressed)
352 Buttons_releaseAll(pressed->buttons);
356 void PressedButtons_connect(PressedButtons& pressedButtons, GtkWidget* widget)
358 g_signal_connect(G_OBJECT(widget), "button_press_event", G_CALLBACK(PressedButtons_button_press), &pressedButtons);
359 g_signal_connect(G_OBJECT(widget), "button_release_event", G_CALLBACK(PressedButtons_button_release), &pressedButtons);
360 g_signal_connect(G_OBJECT(widget), "focus_out_event", G_CALLBACK(PressedButtons_focus_out), &pressedButtons);
363 PressedButtons g_pressedButtons;
370 typedef std::set<guint> Keys;
372 std::size_t refcount;
374 PressedKeys() : refcount(0)
379 AcceleratorMap g_keydown_accelerators;
380 AcceleratorMap g_keyup_accelerators;
382 bool Keys_press(PressedKeys::Keys& keys, guint keyval)
384 if(keys.insert(keyval).second)
386 return AcceleratorMap_activate(g_keydown_accelerators, accelerator_for_event_key(keyval, 0));
388 return g_keydown_accelerators.find(accelerator_for_event_key(keyval, 0)) != g_keydown_accelerators.end();
391 bool Keys_release(PressedKeys::Keys& keys, guint keyval)
393 if(keys.erase(keyval) != 0)
395 return AcceleratorMap_activate(g_keyup_accelerators, accelerator_for_event_key(keyval, 0));
397 return g_keyup_accelerators.find(accelerator_for_event_key(keyval, 0)) != g_keyup_accelerators.end();
400 void Keys_releaseAll(PressedKeys::Keys& keys, guint state)
402 for(PressedKeys::Keys::iterator i = keys.begin(); i != keys.end(); ++i)
404 AcceleratorMap_activate(g_keyup_accelerators, accelerator_for_event_key(*i, state));
409 gboolean PressedKeys_key_press(GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys)
411 //globalOutputStream() << "pressed: " << event->keyval << "\n";
412 return event->state == 0 && Keys_press(pressedKeys->keys, event->keyval);
415 gboolean PressedKeys_key_release(GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys)
417 //globalOutputStream() << "released: " << event->keyval << "\n";
418 return Keys_release(pressedKeys->keys, event->keyval);
421 gboolean PressedKeys_focus_in(GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys)
423 ++pressedKeys->refcount;
427 gboolean PressedKeys_focus_out(GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys)
429 if(--pressedKeys->refcount == 0)
431 Keys_releaseAll(pressedKeys->keys, 0);
436 PressedKeys g_pressedKeys;
438 void GlobalPressedKeys_releaseAll()
440 Keys_releaseAll(g_pressedKeys.keys, 0);
443 void GlobalPressedKeys_connect(GtkWindow* window)
445 unsigned int key_press_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(PressedKeys_key_press), &g_pressedKeys);
446 unsigned int key_release_handler = g_signal_connect(G_OBJECT(window), "key_release_event", G_CALLBACK(PressedKeys_key_release), &g_pressedKeys);
447 g_object_set_data(G_OBJECT(window), "key_press_handler", gint_to_pointer(key_press_handler));
448 g_object_set_data(G_OBJECT(window), "key_release_handler", gint_to_pointer(key_release_handler));
449 unsigned int focus_in_handler = g_signal_connect(G_OBJECT(window), "focus_in_event", G_CALLBACK(PressedKeys_focus_in), &g_pressedKeys);
450 unsigned int focus_out_handler = g_signal_connect(G_OBJECT(window), "focus_out_event", G_CALLBACK(PressedKeys_focus_out), &g_pressedKeys);
451 g_object_set_data(G_OBJECT(window), "focus_in_handler", gint_to_pointer(focus_in_handler));
452 g_object_set_data(G_OBJECT(window), "focus_out_handler", gint_to_pointer(focus_out_handler));
455 void GlobalPressedKeys_disconnect(GtkWindow* window)
457 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_press_handler")));
458 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_release_handler")));
459 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "focus_in_handler")));
460 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "focus_out_handler")));
465 void special_accelerators_add(Accelerator accelerator, const Callback& callback)
467 //globalOutputStream() << "special_accelerators_add: " << makeQuoted(accelerator) << "\n";
468 if(!accelerator_map_insert(g_special_accelerators, accelerator, callback))
470 globalErrorStream() << "special_accelerators_add: already exists: " << makeQuoted(accelerator) << "\n";
473 void special_accelerators_remove(Accelerator accelerator)
475 //globalOutputStream() << "special_accelerators_remove: " << makeQuoted(accelerator) << "\n";
476 if(!accelerator_map_erase(g_special_accelerators, accelerator))
478 globalErrorStream() << "special_accelerators_remove: not found: " << makeQuoted(accelerator) << "\n";
482 void keydown_accelerators_add(Accelerator accelerator, const Callback& callback)
484 //globalOutputStream() << "keydown_accelerators_add: " << makeQuoted(accelerator) << "\n";
485 if(!accelerator_map_insert(g_keydown_accelerators, accelerator, callback))
487 globalErrorStream() << "keydown_accelerators_add: already exists: " << makeQuoted(accelerator) << "\n";
490 void keydown_accelerators_remove(Accelerator accelerator)
492 //globalOutputStream() << "keydown_accelerators_remove: " << makeQuoted(accelerator) << "\n";
493 if(!accelerator_map_erase(g_keydown_accelerators, accelerator))
495 globalErrorStream() << "keydown_accelerators_remove: not found: " << makeQuoted(accelerator) << "\n";
499 void keyup_accelerators_add(Accelerator accelerator, const Callback& callback)
501 //globalOutputStream() << "keyup_accelerators_add: " << makeQuoted(accelerator) << "\n";
502 if(!accelerator_map_insert(g_keyup_accelerators, accelerator, callback))
504 globalErrorStream() << "keyup_accelerators_add: already exists: " << makeQuoted(accelerator) << "\n";
507 void keyup_accelerators_remove(Accelerator accelerator)
509 //globalOutputStream() << "keyup_accelerators_remove: " << makeQuoted(accelerator) << "\n";
510 if(!accelerator_map_erase(g_keyup_accelerators, accelerator))
512 globalErrorStream() << "keyup_accelerators_remove: not found: " << makeQuoted(accelerator) << "\n";
517 gboolean accel_closure_callback(GtkAccelGroup* group, GtkWidget* widget, guint key, GdkModifierType modifiers, gpointer data)
519 (*reinterpret_cast<Callback*>(data))();
523 GClosure* accel_group_add_accelerator(GtkAccelGroup* group, Accelerator accelerator, const Callback& callback)
525 if(accelerator.key != 0 && gtk_accelerator_valid(accelerator.key, accelerator.modifiers))
527 //globalOutputStream() << "global_accel_connect: " << makeQuoted(accelerator) << "\n";
528 GClosure* closure = create_cclosure(G_CALLBACK(accel_closure_callback), callback);
529 gtk_accel_group_connect(group, accelerator.key, accelerator.modifiers, GTK_ACCEL_VISIBLE, closure);
534 special_accelerators_add(accelerator, callback);
539 void accel_group_remove_accelerator(GtkAccelGroup* group, Accelerator accelerator)
541 if(accelerator.key != 0 && gtk_accelerator_valid(accelerator.key, accelerator.modifiers))
543 //globalOutputStream() << "global_accel_disconnect: " << makeQuoted(accelerator) << "\n";
544 gtk_accel_group_disconnect_key(group, accelerator.key, accelerator.modifiers);
548 special_accelerators_remove(accelerator);
552 GtkAccelGroup* global_accel = 0;
554 void global_accel_init()
556 global_accel = gtk_accel_group_new();
559 void global_accel_destroy()
561 g_object_unref(global_accel);
564 GClosure* global_accel_group_add_accelerator(Accelerator accelerator, const Callback& callback)
566 if(!global_accel_enabled())
568 // workaround: cannot add to GtkAccelGroup while it is disabled
569 //globalOutputStream() << "queued for add: " << accelerator << "\n";
570 globalQueuedAccelerators_add(accelerator, callback);
573 return accel_group_add_accelerator(global_accel, accelerator, callback);
575 void global_accel_group_remove_accelerator(Accelerator accelerator)
577 if(!global_accel_enabled())
579 //globalOutputStream() << "queued for remove: " << accelerator << "\n";
580 globalQueuedAccelerators_remove(accelerator);
583 accel_group_remove_accelerator(global_accel, accelerator);
586 /// \brief Propagates key events to the focus-widget, overriding global accelerators.
587 static gboolean override_global_accelerators(GtkWindow* window, GdkEventKey* event, gpointer data)
589 gboolean b = gtk_window_propagate_key_event(window, event);
593 void global_accel_connect_window(GtkWindow* window)
596 unsigned int override_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(override_global_accelerators), 0);
597 g_object_set_data(G_OBJECT(window), "override_handler", gint_to_pointer(override_handler));
599 unsigned int special_key_press_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(accelerator_key_event), &g_special_accelerators);
600 g_object_set_data(G_OBJECT(window), "special_key_press_handler", gint_to_pointer(special_key_press_handler));
602 GlobalPressedKeys_connect(window);
604 unsigned int key_press_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(accelerator_key_event), &g_keydown_accelerators);
605 unsigned int key_release_handler = g_signal_connect(G_OBJECT(window), "key_release_event", G_CALLBACK(accelerator_key_event), &g_keyup_accelerators);
606 g_object_set_data(G_OBJECT(window), "key_press_handler", gint_to_pointer(key_press_handler));
607 g_object_set_data(G_OBJECT(window), "key_release_handler", gint_to_pointer(key_release_handler));
609 g_accel_windows.insert(window);
610 gtk_window_add_accel_group(window, global_accel);
612 void global_accel_disconnect_window(GtkWindow* window)
615 GlobalPressedKeys_disconnect(window);
617 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "override_handler")));
618 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "special_key_press_handler")));
620 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_press_handler")));
621 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_release_handler")));
623 gtk_window_remove_accel_group(window, global_accel);
624 std::size_t count = g_accel_windows.erase(window);
625 ASSERT_MESSAGE(count == 1, "failed to remove accel group\n");
629 GClosure* global_accel_group_find(Accelerator accelerator)
631 guint numEntries = 0;
632 GtkAccelGroupEntry* entry = gtk_accel_group_query(global_accel, accelerator.key, accelerator.modifiers, &numEntries);
637 char* name = gtk_accelerator_name(accelerator.key, accelerator.modifiers);
638 globalErrorStream() << "accelerator already in-use: " << name << "\n";
641 return entry->closure;
646 void global_accel_group_connect(const Accelerator& accelerator, const Callback& callback)
648 if(accelerator.key != 0)
650 global_accel_group_add_accelerator(accelerator, callback);
654 void global_accel_group_disconnect(const Accelerator& accelerator, const Callback& callback)
656 if(accelerator.key != 0)
658 global_accel_group_remove_accelerator(accelerator);