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"
30 #include "generic/callback.h"
31 #include "generic/bitfield.h"
32 #include "string/string.h"
37 #include <gdk/gdkkeysyms.h>
41 const char* global_keys_find( unsigned int key ){
46 s = gdk_keyval_name( key );
53 unsigned int global_keys_find( const char* name ){
55 if ( !name || !*name ) {
58 k = gdk_keyval_from_name( name );
59 if ( k == GDK_KEY_VoidSymbol ) {
65 void accelerator_write( const Accelerator& accelerator, TextOutputStream& ostream ){
67 if ( accelerator.modifiers & GDK_SHIFT_MASK ) {
68 ostream << "Shift + ";
70 if ( accelerator.modifiers & GDK_MOD1_MASK ) {
73 if ( accelerator.modifiers & GDK_CONTROL_MASK ) {
74 ostream << "Control + ";
77 const char* keyName = global_keys_find( accelerator.key );
78 if ( !string_empty( keyName ) ) {
83 ostream << static_cast<char>( accelerator.key );
86 ostream << gtk_accelerator_get_label( accelerator.key, accelerator.modifiers );
89 typedef std::map<Accelerator, Callback<void()>> AcceleratorMap;
90 typedef std::set<Accelerator> AcceleratorSet;
92 bool accelerator_map_insert( AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback<void()>& callback ){
93 if ( accelerator.key != 0 ) {
94 return acceleratorMap.insert( AcceleratorMap::value_type( accelerator, callback ) ).second;
99 bool accelerator_map_erase( AcceleratorMap& acceleratorMap, Accelerator accelerator ){
100 if ( accelerator.key != 0 ) {
101 AcceleratorMap::iterator i = acceleratorMap.find( accelerator );
102 if ( i == acceleratorMap.end() ) {
105 acceleratorMap.erase( i );
110 Accelerator accelerator_for_event_key( guint keyval, guint state ){
111 keyval = gdk_keyval_to_upper( keyval );
112 if ( keyval == GDK_KEY_ISO_Left_Tab ) {
113 keyval = GDK_KEY_Tab;
115 return Accelerator( keyval, (GdkModifierType)( state & gtk_accelerator_get_default_mod_mask() ) );
118 bool AcceleratorMap_activate( const AcceleratorMap& acceleratorMap, const Accelerator& accelerator ){
119 AcceleratorMap::const_iterator i = acceleratorMap.find( accelerator );
120 if ( i != acceleratorMap.end() ) {
128 static gboolean accelerator_key_event( ui::Window window, GdkEventKey* event, AcceleratorMap* acceleratorMap ){
129 return AcceleratorMap_activate( *acceleratorMap, accelerator_for_event_key( event->keyval, event->state ) );
133 AcceleratorMap g_special_accelerators;
136 namespace MouseButton
146 typedef unsigned int ButtonMask;
148 void print_buttons( ButtonMask mask ){
149 globalOutputStream() << "button state: ";
150 if ( ( mask & MouseButton::Left ) != 0 ) {
151 globalOutputStream() << "Left ";
153 if ( ( mask & MouseButton::Right ) != 0 ) {
154 globalOutputStream() << "Right ";
156 if ( ( mask & MouseButton::Middle ) != 0 ) {
157 globalOutputStream() << "Middle ";
159 globalOutputStream() << "\n";
162 ButtonMask ButtonMask_for_event_button( guint button ){
166 return MouseButton::Left;
168 return MouseButton::Middle;
170 return MouseButton::Right;
175 bool window_has_accel( ui::Window toplevel ){
176 return g_slist_length( gtk_accel_groups_from_object( G_OBJECT( toplevel ) ) ) != 0;
181 bool g_accel_enabled = true;
184 bool global_accel_enabled(){
185 return g_accel_enabled;
189 GClosure* accel_group_add_accelerator(ui::AccelGroup group, Accelerator accelerator, const Callback<void()>& callback );
190 void accel_group_remove_accelerator(ui::AccelGroup group, Accelerator accelerator );
192 AcceleratorMap g_queuedAcceleratorsAdd;
193 AcceleratorSet g_queuedAcceleratorsRemove;
195 void globalQueuedAccelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
196 if ( !g_queuedAcceleratorsAdd.insert( AcceleratorMap::value_type( accelerator, callback ) ).second ) {
197 globalErrorStream() << "globalQueuedAccelerators_add: accelerator already queued: " << accelerator << "\n";
201 void globalQueuedAccelerators_remove( Accelerator accelerator ){
202 if ( g_queuedAcceleratorsAdd.erase( accelerator ) == 0 ) {
203 if ( !g_queuedAcceleratorsRemove.insert( accelerator ).second ) {
204 globalErrorStream() << "globalQueuedAccelerators_remove: accelerator already queued: " << accelerator << "\n";
209 void globalQueuedAccelerators_commit(){
210 for ( AcceleratorSet::const_iterator i = g_queuedAcceleratorsRemove.begin(); i != g_queuedAcceleratorsRemove.end(); ++i )
212 //globalOutputStream() << "removing: " << (*i).first << "\n";
213 accel_group_remove_accelerator( global_accel, *i );
215 g_queuedAcceleratorsRemove.clear();
216 for ( AcceleratorMap::const_iterator i = g_queuedAcceleratorsAdd.begin(); i != g_queuedAcceleratorsAdd.end(); ++i )
218 //globalOutputStream() << "adding: " << (*i).first << "\n";
219 accel_group_add_accelerator( global_accel, ( *i ).first, ( *i ).second );
221 g_queuedAcceleratorsAdd.clear();
224 typedef std::set<ui::Window> WindowSet;
225 WindowSet g_accel_windows;
227 bool Buttons_press( ButtonMask& buttons, guint button, guint state ){
228 if ( buttons == 0 && bitfield_enable( buttons, ButtonMask_for_event_button( button ) ) != 0 ) {
229 ASSERT_MESSAGE( g_accel_enabled, "Buttons_press: accelerators not enabled" );
230 g_accel_enabled = false;
231 for ( WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i )
233 ui::Window toplevel = *i;
234 ASSERT_MESSAGE( window_has_accel( toplevel ), "ERROR" );
235 ASSERT_MESSAGE( gtk_widget_is_toplevel( toplevel ), "disabling accel for non-toplevel window" );
236 gtk_window_remove_accel_group( toplevel, global_accel );
238 globalOutputStream() << reinterpret_cast<unsigned int>( toplevel ) << ": disabled global accelerators\n";
242 buttons = bitfield_enable( buttons, ButtonMask_for_event_button( button ) );
244 globalOutputStream() << "Buttons_press: ";
245 print_buttons( buttons );
250 bool Buttons_release( ButtonMask& buttons, guint button, guint state ){
251 if ( buttons != 0 && bitfield_disable( buttons, ButtonMask_for_event_button( button ) ) == 0 ) {
252 ASSERT_MESSAGE( !g_accel_enabled, "Buttons_release: accelerators are enabled" );
253 g_accel_enabled = true;
254 for ( WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i )
256 ui::Window toplevel = *i;
257 ASSERT_MESSAGE( !window_has_accel( toplevel ), "ERROR" );
258 ASSERT_MESSAGE( gtk_widget_is_toplevel( toplevel ), "enabling accel for non-toplevel window" );
259 toplevel.add_accel_group( global_accel );
261 globalOutputStream() << reinterpret_cast<unsigned int>( toplevel ) << ": enabled global accelerators\n";
264 globalQueuedAccelerators_commit();
266 buttons = bitfield_disable( buttons, ButtonMask_for_event_button( button ) );
268 globalOutputStream() << "Buttons_release: ";
269 print_buttons( buttons );
274 bool Buttons_releaseAll( ButtonMask& buttons ){
275 Buttons_release( buttons, MouseButton::Left | MouseButton::Middle | MouseButton::Right, 0 );
279 struct PressedButtons
283 PressedButtons() : buttons( 0 ){
287 gboolean PressedButtons_button_press(ui::Widget widget, GdkEventButton* event, PressedButtons* pressed ){
288 if ( event->type == GDK_BUTTON_PRESS ) {
289 return Buttons_press( pressed->buttons, event->button, event->state );
294 gboolean PressedButtons_button_release(ui::Widget widget, GdkEventButton* event, PressedButtons* pressed ){
295 if ( event->type == GDK_BUTTON_RELEASE ) {
296 return Buttons_release( pressed->buttons, event->button, event->state );
301 gboolean PressedButtons_focus_out(ui::Widget widget, GdkEventFocus* event, PressedButtons* pressed ){
302 Buttons_releaseAll( pressed->buttons );
306 void PressedButtons_connect( PressedButtons& pressedButtons, ui::Widget widget ){
307 widget.connect( "button_press_event", G_CALLBACK( PressedButtons_button_press ), &pressedButtons );
308 widget.connect( "button_release_event", G_CALLBACK( PressedButtons_button_release ), &pressedButtons );
309 widget.connect( "focus_out_event", G_CALLBACK( PressedButtons_focus_out ), &pressedButtons );
312 PressedButtons g_pressedButtons;
316 #include <uilib/uilib.h>
320 typedef std::set<guint> Keys;
322 std::size_t refcount;
324 PressedKeys() : refcount( 0 ){
328 AcceleratorMap g_keydown_accelerators;
329 AcceleratorMap g_keyup_accelerators;
331 bool Keys_press( PressedKeys::Keys& keys, guint keyval ){
332 if ( keys.insert( keyval ).second ) {
333 return AcceleratorMap_activate( g_keydown_accelerators, accelerator_for_event_key( keyval, 0 ) );
335 return g_keydown_accelerators.find( accelerator_for_event_key( keyval, 0 ) ) != g_keydown_accelerators.end();
338 bool Keys_release( PressedKeys::Keys& keys, guint keyval ){
339 if ( keys.erase( keyval ) != 0 ) {
340 return AcceleratorMap_activate( g_keyup_accelerators, accelerator_for_event_key( keyval, 0 ) );
342 return g_keyup_accelerators.find( accelerator_for_event_key( keyval, 0 ) ) != g_keyup_accelerators.end();
345 void Keys_releaseAll( PressedKeys::Keys& keys, guint state ){
346 for ( PressedKeys::Keys::iterator i = keys.begin(); i != keys.end(); ++i )
348 AcceleratorMap_activate( g_keyup_accelerators, accelerator_for_event_key( *i, state ) );
353 gboolean PressedKeys_key_press(ui::Widget widget, GdkEventKey* event, PressedKeys* pressedKeys ){
354 //globalOutputStream() << "pressed: " << event->keyval << "\n";
355 //return event->state == 0 && Keys_press( pressedKeys->keys, event->keyval );
356 //NumLock perspective window fix
357 return ( event->state & ALLOWED_MODIFIERS ) == 0 && Keys_press( pressedKeys->keys, event->keyval );
360 gboolean PressedKeys_key_release(ui::Widget widget, GdkEventKey* event, PressedKeys* pressedKeys ){
361 //globalOutputStream() << "released: " << event->keyval << "\n";
362 return Keys_release( pressedKeys->keys, event->keyval );
365 gboolean PressedKeys_focus_in(ui::Widget widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
366 ++pressedKeys->refcount;
370 gboolean PressedKeys_focus_out(ui::Widget widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
371 if ( --pressedKeys->refcount == 0 ) {
372 Keys_releaseAll( pressedKeys->keys, 0 );
377 PressedKeys g_pressedKeys;
379 void GlobalPressedKeys_releaseAll(){
380 Keys_releaseAll( g_pressedKeys.keys, 0 );
383 void GlobalPressedKeys_connect( ui::Window window ){
384 unsigned int key_press_handler = window.connect( "key_press_event", G_CALLBACK( PressedKeys_key_press ), &g_pressedKeys );
385 unsigned int key_release_handler = window.connect( "key_release_event", G_CALLBACK( PressedKeys_key_release ), &g_pressedKeys );
386 g_object_set_data( G_OBJECT( window ), "key_press_handler", gint_to_pointer( key_press_handler ) );
387 g_object_set_data( G_OBJECT( window ), "key_release_handler", gint_to_pointer( key_release_handler ) );
388 unsigned int focus_in_handler = window.connect( "focus_in_event", G_CALLBACK( PressedKeys_focus_in ), &g_pressedKeys );
389 unsigned int focus_out_handler = window.connect( "focus_out_event", G_CALLBACK( PressedKeys_focus_out ), &g_pressedKeys );
390 g_object_set_data( G_OBJECT( window ), "focus_in_handler", gint_to_pointer( focus_in_handler ) );
391 g_object_set_data( G_OBJECT( window ), "focus_out_handler", gint_to_pointer( focus_out_handler ) );
394 void GlobalPressedKeys_disconnect( ui::Window window ){
395 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_press_handler" ) ) );
396 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_release_handler" ) ) );
397 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_in_handler" ) ) );
398 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_out_handler" ) ) );
403 void special_accelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
404 //globalOutputStream() << "special_accelerators_add: " << makeQuoted(accelerator) << "\n";
405 if ( !accelerator_map_insert( g_special_accelerators, accelerator, callback ) ) {
406 globalErrorStream() << "special_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
409 void special_accelerators_remove( Accelerator accelerator ){
410 //globalOutputStream() << "special_accelerators_remove: " << makeQuoted(accelerator) << "\n";
411 if ( !accelerator_map_erase( g_special_accelerators, accelerator ) ) {
412 globalErrorStream() << "special_accelerators_remove: not found: " << makeQuoted( accelerator ) << "\n";
416 void keydown_accelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
417 //globalOutputStream() << "keydown_accelerators_add: " << makeQuoted(accelerator) << "\n";
418 if ( !accelerator_map_insert( g_keydown_accelerators, accelerator, callback ) ) {
419 globalErrorStream() << "keydown_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
422 void keydown_accelerators_remove( Accelerator accelerator ){
423 //globalOutputStream() << "keydown_accelerators_remove: " << makeQuoted(accelerator) << "\n";
424 if ( !accelerator_map_erase( g_keydown_accelerators, accelerator ) ) {
425 globalErrorStream() << "keydown_accelerators_remove: not found: " << makeQuoted( accelerator ) << "\n";
429 void keyup_accelerators_add( Accelerator accelerator, const Callback<void()>& callback ){
430 //globalOutputStream() << "keyup_accelerators_add: " << makeQuoted(accelerator) << "\n";
431 if ( !accelerator_map_insert( g_keyup_accelerators, accelerator, callback ) ) {
432 globalErrorStream() << "keyup_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
435 void keyup_accelerators_remove( Accelerator accelerator ){
436 //globalOutputStream() << "keyup_accelerators_remove: " << makeQuoted(accelerator) << "\n";
437 if ( !accelerator_map_erase( g_keyup_accelerators, accelerator ) ) {
438 globalErrorStream() << "keyup_accelerators_remove: not found: " << makeQuoted( accelerator ) << "\n";
443 gboolean accel_closure_callback(ui::AccelGroup group, ui::Widget widget, guint key, GdkModifierType modifiers, gpointer data ){
444 ( *reinterpret_cast<Callback<void()>*>( data ) )( );
448 GClosure* accel_group_add_accelerator(ui::AccelGroup group, Accelerator accelerator, const Callback<void()>& callback ){
449 if ( accelerator.key != 0 && gtk_accelerator_valid( accelerator.key, accelerator.modifiers ) ) {
450 //globalOutputStream() << "global_accel_connect: " << makeQuoted(accelerator) << "\n";
451 GClosure* closure = create_cclosure( G_CALLBACK( accel_closure_callback ), callback );
452 gtk_accel_group_connect( group, accelerator.key, accelerator.modifiers, GTK_ACCEL_VISIBLE, closure );
457 special_accelerators_add( accelerator, callback );
462 void accel_group_remove_accelerator(ui::AccelGroup group, Accelerator accelerator ){
463 if ( accelerator.key != 0 && gtk_accelerator_valid( accelerator.key, accelerator.modifiers ) ) {
464 //globalOutputStream() << "global_accel_disconnect: " << makeQuoted(accelerator) << "\n";
465 gtk_accel_group_disconnect_key( group, accelerator.key, accelerator.modifiers );
469 special_accelerators_remove( accelerator );
473 ui::AccelGroup global_accel{ui::New};
475 GClosure* global_accel_group_add_accelerator( Accelerator accelerator, const Callback<void()>& callback ){
476 if ( !global_accel_enabled() ) {
477 // workaround: cannot add to GtkAccelGroup while it is disabled
478 //globalOutputStream() << "queued for add: " << accelerator << "\n";
479 globalQueuedAccelerators_add( accelerator, callback );
482 return accel_group_add_accelerator( global_accel, accelerator, callback );
484 void global_accel_group_remove_accelerator( Accelerator accelerator ){
485 if ( !global_accel_enabled() ) {
486 //globalOutputStream() << "queued for remove: " << accelerator << "\n";
487 globalQueuedAccelerators_remove( accelerator );
490 accel_group_remove_accelerator( global_accel, accelerator );
493 /// \brief Propagates key events to the focus-widget, overriding global accelerators.
494 static gboolean override_global_accelerators( ui::Window window, GdkEventKey* event, gpointer data ){
495 gboolean b = gtk_window_propagate_key_event( window, event );
499 void global_accel_connect_window( ui::Window window ){
501 unsigned int override_handler = window.connect( "key_press_event", G_CALLBACK( override_global_accelerators ), 0 );
502 g_object_set_data( G_OBJECT( window ), "override_handler", gint_to_pointer( override_handler ) );
504 unsigned int special_key_press_handler = window.connect( "key_press_event", G_CALLBACK( accelerator_key_event ), &g_special_accelerators );
505 g_object_set_data( G_OBJECT( window ), "special_key_press_handler", gint_to_pointer( special_key_press_handler ) );
507 GlobalPressedKeys_connect( window );
509 unsigned int key_press_handler = window.connect( "key_press_event", G_CALLBACK( accelerator_key_event ), &g_keydown_accelerators );
510 unsigned int key_release_handler = window.connect( "key_release_event", G_CALLBACK( accelerator_key_event ), &g_keyup_accelerators );
511 g_object_set_data( G_OBJECT( window ), "key_press_handler", gint_to_pointer( key_press_handler ) );
512 g_object_set_data( G_OBJECT( window ), "key_release_handler", gint_to_pointer( key_release_handler ) );
514 g_accel_windows.insert( window );
515 window.add_accel_group( global_accel );
517 void global_accel_disconnect_window( ui::Window window ){
519 GlobalPressedKeys_disconnect( window );
521 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "override_handler" ) ) );
522 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "special_key_press_handler" ) ) );
524 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_press_handler" ) ) );
525 g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_release_handler" ) ) );
527 gtk_window_remove_accel_group( window, global_accel );
528 std::size_t count = g_accel_windows.erase( window );
529 ASSERT_MESSAGE( count == 1, "failed to remove accel group\n" );
533 GClosure* global_accel_group_find( Accelerator accelerator ){
534 guint numEntries = 0;
535 GtkAccelGroupEntry* entry = gtk_accel_group_query( global_accel, accelerator.key, accelerator.modifiers, &numEntries );
536 if ( numEntries != 0 ) {
537 if ( numEntries != 1 ) {
538 char* name = gtk_accelerator_name( accelerator.key, accelerator.modifiers );
539 globalErrorStream() << "accelerator already in-use: " << name << "\n";
542 return entry->closure;
547 void global_accel_group_connect( const Accelerator& accelerator, const Callback<void()>& callback ){
548 if ( accelerator.key != 0 ) {
549 global_accel_group_add_accelerator( accelerator, callback );
553 void global_accel_group_disconnect( const Accelerator& accelerator, const Callback<void()>& callback ){
554 if ( accelerator.key != 0 ) {
555 global_accel_group_remove_accelerator( accelerator );