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
  34 #include "pointer.h"
  35 #include "closure.h"
  36
  37
  38
  39 typedef std::map<Accelerator, Callback> AcceleratorMap;
  40
  41 void accelerator_map_insert(AcceleratorMap& acceleratorMap, Accelerator accelerator, const Callback& callback)
  42 {
  43   if(accelerator.key != 0)
  44   {
  45     ASSERT_MESSAGE(acceleratorMap.find(accelerator) == acceleratorMap.end(), "failed to add accelerator");
  46     acceleratorMap.insert(AcceleratorMap::value_type(accelerator, callback));
  47   }
  48 }
  49
  50 void accelerator_map_erase(AcceleratorMap& acceleratorMap, Accelerator accelerator)
  51 {
  52   if(accelerator.key != 0)
  53   {
  54     ASSERT_MESSAGE(acceleratorMap.find(accelerator) != acceleratorMap.end(), "failed to remove accelerator");
  55     acceleratorMap.erase(accelerator);
  56   }
  57 }
  58
  59 Accelerator accelerator_for_event_key(guint keyval, guint state)
  60 {
  61   keyval = gdk_keyval_to_upper(keyval);
  62   if(keyval == GDK_ISO_Left_Tab)
  63     keyval = GDK_Tab;
  64   return Accelerator(keyval, (GdkModifierType)(state & gtk_accelerator_get_default_mod_mask()));
  65 }
  66
  67 bool AcceleratorMap_activate(const AcceleratorMap& acceleratorMap, const Accelerator& accelerator)
  68 {
  69   AcceleratorMap::const_iterator i = acceleratorMap.find(accelerator);
  70   if(i != acceleratorMap.end())
  71   {
  72     (*i).second();
  73     return true;
  74   }
  75
  76   return false;
  77 }
  78
  79 static gboolean accelerator_key_event(GtkWindow* window, GdkEventKey* event, AcceleratorMap* acceleratorMap)
  80 {
  81   return AcceleratorMap_activate(*acceleratorMap, accelerator_for_event_key(event->keyval, event->state));
  82 }
  83
  84
  85 AcceleratorMap g_special_accelerators;
  86
  87
  88 namespace MouseButton
  89 {
  90   enum
  91   {
  92     Left = 1 << 0,
  93     Right = 1 << 1,
  94     Middle = 1 << 2,
  95   };
  96 }
  97
  98 typedef unsigned int ButtonMask;
  99
 100 void print_buttons(ButtonMask mask)
 101 {
 102   globalOutputStream() << "button state: ";
 103   if((mask & MouseButton::Left) != 0)
 104   {
 105     globalOutputStream() << "Left ";
 106   }
 107   if((mask & MouseButton::Right) != 0)
 108   {
 109     globalOutputStream() << "Right ";
 110   }
 111   if((mask & MouseButton::Middle) != 0)
 112   {
 113     globalOutputStream() << "Middle ";
 114   }
 115   globalOutputStream() << "\n";
 116 }
 117
 118 ButtonMask ButtonMask_for_event_button(guint button)
 119 {
 120   switch(button)
 121   {
 122   case 1:
 123     return MouseButton::Left;
 124   case 2:
 125     return MouseButton::Middle;
 126   case 3:
 127     return MouseButton::Right;
 128   }
 129   return 0;
 130 }
 131
 132 bool window_has_accel(GtkWindow* toplevel)
 133 {
 134   return g_slist_length(gtk_accel_groups_from_object(G_OBJECT(toplevel))) != 0;
 135 }
 136
 137 namespace
 138 {
 139   bool g_accel_enabled = true;
 140 }
 141
 142 bool global_accel_enabled()
 143 {
 144   return g_accel_enabled;
 145 }
 146
 147
 148 AcceleratorMap g_queuedAccelerators;
 149
 150 GClosure* accel_group_add_accelerator(GtkAccelGroup* group, Accelerator accelerator, const Callback& callback);
 151
 152 void GlobalQueuedAccelerators_commit()
 153 {
 154   for(AcceleratorMap::const_iterator i = g_queuedAccelerators.begin(); i != g_queuedAccelerators.end(); ++i)
 155   {
 156     accel_group_add_accelerator(global_accel, (*i).first, (*i).second);
 157   }
 158   g_queuedAccelerators.clear();
 159 }
 160
 161 void GlobalQueuedAccelerators_add(Accelerator accelerator, const Callback& callback)
 162 {
 163   g_queuedAccelerators.insert(AcceleratorMap::value_type(accelerator, callback));
 164 }
 165
 166 void accel_group_test(GtkWindow* toplevel, GtkAccelGroup* accel)
 167 {
 168   guint n_entries;
 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";
 172 }
 173
 174 typedef std::set<GtkWindow*> WindowSet;
 175 WindowSet g_accel_windows;
 176
 177 bool Buttons_press(ButtonMask& buttons, guint button, guint state)
 178 {
 179   if(buttons == 0 && bitfield_enable(buttons, ButtonMask_for_event_button(button)) != 0)
 180   {
 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)
 184     {
 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);
 189 #if 0
 190       globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": disabled global accelerators\n";
 191 #endif
 192 #if 0
 193       accel_group_test(toplevel, global_accel);
 194 #endif
 195     }
 196   }
 197   buttons = bitfield_enable(buttons, ButtonMask_for_event_button(button));
 198 #if 0
 199   globalOutputStream() << "Buttons_press: ";
 200   print_buttons(buttons);
 201 #endif
 202   return false;
 203 }
 204
 205 bool Buttons_release(ButtonMask& buttons, guint button, guint state)
 206 {
 207   if(buttons != 0 && bitfield_disable(buttons, ButtonMask_for_event_button(button)) == 0)
 208   {
 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)
 212     {
 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);
 217 #if 0
 218       globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": enabled global accelerators\n";
 219 #endif
 220 #if 0
 221       accel_group_test(toplevel, global_accel);
 222 #endif
 223     }
 224     GlobalQueuedAccelerators_commit();
 225   }
 226   buttons = bitfield_disable(buttons, ButtonMask_for_event_button(button));
 227 #if 0
 228   globalOutputStream() << "Buttons_release: ";
 229   print_buttons(buttons);
 230 #endif
 231   return false;
 232 }
 233
 234 bool Buttons_releaseAll(ButtonMask& buttons)
 235 {
 236   Buttons_release(buttons, MouseButton::Left | MouseButton::Middle | MouseButton::Right, 0);
 237   return false;
 238 }
 239
 240 struct PressedButtons
 241 {
 242   ButtonMask buttons;
 243
 244   PressedButtons() : buttons(0)
 245   {
 246   }
 247 };
 248
 249 gboolean PressedButtons_button_press(GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed)
 250 {
 251   if(event->type == GDK_BUTTON_PRESS)
 252   {
 253     return Buttons_press(pressed->buttons, event->button, event->state);
 254   }
 255   return FALSE;
 256 }
 257
 258 gboolean PressedButtons_button_release(GtkWidget* widget, GdkEventButton* event, PressedButtons* pressed)
 259 {
 260   if(event->type == GDK_BUTTON_RELEASE)
 261   {
 262     return Buttons_release(pressed->buttons, event->button, event->state);
 263   }
 264   return FALSE;
 265 }
 266
 267 gboolean PressedButtons_focus_out(GtkWidget* widget, GdkEventFocus* event, PressedButtons* pressed)
 268 {
 269   Buttons_releaseAll(pressed->buttons);
 270   return FALSE;
 271 }
 272
 273 void PressedButtons_connect(PressedButtons& pressedButtons, GtkWidget* widget)
 274 {
 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);
 278 }
 279
 280 PressedButtons g_pressedButtons;
 281
 282
 283 #include <set>
 284
 285 struct PressedKeys
 286 {
 287   typedef std::set<guint> Keys;
 288   Keys keys;
 289   std::size_t refcount;
 290
 291   PressedKeys() : refcount(0)
 292   {
 293   }
 294 };
 295
 296 AcceleratorMap g_keydown_accelerators;
 297 AcceleratorMap g_keyup_accelerators;
 298
 299 bool Keys_press(PressedKeys::Keys& keys, guint keyval)
 300 {
 301   if(keys.insert(keyval).second)
 302   {
 303     return AcceleratorMap_activate(g_keydown_accelerators, accelerator_for_event_key(keyval, 0));
 304   }
 305   return g_keydown_accelerators.find(accelerator_for_event_key(keyval, 0)) != g_keydown_accelerators.end();
 306 }
 307
 308 bool Keys_release(PressedKeys::Keys& keys, guint keyval)
 309 {
 310   if(keys.erase(keyval) != 0)
 311   {
 312     return AcceleratorMap_activate(g_keyup_accelerators, accelerator_for_event_key(keyval, 0));
 313   }
 314   return g_keyup_accelerators.find(accelerator_for_event_key(keyval, 0)) != g_keyup_accelerators.end();
 315 }
 316
 317 void Keys_releaseAll(PressedKeys::Keys& keys, guint state)
 318 {
 319   for(PressedKeys::Keys::iterator i = keys.begin(); i != keys.end(); ++i)
 320   {
 321     AcceleratorMap_activate(g_keyup_accelerators, accelerator_for_event_key(*i, state));
 322   }
 323   keys.clear();
 324 }
 325
 326 gboolean PressedKeys_key_press(GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys)
 327 {
 328   //globalOutputStream() << "pressed: " << event->keyval << "\n";
 329   return event->state == 0 && Keys_press(pressedKeys->keys, event->keyval);
 330 }
 331
 332 gboolean PressedKeys_key_release(GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys)
 333 {
 334   //globalOutputStream() << "released: " << event->keyval << "\n";
 335   return Keys_release(pressedKeys->keys, event->keyval);
 336 }
 337
 338 gboolean PressedKeys_focus_in(GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys)
 339 {
 340   ++pressedKeys->refcount;
 341   return FALSE;
 342 }
 343
 344 gboolean PressedKeys_focus_out(GtkWidget* widget, GdkEventFocus* event, PressedKeys* pressedKeys)
 345 {
 346   if(--pressedKeys->refcount == 0)
 347   {
 348     Keys_releaseAll(pressedKeys->keys, 0);
 349   }
 350   return FALSE;
 351 }
 352
 353 PressedKeys g_pressedKeys;
 354
 355 void GlobalPressedKeys_releaseAll()
 356 {
 357   Keys_releaseAll(g_pressedKeys.keys, 0);
 358 }
 359
 360 void GlobalPressedKeys_connect(GtkWindow* window)
 361 {
 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));
 370 }
 371
 372 void GlobalPressedKeys_disconnect(GtkWindow* window)
 373 {
 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")));
 378 }
 379
 380
 381
 382 void special_accelerators_add(Accelerator accelerator, const Callback& callback)
 383 {
 384   accelerator_map_insert(g_special_accelerators, accelerator, callback);
 385 }
 386 void special_accelerators_remove(Accelerator accelerator)
 387 {
 388   accelerator_map_erase(g_special_accelerators, accelerator);
 389 }
 390
 391 void keydown_accelerators_add(Accelerator accelerator, const Callback& callback)
 392 {
 393   accelerator_map_insert(g_keydown_accelerators, accelerator, callback);
 394 }
 395 void keydown_accelerators_remove(Accelerator accelerator)
 396 {
 397   accelerator_map_erase(g_keydown_accelerators, accelerator);
 398 }
 399
 400 void keyup_accelerators_add(Accelerator accelerator, const Callback& callback)
 401 {
 402   accelerator_map_insert(g_keyup_accelerators, accelerator, callback);
 403 }
 404 void keyup_accelerators_remove(Accelerator accelerator)
 405 {
 406   accelerator_map_erase(g_keyup_accelerators, accelerator);
 407 }
 408
 409
 410 gboolean accel_closure_callback(GtkAccelGroup* group, GtkWidget* widget, guint key, GdkModifierType modifiers, gpointer data)
 411 {
 412   (*reinterpret_cast<Callback*>(data))();
 413   return TRUE;
 414 }
 415
 416 GClosure* accel_group_add_accelerator(GtkAccelGroup* group, Accelerator accelerator, const Callback& callback)
 417 {
 418   if(accelerator.key != 0 && gtk_accelerator_valid(accelerator.key, accelerator.modifiers))
 419   {
 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);
 423     return closure;
 424   }
 425   else
 426   {
 427     special_accelerators_add(accelerator, callback);
 428     return 0;
 429   }
 430 }
 431
 432 void accel_group_remove_accelerator(GtkAccelGroup* group, Accelerator accelerator)
 433 {
 434   if(accelerator.key != 0 && gtk_accelerator_valid(accelerator.key, accelerator.modifiers))
 435   {
 436     gtk_accel_group_disconnect_key(group, accelerator.key, accelerator.modifiers);
 437   }
 438   else
 439   {
 440     special_accelerators_remove(accelerator);
 441   }
 442 }
 443
 444 GtkAccelGroup* global_accel = 0;
 445
 446 void global_accel_init()
 447 {
 448   global_accel = gtk_accel_group_new();
 449 }
 450
 451 void global_accel_destroy()
 452 {
 453   g_object_unref(global_accel);
 454 }
 455
 456 GClosure* global_accel_group_add_accelerator(Accelerator accelerator, const Callback& callback)
 457 {
 458   if(!global_accel_enabled())
 459   {
 460     // workaround: cannot add to GtkAccelGroup while it is disabled
 461     GlobalQueuedAccelerators_add(accelerator, callback);
 462     return 0;
 463   }
 464   return accel_group_add_accelerator(global_accel, accelerator, callback);
 465 }
 466 void global_accel_group_remove_accelerator(Accelerator accelerator)
 467 {
 468   //ASSERT_MESSAGE(global_accel_enabled(), "removing accelerator while global accel is disabled");
 469   accel_group_remove_accelerator(global_accel, accelerator);
 470 }
 471
 472 /// \brief Propagates key events to the focus-widget, overriding global accelerators.
 473 static gboolean override_global_accelerators(GtkWindow* window, GdkEventKey* event, gpointer data)
 474 {
 475   return gtk_window_propagate_key_event(window, event);
 476 }
 477
 478 void global_accel_connect_window(GtkWindow* window)
 479 {
 480 #if 1
 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));
 483
 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));
 486
 487   GlobalPressedKeys_connect(window);
 488 #else
 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));
 493 #endif
 494   g_accel_windows.insert(window);
 495   gtk_window_add_accel_group(window, global_accel);
 496 }
 497 void global_accel_disconnect_window(GtkWindow* window)
 498 {
 499 #if 1
 500   GlobalPressedKeys_disconnect(window);
 501
 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")));
 504 #else
 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")));
 507 #endif
 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");
 511 }
 512
 513
 514 GClosure* global_accel_group_find(Accelerator accelerator)
 515 {
 516   guint numEntries = 0;
 517   GtkAccelGroupEntry* entry = gtk_accel_group_query(global_accel, accelerator.key, accelerator.modifiers, &numEntries);
 518   if(numEntries != 0)
 519   {
 520     if(numEntries != 1)
 521     {
 522       char* name = gtk_accelerator_name(accelerator.key, accelerator.modifiers);
 523       globalErrorStream() << "accelerator already in-use: " << name << "\n";
 524       g_free(name);
 525     }
 526     return entry->closure;
 527   }
 528   return 0;
 529 }
 530
 531 void command_connect_accelerator(const Accelerator& accelerator, const Callback& callback)
 532 {
 533   if(accelerator.key != 0)
 534   {
 535     global_accel_group_add_accelerator(accelerator, callback);
 536   }
 537 }
 538
 539 void command_disconnect_accelerator(const Accelerator& accelerator, const Callback& callback)
 540 {
 541   if(accelerator.key != 0)
 542   {
 543     global_accel_group_remove_accelerator(accelerator);
 544   }
 545 }
 546
 547