libs/gtkutil/accelerator.cpp

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   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.
  11
  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.
  16
  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
  20  */
  21
  22 #include "accelerator.h"
  23
  24 #include "debugging/debugging.h"
  25
  26 #include <map>
  27 #include <set>
  28 #include <gtk/gtkwindow.h>
  29 #include <gtk/gtkaccelgroup.h>
  30
  31 #include "generic/callback.h"
  32 #include "generic/bitfield.h"
  33 #include "string/string.h"
  34
  35 #include "pointer.h"
  36 #include "closure.h"
  37
  38 #include <gdk/gdkkeysyms.h>
  39
  40
  41
  42 const char* global_keys_find( unsigned int key ){
  43         const char *s;
  44         if ( key == 0 ) {
  45                 return "";
  46         }
  47         s = gdk_keyval_name( key );
  48         if ( !s ) {
  49                 return "";
  50         }
  51         return s;
  52 }
  53
  54 unsigned int global_keys_find( const char* name ){
  55         guint k;
  56         if ( !name || !*name ) {
  57                 return 0;
  58         }
  59         k = gdk_keyval_from_name( name );
  60         if ( k == GDK_VoidSymbol ) {
  61                 return 0;
  62         }
  63         return k;
  64 }
  65
  66 void accelerator_write( const Accelerator& accelerator, TextOutputStream& ostream ){
  67 #if 0
  68         if ( accelerator.modifiers & GDK_SHIFT_MASK ) {
  69                 ostream << "Shift + ";
  70         }
  71         if ( accelerator.modifiers & GDK_MOD1_MASK ) {
  72                 ostream << "Alt + ";
  73         }
  74         if ( accelerator.modifiers & GDK_CONTROL_MASK ) {
  75                 ostream << "Control + ";
  76         }
  77
  78         const char* keyName = global_keys_find( accelerator.key );
  79         if ( !string_empty( keyName ) ) {
  80                 ostream << keyName;
  81         }
  82         else
  83         {
  84                 ostream << static_cast<char>( accelerator.key );
  85         }
  86 #endif
  87         ostream << gtk_accelerator_get_label( accelerator.key, accelerator.modifiers );
  88 }
  89
  90 typedef std::map<Accelerator, Callback> AcceleratorMap;
  91 typedef std::set<Accelerator> AcceleratorSet;
  92
  93 bool accelerator_map_insert( AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback& callback ){
  94         if ( accelerator.key != 0 ) {
  95                 return acceleratorMap.insert( AcceleratorMap::value_type( accelerator, callback ) ).second;
  96         }
  97         return true;
  98 }
  99
 100 bool accelerator_map_erase( AcceleratorMap& acceleratorMap, Accelerator accelerator ){
 101         if ( accelerator.key != 0 ) {
 102                 AcceleratorMap::iterator i = acceleratorMap.find( accelerator );
 103                 if ( i == acceleratorMap.end() ) {
 104                         return false;
 105                 }
 106                 acceleratorMap.erase( i );
 107         }
 108         return true;
 109 }
 110
 111 Accelerator accelerator_for_event_key( guint keyval, guint state ){
 112         keyval = gdk_keyval_to_upper( keyval );
 113         if ( keyval == GDK_ISO_Left_Tab ) {
 114                 keyval = GDK_Tab;
 115         }
 116         return Accelerator( keyval, (GdkModifierType)( state & gtk_accelerator_get_default_mod_mask() ) );
 117 }
 118
 119 bool AcceleratorMap_activate( const AcceleratorMap& acceleratorMap, const Accelerator& accelerator ){
 120         AcceleratorMap::const_iterator i = acceleratorMap.find( accelerator );
 121         if ( i != acceleratorMap.end() ) {
 122                 ( *i ).second();
 123                 return true;
 124         }
 125
 126         return false;
 127 }
 128
 129 static gboolean accelerator_key_event( GtkWindow* window, GdkEventKey* event, AcceleratorMap* acceleratorMap ){
 130         return AcceleratorMap_activate( *acceleratorMap, accelerator_for_event_key( event->keyval, event->state ) );
 131 }
 132
 133
 134 AcceleratorMap g_special_accelerators;
 135
 136
 137 namespace MouseButton
 138 {
 139 enum
 140 {
 141         Left = 1 << 0,
 142         Right = 1 << 1,
 143         Middle = 1 << 2,
 144 };
 145 }
 146
 147 typedef unsigned int ButtonMask;
 148
 149 void print_buttons( ButtonMask mask ){
 150         globalOutputStream() << "button state: ";
 151         if ( ( mask & MouseButton::Left ) != 0 ) {
 152                 globalOutputStream() << "Left ";
 153         }
 154         if ( ( mask & MouseButton::Right ) != 0 ) {
 155                 globalOutputStream() << "Right ";
 156         }
 157         if ( ( mask & MouseButton::Middle ) != 0 ) {
 158                 globalOutputStream() << "Middle ";
 159         }
 160         globalOutputStream() << "\n";
 161 }
 162
 163 ButtonMask ButtonMask_for_event_button( guint button ){
 164         switch ( button )
 165         {
 166         case 1:
 167                 return MouseButton::Left;
 168         case 2:
 169                 return MouseButton::Middle;
 170         case 3:
 171                 return MouseButton::Right;
 172         }
 173         return 0;
 174 }
 175
 176 bool window_has_accel( GtkWindow* toplevel ){
 177         return g_slist_length( gtk_accel_groups_from_object( G_OBJECT( toplevel ) ) ) != 0;
 178 }
 179
 180 namespace
 181 {
 182 bool g_accel_enabled = true;
 183 }
 184
 185 bool global_accel_enabled(){
 186         return g_accel_enabled;
 187 }
 188
 189
 190 GClosure* accel_group_add_accelerator( GtkAccelGroup* group, Accelerator accelerator, const Callback& callback );
 191 void accel_group_remove_accelerator( GtkAccelGroup* group, Accelerator accelerator );
 192
 193 AcceleratorMap g_queuedAcceleratorsAdd;
 194 AcceleratorSet g_queuedAcceleratorsRemove;
 195
 196 void globalQueuedAccelerators_add( Accelerator accelerator, const Callback& callback ){
 197         if ( !g_queuedAcceleratorsAdd.insert( AcceleratorMap::value_type( accelerator, callback ) ).second ) {
 198                 globalErrorStream() << "globalQueuedAccelerators_add: accelerator already queued: " << accelerator << "\n";
 199         }
 200 }
 201
 202 void globalQueuedAccelerators_remove( Accelerator accelerator ){
 203         if ( g_queuedAcceleratorsAdd.erase( accelerator ) == 0 ) {
 204                 if ( !g_queuedAcceleratorsRemove.insert( accelerator ).second ) {
 205                         globalErrorStream() << "globalQueuedAccelerators_remove: accelerator already queued: " << accelerator << "\n";
 206                 }
 207         }
 208 }
 209
 210 void globalQueuedAccelerators_commit(){
 211         for ( AcceleratorSet::const_iterator i = g_queuedAcceleratorsRemove.begin(); i != g_queuedAcceleratorsRemove.end(); ++i )
 212         {
 213                 //globalOutputStream() << "removing: " << (*i).first << "\n";
 214                 accel_group_remove_accelerator( global_accel, *i );
 215         }
 216         g_queuedAcceleratorsRemove.clear();
 217         for ( AcceleratorMap::const_iterator i = g_queuedAcceleratorsAdd.begin(); i != g_queuedAcceleratorsAdd.end(); ++i )
 218         {
 219                 //globalOutputStream() << "adding: " << (*i).first << "\n";
 220                 accel_group_add_accelerator( global_accel, ( *i ).first, ( *i ).second );
 221         }
 222         g_queuedAcceleratorsAdd.clear();
 223 }
 224
 225 void accel_group_test( GtkWindow* toplevel, GtkAccelGroup* accel ){
 226         guint n_entries;
 227         gtk_accel_group_query( accel, '4', (GdkModifierType)0, &n_entries );
 228         globalOutputStream() << "grid4: " << n_entries << "\n";
 229         globalOutputStream() << "toplevel accelgroups: " << g_slist_length( gtk_accel_groups_from_object( G_OBJECT( toplevel ) ) ) << "\n";
 230 }
 231
 232 typedef std::set<GtkWindow*> WindowSet;
 233 WindowSet g_accel_windows;
 234
 235 bool Buttons_press( ButtonMask& buttons, guint button, guint state ){
 236         if ( buttons == 0 && bitfield_enable( buttons, ButtonMask_for_event_button( button ) ) != 0 ) {
 237                 ASSERT_MESSAGE( g_accel_enabled, "Buttons_press: accelerators not enabled" );
 238                 g_accel_enabled = false;
 239                 for ( WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i )
 240                 {
 241                         GtkWindow* toplevel = *i;
 242                         ASSERT_MESSAGE( window_has_accel( toplevel ), "ERROR" );
 243                         ASSERT_MESSAGE( GTK_WIDGET_TOPLEVEL( toplevel ), "disabling accel for non-toplevel window" );
 244                         gtk_window_remove_accel_group( toplevel,  global_accel );
 245 #if 0
 246                         globalOutputStream() << reinterpret_cast<unsigned int>( toplevel ) << ": disabled global accelerators\n";
 247 #endif
 248 #if 0
 249                         accel_group_test( toplevel, global_accel );
 250 #endif
 251                 }
 252         }
 253         buttons = bitfield_enable( buttons, ButtonMask_for_event_button( button ) );
 254 #if 0
 255         globalOutputStream() << "Buttons_press: ";
 256         print_buttons( buttons );
 257 #endif
 258         return false;
 259 }
 260
 261 bool Buttons_release( ButtonMask& buttons, guint button, guint state ){
 262         if ( buttons != 0 && bitfield_disable( buttons, ButtonMask_for_event_button( button ) ) == 0 ) {
 263                 ASSERT_MESSAGE( !g_accel_enabled, "Buttons_release: accelerators are enabled" );
 264                 g_accel_enabled = true;
 265                 for ( WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i )
 266                 {
 267                         GtkWindow* toplevel = *i;
 268                         ASSERT_MESSAGE( !window_has_accel( toplevel ), "ERROR" );
 269                         ASSERT_MESSAGE( GTK_WIDGET_TOPLEVEL( toplevel ), "enabling accel for non-toplevel window" );
 270                         gtk_window_add_accel_group( toplevel, global_accel );
 271 #if 0
 272                         globalOutputStream() << reinterpret_cast<unsigned int>( toplevel ) << ": enabled global accelerators\n";
 273 #endif
 274 #if 0
 275                         accel_group_test( toplevel, global_accel );
 276 #endif
 277                 }
 278                 globalQueuedAccelerators_commit();
 279         }
 280         buttons = bitfield_disable( buttons, ButtonMask_for_event_button( button ) );
 281 #if 0
 282         globalOutputStream() << "Buttons_release: ";
 283         print_buttons( buttons );
 284 #endif
 285         return false;
 286 }
 287
 288 bool Buttons_releaseAll( ButtonMask& buttons ){
 289         Buttons_release( buttons, MouseButton::Left | MouseButton::Middle | MouseButton::Right, 0 );
 290         return false;
 291 }
 292
 293 struct PressedButtons
 294 {
 295         ButtonMask buttons;
 296
 297         PressedButtons() : buttons( 0 ){
 298         }
 299 };
 300
 301 gboolean PressedButtons_button_press( GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed ){
 302         if ( event->type == GDK_BUTTON_PRESS ) {
 303                 return Buttons_press( pressed->buttons, event->button, event->state );
 304         }
 305         return FALSE;
 306 }
 307
 308 gboolean PressedButtons_button_release( GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed ){
 309         if ( event->type == GDK_BUTTON_RELEASE ) {
 310                 return Buttons_release( pressed->buttons, event->button, event->state );
 311         }
 312         return FALSE;
 313 }
 314
 315 gboolean PressedButtons_focus_out( GtkWidget* widget, GdkEventFocus* event, PressedButtons* pressed ){
 316         Buttons_releaseAll( pressed->buttons );
 317         return FALSE;
 318 }
 319
 320 void PressedButtons_connect( PressedButtons& pressedButtons, GtkWidget* widget ){
 321         g_signal_connect( G_OBJECT( widget ), "button_press_event", G_CALLBACK( PressedButtons_button_press ), &pressedButtons );
 322         g_signal_connect( G_OBJECT( widget ), "button_release_event", G_CALLBACK( PressedButtons_button_release ), &pressedButtons );
 323         g_signal_connect( G_OBJECT( widget ), "focus_out_event", G_CALLBACK( PressedButtons_focus_out ), &pressedButtons );
 324 }
 325
 326 PressedButtons g_pressedButtons;
 327
 328
 329 #include <set>
 330
 331 struct PressedKeys
 332 {
 333         typedef std::set<guint> Keys;
 334         Keys keys;
 335         std::size_t refcount;
 336
 337         PressedKeys() : refcount( 0 ){
 338         }
 339 };
 340
 341 AcceleratorMap g_keydown_accelerators;
 342 AcceleratorMap g_keyup_accelerators;
 343
 344 bool Keys_press( PressedKeys::Keys& keys, guint keyval ){
 345         if ( keys.insert( keyval ).second ) {
 346                 return AcceleratorMap_activate( g_keydown_accelerators, accelerator_for_event_key( keyval, 0 ) );
 347         }
 348         return g_keydown_accelerators.find( accelerator_for_event_key( keyval, 0 ) ) != g_keydown_accelerators.end();
 349 }
 350
 351 bool Keys_release( PressedKeys::Keys& keys, guint keyval ){
 352         if ( keys.erase( keyval ) != 0 ) {
 353                 return AcceleratorMap_activate( g_keyup_accelerators, accelerator_for_event_key( keyval, 0 ) );
 354         }
 355         return g_keyup_accelerators.find( accelerator_for_event_key( keyval, 0 ) ) != g_keyup_accelerators.end();
 356 }
 357
 358 void Keys_releaseAll( PressedKeys::Keys& keys, guint state ){
 359         for ( PressedKeys::Keys::iterator i = keys.begin(); i != keys.end(); ++i )
 360         {
 361                 AcceleratorMap_activate( g_keyup_accelerators, accelerator_for_event_key( *i, state ) );
 362         }
 363         keys.clear();
 364 }
 365
 366 gboolean PressedKeys_key_press( GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys ){
 367         //globalOutputStream() << "pressed: " << event->keyval << "\n";
 368         return event->state == 0 && Keys_press( pressedKeys->keys, event->keyval );
 369 }
 370
 371 gboolean PressedKeys_key_release( GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys ){
 372         //globalOutputStream() << "released: " << event->keyval << "\n";
 373         return Keys_release( pressedKeys->keys, event->keyval );
 374 }
 375
 376 gboolean PressedKeys_focus_in( GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
 377         ++pressedKeys->refcount;
 378         return FALSE;
 379 }
 380
 381 gboolean PressedKeys_focus_out( GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys ){
 382         if ( --pressedKeys->refcount == 0 ) {
 383                 Keys_releaseAll( pressedKeys->keys, 0 );
 384         }
 385         return FALSE;
 386 }
 387
 388 PressedKeys g_pressedKeys;
 389
 390 void GlobalPressedKeys_releaseAll(){
 391         Keys_releaseAll( g_pressedKeys.keys, 0 );
 392 }
 393
 394 void GlobalPressedKeys_connect( GtkWindow* window ){
 395         unsigned int key_press_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( PressedKeys_key_press ), &g_pressedKeys );
 396         unsigned int key_release_handler = g_signal_connect( G_OBJECT( window ), "key_release_event", G_CALLBACK( PressedKeys_key_release ), &g_pressedKeys );
 397         g_object_set_data( G_OBJECT( window ), "key_press_handler", gint_to_pointer( key_press_handler ) );
 398         g_object_set_data( G_OBJECT( window ), "key_release_handler", gint_to_pointer( key_release_handler ) );
 399         unsigned int focus_in_handler = g_signal_connect( G_OBJECT( window ), "focus_in_event", G_CALLBACK( PressedKeys_focus_in ), &g_pressedKeys );
 400         unsigned int focus_out_handler = g_signal_connect( G_OBJECT( window ), "focus_out_event", G_CALLBACK( PressedKeys_focus_out ), &g_pressedKeys );
 401         g_object_set_data( G_OBJECT( window ), "focus_in_handler", gint_to_pointer( focus_in_handler ) );
 402         g_object_set_data( G_OBJECT( window ), "focus_out_handler", gint_to_pointer( focus_out_handler ) );
 403 }
 404
 405 void GlobalPressedKeys_disconnect( GtkWindow* window ){
 406         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_press_handler" ) ) );
 407         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_release_handler" ) ) );
 408         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_in_handler" ) ) );
 409         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_out_handler" ) ) );
 410 }
 411
 412
 413
 414 void special_accelerators_add( Accelerator accelerator, const Callback& callback ){
 415         //globalOutputStream() << "special_accelerators_add: " << makeQuoted(accelerator) << "\n";
 416         if ( !accelerator_map_insert( g_special_accelerators, accelerator, callback ) ) {
 417                 globalErrorStream() << "special_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
 418         }
 419 }
 420 void special_accelerators_remove( Accelerator accelerator ){
 421         //globalOutputStream() << "special_accelerators_remove: " << makeQuoted(accelerator) << "\n";
 422         if ( !accelerator_map_erase( g_special_accelerators, accelerator ) ) {
 423                 globalErrorStream() << "special_accelerators_remove: not found: " << makeQuoted( accelerator ) << "\n";
 424         }
 425 }
 426
 427 void keydown_accelerators_add( Accelerator accelerator, const Callback& callback ){
 428         //globalOutputStream() << "keydown_accelerators_add: " << makeQuoted(accelerator) << "\n";
 429         if ( !accelerator_map_insert( g_keydown_accelerators, accelerator, callback ) ) {
 430                 globalErrorStream() << "keydown_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
 431         }
 432 }
 433 void keydown_accelerators_remove( Accelerator accelerator ){
 434         //globalOutputStream() << "keydown_accelerators_remove: " << makeQuoted(accelerator) << "\n";
 435         if ( !accelerator_map_erase( g_keydown_accelerators, accelerator ) ) {
 436                 globalErrorStream() << "keydown_accelerators_remove: not found: " << makeQuoted( accelerator ) << "\n";
 437         }
 438 }
 439
 440 void keyup_accelerators_add( Accelerator accelerator, const Callback& callback ){
 441         //globalOutputStream() << "keyup_accelerators_add: " << makeQuoted(accelerator) << "\n";
 442         if ( !accelerator_map_insert( g_keyup_accelerators, accelerator, callback ) ) {
 443                 globalErrorStream() << "keyup_accelerators_add: already exists: " << makeQuoted( accelerator ) << "\n";
 444         }
 445 }
 446 void keyup_accelerators_remove( Accelerator accelerator ){
 447         //globalOutputStream() << "keyup_accelerators_remove: " << makeQuoted(accelerator) << "\n";
 448         if ( !accelerator_map_erase( g_keyup_accelerators, accelerator ) ) {
 449                 globalErrorStream() << "keyup_accelerators_remove: not found: " << makeQuoted( accelerator ) << "\n";
 450         }
 451 }
 452
 453
 454 gboolean accel_closure_callback( GtkAccelGroup* group, GtkWidget* widget, guint key, GdkModifierType modifiers, gpointer data ){
 455         ( *reinterpret_cast<Callback*>( data ) )( );
 456         return TRUE;
 457 }
 458
 459 GClosure* accel_group_add_accelerator( GtkAccelGroup* group, Accelerator accelerator, const Callback& callback ){
 460         if ( accelerator.key != 0 && gtk_accelerator_valid( accelerator.key, accelerator.modifiers ) ) {
 461                 //globalOutputStream() << "global_accel_connect: " << makeQuoted(accelerator) << "\n";
 462                 GClosure* closure = create_cclosure( G_CALLBACK( accel_closure_callback ), callback );
 463                 gtk_accel_group_connect( group, accelerator.key, accelerator.modifiers, GTK_ACCEL_VISIBLE, closure );
 464                 return closure;
 465         }
 466         else
 467         {
 468                 special_accelerators_add( accelerator, callback );
 469                 return 0;
 470         }
 471 }
 472
 473 void accel_group_remove_accelerator( GtkAccelGroup* group, Accelerator accelerator ){
 474         if ( accelerator.key != 0 && gtk_accelerator_valid( accelerator.key, accelerator.modifiers ) ) {
 475                 //globalOutputStream() << "global_accel_disconnect: " << makeQuoted(accelerator) << "\n";
 476                 gtk_accel_group_disconnect_key( group, accelerator.key, accelerator.modifiers );
 477         }
 478         else
 479         {
 480                 special_accelerators_remove( accelerator );
 481         }
 482 }
 483
 484 GtkAccelGroup* global_accel = 0;
 485
 486 void global_accel_init(){
 487         global_accel = gtk_accel_group_new();
 488 }
 489
 490 void global_accel_destroy(){
 491         g_object_unref( global_accel );
 492 }
 493
 494 GClosure* global_accel_group_add_accelerator( Accelerator accelerator, const Callback& callback ){
 495         if ( !global_accel_enabled() ) {
 496                 // workaround: cannot add to GtkAccelGroup while it is disabled
 497                 //globalOutputStream() << "queued for add: " << accelerator << "\n";
 498                 globalQueuedAccelerators_add( accelerator, callback );
 499                 return 0;
 500         }
 501         return accel_group_add_accelerator( global_accel, accelerator, callback );
 502 }
 503 void global_accel_group_remove_accelerator( Accelerator accelerator ){
 504         if ( !global_accel_enabled() ) {
 505                 //globalOutputStream() << "queued for remove: " << accelerator << "\n";
 506                 globalQueuedAccelerators_remove( accelerator );
 507                 return;
 508         }
 509         accel_group_remove_accelerator( global_accel, accelerator );
 510 }
 511
 512 /// \brief Propagates key events to the focus-widget, overriding global accelerators.
 513 static gboolean override_global_accelerators( GtkWindow* window, GdkEventKey* event, gpointer data ){
 514         gboolean b = gtk_window_propagate_key_event( window, event );
 515         return b;
 516 }
 517
 518 void global_accel_connect_window( GtkWindow* window ){
 519 #if 1
 520         unsigned int override_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( override_global_accelerators ), 0 );
 521         g_object_set_data( G_OBJECT( window ), "override_handler", gint_to_pointer( override_handler ) );
 522
 523         unsigned int special_key_press_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( accelerator_key_event ), &g_special_accelerators );
 524         g_object_set_data( G_OBJECT( window ), "special_key_press_handler", gint_to_pointer( special_key_press_handler ) );
 525
 526         GlobalPressedKeys_connect( window );
 527 #else
 528         unsigned int key_press_handler = g_signal_connect( G_OBJECT( window ), "key_press_event", G_CALLBACK( accelerator_key_event ), &g_keydown_accelerators );
 529         unsigned int key_release_handler = g_signal_connect( G_OBJECT( window ), "key_release_event", G_CALLBACK( accelerator_key_event ), &g_keyup_accelerators );
 530         g_object_set_data( G_OBJECT( window ), "key_press_handler", gint_to_pointer( key_press_handler ) );
 531         g_object_set_data( G_OBJECT( window ), "key_release_handler", gint_to_pointer( key_release_handler ) );
 532 #endif
 533         g_accel_windows.insert( window );
 534         gtk_window_add_accel_group( window, global_accel );
 535 }
 536 void global_accel_disconnect_window( GtkWindow* window ){
 537 #if 1
 538         GlobalPressedKeys_disconnect( window );
 539
 540         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "override_handler" ) ) );
 541         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "special_key_press_handler" ) ) );
 542 #else
 543         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_press_handler" ) ) );
 544         g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_release_handler" ) ) );
 545 #endif
 546         gtk_window_remove_accel_group( window, global_accel );
 547         std::size_t count = g_accel_windows.erase( window );
 548         ASSERT_MESSAGE( count == 1, "failed to remove accel group\n" );
 549 }
 550
 551
 552 GClosure* global_accel_group_find( Accelerator accelerator ){
 553         guint numEntries = 0;
 554         GtkAccelGroupEntry* entry = gtk_accel_group_query( global_accel, accelerator.key, accelerator.modifiers, &numEntries );
 555         if ( numEntries != 0 ) {
 556                 if ( numEntries != 1 ) {
 557                         char* name = gtk_accelerator_name( accelerator.key, accelerator.modifiers );
 558                         globalErrorStream() << "accelerator already in-use: " << name << "\n";
 559                         g_free( name );
 560                 }
 561                 return entry->closure;
 562         }
 563         return 0;
 564 }
 565
 566 void global_accel_group_connect( const Accelerator& accelerator, const Callback& callback ){
 567         if ( accelerator.key != 0 ) {
 568                 global_accel_group_add_accelerator( accelerator, callback );
 569         }
 570 }
 571
 572 void global_accel_group_disconnect( const Accelerator& accelerator, const Callback& callback ){
 573         if ( accelerator.key != 0 ) {
 574                 global_accel_group_remove_accelerator( accelerator );
 575         }
 576 }