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"
39 typedef std::map<Accelerator, Callback> AcceleratorMap;
41 void accelerator_map_insert(AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback& callback)
43 if(accelerator.key != 0)
45 ASSERT_MESSAGE(acceleratorMap.find(accelerator) == acceleratorMap.end(), "failed to add accelerator");
46 acceleratorMap.insert(AcceleratorMap::value_type(accelerator, callback));
50 void accelerator_map_erase(AcceleratorMap& acceleratorMap, Accelerator accelerator)
52 if(accelerator.key != 0)
54 ASSERT_MESSAGE(acceleratorMap.find(accelerator) != acceleratorMap.end(), "failed to remove accelerator");
55 acceleratorMap.erase(accelerator);
59 Accelerator accelerator_for_event_key(guint keyval, guint state)
61 keyval = gdk_keyval_to_upper(keyval);
62 if(keyval == GDK_ISO_Left_Tab)
64 return Accelerator(keyval, (GdkModifierType)(state & gtk_accelerator_get_default_mod_mask()));
67 bool AcceleratorMap_activate(const AcceleratorMap& acceleratorMap, const Accelerator& accelerator)
69 AcceleratorMap::const_iterator i = acceleratorMap.find(accelerator);
70 if(i != acceleratorMap.end())
79 static gboolean accelerator_key_event(GtkWindow* window, GdkEventKey* event, AcceleratorMap* acceleratorMap)
81 return AcceleratorMap_activate(*acceleratorMap, accelerator_for_event_key(event->keyval, event->state));
85 AcceleratorMap g_special_accelerators;
98 typedef unsigned int ButtonMask;
100 void print_buttons(ButtonMask mask)
102 globalOutputStream() << "button state: ";
103 if((mask & MouseButton::Left) != 0)
105 globalOutputStream() << "Left ";
107 if((mask & MouseButton::Right) != 0)
109 globalOutputStream() << "Right ";
111 if((mask & MouseButton::Middle) != 0)
113 globalOutputStream() << "Middle ";
115 globalOutputStream() << "\n";
118 ButtonMask ButtonMask_for_event_button(guint button)
123 return MouseButton::Left;
125 return MouseButton::Middle;
127 return MouseButton::Right;
132 bool window_has_accel(GtkWindow* toplevel)
134 return g_slist_length(gtk_accel_groups_from_object(G_OBJECT(toplevel))) != 0;
139 bool g_accel_enabled = true;
142 bool global_accel_enabled()
144 return g_accel_enabled;
148 AcceleratorMap g_queuedAccelerators;
150 GClosure* accel_group_add_accelerator(GtkAccelGroup* group, Accelerator accelerator, const Callback& callback);
152 void GlobalQueuedAccelerators_commit()
154 for(AcceleratorMap::const_iterator i = g_queuedAccelerators.begin(); i != g_queuedAccelerators.end(); ++i)
156 accel_group_add_accelerator(global_accel, (*i).first, (*i).second);
158 g_queuedAccelerators.clear();
161 void GlobalQueuedAccelerators_add(Accelerator accelerator, const Callback& callback)
163 g_queuedAccelerators.insert(AcceleratorMap::value_type(accelerator, callback));
166 void accel_group_test(GtkWindow* toplevel, GtkAccelGroup* accel)
169 gtk_accel_group_query(accel, '4', (GdkModifierType)0, &n_entries);
170 globalOutputStream() << "grid4: " << n_entries << "\n";
171 globalOutputStream() << "toplevel accelgroups: " << g_slist_length(gtk_accel_groups_from_object(G_OBJECT(toplevel))) << "\n";
174 typedef std::set<GtkWindow*> WindowSet;
175 WindowSet g_accel_windows;
177 bool Buttons_press(ButtonMask& buttons, guint button, guint state)
179 if(buttons == 0 && bitfield_enable(buttons, ButtonMask_for_event_button(button)) != 0)
181 ASSERT_MESSAGE(g_accel_enabled, "Buttons_press: accelerators not enabled");
182 g_accel_enabled = false;
183 for(WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i)
185 GtkWindow* toplevel = *i;
186 ASSERT_MESSAGE(window_has_accel(toplevel), "ERROR");
187 ASSERT_MESSAGE(GTK_WIDGET_TOPLEVEL(toplevel), "disabling accel for non-toplevel window");
188 gtk_window_remove_accel_group(toplevel, global_accel);
190 globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": disabled global accelerators\n";
193 accel_group_test(toplevel, global_accel);
197 buttons = bitfield_enable(buttons, ButtonMask_for_event_button(button));
199 globalOutputStream() << "Buttons_press: ";
200 print_buttons(buttons);
205 bool Buttons_release(ButtonMask& buttons, guint button, guint state)
207 if(buttons != 0 && bitfield_disable(buttons, ButtonMask_for_event_button(button)) == 0)
209 ASSERT_MESSAGE(!g_accel_enabled, "Buttons_release: accelerators are enabled");
210 g_accel_enabled = true;
211 for(WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i)
213 GtkWindow* toplevel = *i;
214 ASSERT_MESSAGE(!window_has_accel(toplevel), "ERROR");
215 ASSERT_MESSAGE(GTK_WIDGET_TOPLEVEL(toplevel), "enabling accel for non-toplevel window");
216 gtk_window_add_accel_group(toplevel, global_accel);
218 globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": enabled global accelerators\n";
221 accel_group_test(toplevel, global_accel);
224 GlobalQueuedAccelerators_commit();
226 buttons = bitfield_disable(buttons, ButtonMask_for_event_button(button));
228 globalOutputStream() << "Buttons_release: ";
229 print_buttons(buttons);
234 bool Buttons_releaseAll(ButtonMask& buttons)
236 Buttons_release(buttons, MouseButton::Left | MouseButton::Middle | MouseButton::Right, 0);
240 struct PressedButtons
244 PressedButtons() : buttons(0)
249 gboolean PressedButtons_button_press(GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed)
251 if(event->type == GDK_BUTTON_PRESS)
253 return Buttons_press(pressed->buttons, event->button, event->state);
258 gboolean PressedButtons_button_release(GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed)
260 if(event->type == GDK_BUTTON_RELEASE)
262 return Buttons_release(pressed->buttons, event->button, event->state);
267 gboolean PressedButtons_focus_out(GtkWidget* widget, GdkEventFocus* event, PressedButtons* pressed)
269 Buttons_releaseAll(pressed->buttons);
273 void PressedButtons_connect(PressedButtons& pressedButtons, GtkWidget* widget)
275 g_signal_connect(G_OBJECT(widget), "button_press_event", G_CALLBACK(PressedButtons_button_press), &pressedButtons);
276 g_signal_connect(G_OBJECT(widget), "button_release_event", G_CALLBACK(PressedButtons_button_release), &pressedButtons);
277 g_signal_connect(G_OBJECT(widget), "focus_out_event", G_CALLBACK(PressedButtons_focus_out), &pressedButtons);
280 PressedButtons g_pressedButtons;
287 typedef std::set<guint> Keys;
289 std::size_t refcount;
291 PressedKeys() : refcount(0)
296 AcceleratorMap g_keydown_accelerators;
297 AcceleratorMap g_keyup_accelerators;
299 bool Keys_press(PressedKeys::Keys& keys, guint keyval)
301 if(keys.insert(keyval).second)
303 return AcceleratorMap_activate(g_keydown_accelerators, accelerator_for_event_key(keyval, 0));
305 return g_keydown_accelerators.find(accelerator_for_event_key(keyval, 0)) != g_keydown_accelerators.end();
308 bool Keys_release(PressedKeys::Keys& keys, guint keyval)
310 if(keys.erase(keyval) != 0)
312 return AcceleratorMap_activate(g_keyup_accelerators, accelerator_for_event_key(keyval, 0));
314 return g_keyup_accelerators.find(accelerator_for_event_key(keyval, 0)) != g_keyup_accelerators.end();
317 void Keys_releaseAll(PressedKeys::Keys& keys, guint state)
319 for(PressedKeys::Keys::iterator i = keys.begin(); i != keys.end(); ++i)
321 AcceleratorMap_activate(g_keyup_accelerators, accelerator_for_event_key(*i, state));
326 gboolean PressedKeys_key_press(GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys)
328 //globalOutputStream() << "pressed: " << event->keyval << "\n";
329 return event->state == 0 && Keys_press(pressedKeys->keys, event->keyval);
332 gboolean PressedKeys_key_release(GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys)
334 //globalOutputStream() << "released: " << event->keyval << "\n";
335 return Keys_release(pressedKeys->keys, event->keyval);
338 gboolean PressedKeys_focus_in(GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys)
340 ++pressedKeys->refcount;
344 gboolean PressedKeys_focus_out(GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys)
346 if(--pressedKeys->refcount == 0)
348 Keys_releaseAll(pressedKeys->keys, 0);
353 PressedKeys g_pressedKeys;
355 void GlobalPressedKeys_releaseAll()
357 Keys_releaseAll(g_pressedKeys.keys, 0);
360 void GlobalPressedKeys_connect(GtkWindow* window)
362 unsigned int key_press_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(PressedKeys_key_press), &g_pressedKeys);
363 unsigned int key_release_handler = g_signal_connect(G_OBJECT(window), "key_release_event", G_CALLBACK(PressedKeys_key_release), &g_pressedKeys);
364 g_object_set_data(G_OBJECT(window), "key_press_handler", gint_to_pointer(key_press_handler));
365 g_object_set_data(G_OBJECT(window), "key_release_handler", gint_to_pointer(key_release_handler));
366 unsigned int focus_in_handler = g_signal_connect(G_OBJECT(window), "focus_in_event", G_CALLBACK(PressedKeys_focus_in), &g_pressedKeys);
367 unsigned int focus_out_handler = g_signal_connect(G_OBJECT(window), "focus_out_event", G_CALLBACK(PressedKeys_focus_out), &g_pressedKeys);
368 g_object_set_data(G_OBJECT(window), "focus_in_handler", gint_to_pointer(focus_in_handler));
369 g_object_set_data(G_OBJECT(window), "focus_out_handler", gint_to_pointer(focus_out_handler));
372 void GlobalPressedKeys_disconnect(GtkWindow* window)
374 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_press_handler")));
375 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_release_handler")));
376 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "focus_in_handler")));
377 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "focus_out_handler")));
382 void special_accelerators_add(Accelerator accelerator, const Callback& callback)
384 accelerator_map_insert(g_special_accelerators, accelerator, callback);
386 void special_accelerators_remove(Accelerator accelerator)
388 accelerator_map_erase(g_special_accelerators, accelerator);
391 void keydown_accelerators_add(Accelerator accelerator, const Callback& callback)
393 accelerator_map_insert(g_keydown_accelerators, accelerator, callback);
395 void keydown_accelerators_remove(Accelerator accelerator)
397 accelerator_map_erase(g_keydown_accelerators, accelerator);
400 void keyup_accelerators_add(Accelerator accelerator, const Callback& callback)
402 accelerator_map_insert(g_keyup_accelerators, accelerator, callback);
404 void keyup_accelerators_remove(Accelerator accelerator)
406 accelerator_map_erase(g_keyup_accelerators, accelerator);
410 gboolean accel_closure_callback(GtkAccelGroup* group, GtkWidget* widget, guint key, GdkModifierType modifiers, gpointer data)
412 (*reinterpret_cast<Callback*>(data))();
416 GClosure* accel_group_add_accelerator(GtkAccelGroup* group, Accelerator accelerator, const Callback& callback)
418 if(accelerator.key != 0 && gtk_accelerator_valid(accelerator.key, accelerator.modifiers))
420 //globalOutputStream() << "adding accelerator: " << accelerator.key << " " << accelerator.modifiers << "\n";
421 GClosure* closure = create_cclosure(G_CALLBACK(accel_closure_callback), callback);
422 gtk_accel_group_connect(group, accelerator.key, accelerator.modifiers, GTK_ACCEL_VISIBLE, closure);
427 special_accelerators_add(accelerator, callback);
432 void accel_group_remove_accelerator(GtkAccelGroup* group, Accelerator accelerator)
434 if(accelerator.key != 0 && gtk_accelerator_valid(accelerator.key, accelerator.modifiers))
436 gtk_accel_group_disconnect_key(group, accelerator.key, accelerator.modifiers);
440 special_accelerators_remove(accelerator);
444 GtkAccelGroup* global_accel = 0;
446 void global_accel_init()
448 global_accel = gtk_accel_group_new();
451 void global_accel_destroy()
453 g_object_unref(global_accel);
456 GClosure* global_accel_group_add_accelerator(Accelerator accelerator, const Callback& callback)
458 if(!global_accel_enabled())
460 // workaround: cannot add to GtkAccelGroup while it is disabled
461 GlobalQueuedAccelerators_add(accelerator, callback);
464 return accel_group_add_accelerator(global_accel, accelerator, callback);
466 void global_accel_group_remove_accelerator(Accelerator accelerator)
468 //ASSERT_MESSAGE(global_accel_enabled(), "removing accelerator while global accel is disabled");
469 accel_group_remove_accelerator(global_accel, accelerator);
472 /// \brief Propagates key events to the focus-widget, overriding global accelerators.
473 static gboolean override_global_accelerators(GtkWindow* window, GdkEventKey* event, gpointer data)
475 return gtk_window_propagate_key_event(window, event);
478 void global_accel_connect_window(GtkWindow* window)
481 unsigned int override_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(override_global_accelerators), 0);
482 g_object_set_data(G_OBJECT(window), "override_handler", gint_to_pointer(override_handler));
484 unsigned int special_key_press_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(accelerator_key_event), &g_special_accelerators);
485 g_object_set_data(G_OBJECT(window), "special_key_press_handler", gint_to_pointer(special_key_press_handler));
487 GlobalPressedKeys_connect(window);
489 unsigned int key_press_handler = g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(accelerator_key_event), &g_keydown_accelerators);
490 unsigned int key_release_handler = g_signal_connect(G_OBJECT(window), "key_release_event", G_CALLBACK(accelerator_key_event), &g_keyup_accelerators);
491 g_object_set_data(G_OBJECT(window), "key_press_handler", gint_to_pointer(key_press_handler));
492 g_object_set_data(G_OBJECT(window), "key_release_handler", gint_to_pointer(key_release_handler));
494 g_accel_windows.insert(window);
495 gtk_window_add_accel_group(window, global_accel);
497 void global_accel_disconnect_window(GtkWindow* window)
500 GlobalPressedKeys_disconnect(window);
502 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "override_handler")));
503 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "special_key_press_handler")));
505 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_press_handler")));
506 g_signal_handler_disconnect(G_OBJECT(window), gpointer_to_int(g_object_get_data(G_OBJECT(window), "key_release_handler")));
508 gtk_window_remove_accel_group(window, global_accel);
509 std::size_t count = g_accel_windows.erase(window);
510 ASSERT_MESSAGE(count == 1, "failed to remove accel group\n");
514 GClosure* global_accel_group_find(Accelerator accelerator)
516 guint numEntries = 0;
517 GtkAccelGroupEntry* entry = gtk_accel_group_query(global_accel, accelerator.key, accelerator.modifiers, &numEntries);
522 char* name = gtk_accelerator_name(accelerator.key, accelerator.modifiers);
523 globalErrorStream() << "accelerator already in-use: " << name << "\n";
526 return entry->closure;
531 void global_accel_group_connect(const Accelerator& accelerator, const Callback& callback)
533 if(accelerator.key != 0)
535 global_accel_group_add_accelerator(accelerator, callback);
539 void global_accel_group_disconnect(const Accelerator& accelerator, const Callback& callback)
541 if(accelerator.key != 0)
543 global_accel_group_remove_accelerator(accelerator);