radiant/commands.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 "commands.h"
  23
  24 #include "gtk/gtk.h"
  25 #include "debugging/debugging.h"
  26 #include "warnings.h"
  27
  28 #include <map>
  29 #include "string/string.h"
  30 #include "versionlib.h"
  31 #include "gtkutil/messagebox.h"
  32 #include "gtkmisc.h"
  33
  34 typedef std::pair<Accelerator, int> ShortcutValue; // accelerator, isRegistered
  35 typedef std::map<CopiedString, ShortcutValue> Shortcuts;
  36
  37 void Shortcuts_foreach(Shortcuts &shortcuts, CommandVisitor &visitor)
  38 {
  39     for (Shortcuts::iterator i = shortcuts.begin(); i != shortcuts.end(); ++i) {
  40         visitor.visit((*i).first.c_str(), (*i).second.first);
  41     }
  42 }
  43
  44 Shortcuts g_shortcuts;
  45
  46 const Accelerator &GlobalShortcuts_insert(const char *name, const Accelerator &accelerator)
  47 {
  48     return (*g_shortcuts.insert(Shortcuts::value_type(name, ShortcutValue(accelerator, false))).first).second.first;
  49 }
  50
  51 void GlobalShortcuts_foreach(CommandVisitor &visitor)
  52 {
  53     Shortcuts_foreach(g_shortcuts, visitor);
  54 }
  55
  56 void GlobalShortcuts_register(const char *name, int type)
  57 {
  58     Shortcuts::iterator i = g_shortcuts.find(name);
  59     if (i != g_shortcuts.end()) {
  60         (*i).second.second = type;
  61     }
  62 }
  63
  64 void GlobalShortcuts_reportUnregistered()
  65 {
  66     for (Shortcuts::iterator i = g_shortcuts.begin(); i != g_shortcuts.end(); ++i) {
  67         if ((*i).second.first.key != 0 && !(*i).second.second) {
  68             globalOutputStream() << "shortcut not registered: " << (*i).first.c_str() << "\n";
  69         }
  70     }
  71 }
  72
  73 typedef std::map<CopiedString, Command> Commands;
  74
  75 Commands g_commands;
  76
  77 void GlobalCommands_insert(const char *name, const Callback<void()> &callback, const Accelerator &accelerator)
  78 {
  79     bool added = g_commands.insert(
  80             Commands::value_type(name, Command(callback, GlobalShortcuts_insert(name, accelerator)))).second;
  81     ASSERT_MESSAGE(added, "command already registered: " << makeQuoted(name));
  82 }
  83
  84 const Command &GlobalCommands_find(const char *command)
  85 {
  86     Commands::iterator i = g_commands.find(command);
  87     ASSERT_MESSAGE(i != g_commands.end(), "failed to lookup command " << makeQuoted(command));
  88     return (*i).second;
  89 }
  90
  91 typedef std::map<CopiedString, Toggle> Toggles;
  92
  93
  94 Toggles g_toggles;
  95
  96 void GlobalToggles_insert(const char *name, const Callback<void()> &callback,
  97                           const Callback<void(const Callback<void(bool)> &)> &exportCallback,
  98                           const Accelerator &accelerator)
  99 {
 100     bool added = g_toggles.insert(Toggles::value_type(name, Toggle(callback, GlobalShortcuts_insert(name, accelerator),
 101                                                                    exportCallback))).second;
 102     ASSERT_MESSAGE(added, "toggle already registered: " << makeQuoted(name));
 103 }
 104
 105 const Toggle &GlobalToggles_find(const char *name)
 106 {
 107     Toggles::iterator i = g_toggles.find(name);
 108     ASSERT_MESSAGE(i != g_toggles.end(), "failed to lookup toggle " << makeQuoted(name));
 109     return (*i).second;
 110 }
 111
 112 typedef std::map<CopiedString, KeyEvent> KeyEvents;
 113
 114
 115 KeyEvents g_keyEvents;
 116
 117 void GlobalKeyEvents_insert(const char *name, const Accelerator &accelerator, const Callback<void()> &keyDown,
 118                             const Callback<void()> &keyUp)
 119 {
 120     bool added = g_keyEvents.insert(
 121             KeyEvents::value_type(name, KeyEvent(GlobalShortcuts_insert(name, accelerator), keyDown, keyUp))).second;
 122     ASSERT_MESSAGE(added, "command already registered: " << makeQuoted(name));
 123 }
 124
 125 const KeyEvent &GlobalKeyEvents_find(const char *name)
 126 {
 127     KeyEvents::iterator i = g_keyEvents.find(name);
 128     ASSERT_MESSAGE(i != g_keyEvents.end(), "failed to lookup keyEvent " << makeQuoted(name));
 129     return (*i).second;
 130 }
 131
 132
 133 void disconnect_accelerator(const char *name)
 134 {
 135     Shortcuts::iterator i = g_shortcuts.find(name);
 136     if (i != g_shortcuts.end()) {
 137         switch ((*i).second.second) {
 138             case 1:
 139                 // command
 140                 command_disconnect_accelerator(name);
 141                 break;
 142             case 2:
 143                 // toggle
 144                 toggle_remove_accelerator(name);
 145                 break;
 146         }
 147     }
 148 }
 149
 150 void connect_accelerator(const char *name)
 151 {
 152     Shortcuts::iterator i = g_shortcuts.find(name);
 153     if (i != g_shortcuts.end()) {
 154         switch ((*i).second.second) {
 155             case 1:
 156                 // command
 157                 command_connect_accelerator(name);
 158                 break;
 159             case 2:
 160                 // toggle
 161                 toggle_add_accelerator(name);
 162                 break;
 163         }
 164     }
 165 }
 166
 167
 168 #include <uilib/uilib.h>
 169 #include <gdk/gdkkeysyms.h>
 170
 171 #include "gtkutil/dialog.h"
 172 #include "mainframe.h"
 173
 174 #include "stream/textfilestream.h"
 175 #include "stream/stringstream.h"
 176
 177
 178 struct command_list_dialog_t : public ModalDialog {
 179     command_list_dialog_t()
 180             : m_close_button(*this, eIDCANCEL), m_list(ui::null), m_command_iter(), m_model(ui::null),
 181               m_waiting_for_key(false)
 182     {
 183     }
 184
 185     ModalDialogButton m_close_button;
 186
 187     ui::TreeView m_list;
 188     GtkTreeIter m_command_iter;
 189     ui::TreeModel m_model;
 190     bool m_waiting_for_key;
 191 };
 192
 193 void accelerator_clear_button_clicked(ui::Button btn, gpointer dialogptr)
 194 {
 195     command_list_dialog_t &dialog = *(command_list_dialog_t *) dialogptr;
 196
 197     if (dialog.m_waiting_for_key) {
 198         // just unhighlight, user wanted to cancel
 199         dialog.m_waiting_for_key = false;
 200         gtk_list_store_set(ui::ListStore::from(dialog.m_model), &dialog.m_command_iter, 2, false, -1);
 201         gtk_widget_set_sensitive(dialog.m_list, true);
 202         dialog.m_model = ui::TreeModel(ui::null);
 203         return;
 204     }
 205
 206     auto sel = gtk_tree_view_get_selection(dialog.m_list);
 207     GtkTreeModel *model;
 208     GtkTreeIter iter;
 209     if (!gtk_tree_selection_get_selected(sel, &model, &iter)) {
 210         return;
 211     }
 212
 213     GValue val;
 214     memset(&val, 0, sizeof(val));
 215     gtk_tree_model_get_value(model, &iter, 0, &val);
 216     const char *commandName = g_value_get_string(&val);;
 217
 218     // clear the ACTUAL accelerator too!
 219     disconnect_accelerator(commandName);
 220
 221     Shortcuts::iterator thisShortcutIterator = g_shortcuts.find(commandName);
 222     if (thisShortcutIterator == g_shortcuts.end()) {
 223         return;
 224     }
 225     thisShortcutIterator->second.first = accelerator_null();
 226
 227     gtk_list_store_set(ui::ListStore::from(model), &iter, 1, "", -1);
 228
 229     g_value_unset(&val);
 230 }
 231
 232 void accelerator_edit_button_clicked(ui::Button btn, gpointer dialogptr)
 233 {
 234     command_list_dialog_t &dialog = *(command_list_dialog_t *) dialogptr;
 235
 236     // 1. find selected row
 237     auto sel = gtk_tree_view_get_selection(dialog.m_list);
 238     GtkTreeModel *model;
 239     GtkTreeIter iter;
 240     if (!gtk_tree_selection_get_selected(sel, &model, &iter)) {
 241         return;
 242     }
 243     dialog.m_command_iter = iter;
 244     dialog.m_model = ui::TreeModel::from(model);
 245
 246     // 2. disallow changing the row
 247     //gtk_widget_set_sensitive(dialog.m_list, false);
 248
 249     // 3. highlight the row
 250     gtk_list_store_set(ui::ListStore::from(model), &iter, 2, true, -1);
 251
 252     // 4. grab keyboard focus
 253     dialog.m_waiting_for_key = true;
 254 }
 255
 256 bool accelerator_window_key_press(ui::Window widget, GdkEventKey *event, gpointer dialogptr)
 257 {
 258     command_list_dialog_t &dialog = *(command_list_dialog_t *) dialogptr;
 259
 260     if (!dialog.m_waiting_for_key) {
 261         return false;
 262     }
 263
 264 #if 0
 265     if ( event->is_modifier ) {
 266         return false;
 267     }
 268 #else
 269     switch (event->keyval) {
 270         case GDK_KEY_Shift_L:
 271         case GDK_KEY_Shift_R:
 272         case GDK_KEY_Control_L:
 273         case GDK_KEY_Control_R:
 274         case GDK_KEY_Caps_Lock:
 275         case GDK_KEY_Shift_Lock:
 276         case GDK_KEY_Meta_L:
 277         case GDK_KEY_Meta_R:
 278         case GDK_KEY_Alt_L:
 279         case GDK_KEY_Alt_R:
 280         case GDK_KEY_Super_L:
 281         case GDK_KEY_Super_R:
 282         case GDK_KEY_Hyper_L:
 283         case GDK_KEY_Hyper_R:
 284             return false;
 285     }
 286 #endif
 287
 288     dialog.m_waiting_for_key = false;
 289
 290     // 7. find the name of the accelerator
 291     GValue val;
 292     memset(&val, 0, sizeof(val));
 293     gtk_tree_model_get_value(dialog.m_model, &dialog.m_command_iter, 0, &val);
 294     const char *commandName = g_value_get_string(&val);;
 295     Shortcuts::iterator thisShortcutIterator = g_shortcuts.find(commandName);
 296     if (thisShortcutIterator == g_shortcuts.end()) {
 297         gtk_list_store_set(ui::ListStore::from(dialog.m_model), &dialog.m_command_iter, 2, false, -1);
 298         gtk_widget_set_sensitive(dialog.m_list, true);
 299         return true;
 300     }
 301
 302     // 8. build an Accelerator
 303     Accelerator newAccel(event->keyval, (GdkModifierType) event->state);
 304
 305     // 8. verify the key is still free, show a dialog to ask what to do if not
 306     class VerifyAcceleratorNotTaken : public CommandVisitor {
 307         const char *commandName;
 308         const Accelerator &newAccel;
 309         ui::Widget widget;
 310         ui::TreeModel model;
 311     public:
 312         bool allow;
 313
 314         VerifyAcceleratorNotTaken(const char *name, const Accelerator &accelerator, ui::Widget w, ui::TreeModel m)
 315                 : commandName(name), newAccel(accelerator), widget(w), model(m), allow(true)
 316         {
 317         }
 318
 319         void visit(const char *name, Accelerator &accelerator)
 320         {
 321             if (!strcmp(name, commandName)) {
 322                 return;
 323             }
 324             if (!allow) {
 325                 return;
 326             }
 327             if (accelerator.key == 0) {
 328                 return;
 329             }
 330             if (accelerator == newAccel) {
 331                 StringOutputStream msg;
 332                 msg << "The command " << name << " is already assigned to the key " << accelerator << ".\n\n"
 333                     << "Do you want to unassign " << name << " first?";
 334                 auto r = ui::alert(widget.window(), msg.c_str(), "Key already used", ui::alert_type::YESNOCANCEL);
 335                 if (r == ui::alert_response::YES) {
 336                     // clear the ACTUAL accelerator too!
 337                     disconnect_accelerator(name);
 338                     // delete the modifier
 339                     accelerator = accelerator_null();
 340                     // empty the cell of the key binds dialog
 341                     GtkTreeIter i;
 342                     if (gtk_tree_model_get_iter_first(model, &i)) {
 343                         for (;;) {
 344                             GValue val;
 345                             memset(&val, 0, sizeof(val));
 346                             gtk_tree_model_get_value(model, &i, 0, &val);
 347                             const char *thisName = g_value_get_string(&val);;
 348                             if (!strcmp(thisName, name)) {
 349                                 gtk_list_store_set(ui::ListStore::from(model), &i, 1, "", -1);
 350                             }
 351                             g_value_unset(&val);
 352                             if (!gtk_tree_model_iter_next(model, &i)) {
 353                                 break;
 354                             }
 355                         }
 356                     }
 357                 } else if (r == ui::alert_response::CANCEL) {
 358                     // aborted
 359                     allow = false;
 360                 }
 361             }
 362         }
 363     } verify_visitor(commandName, newAccel, widget, dialog.m_model);
 364     GlobalShortcuts_foreach(verify_visitor);
 365
 366     gtk_list_store_set(ui::ListStore::from(dialog.m_model), &dialog.m_command_iter, 2, false, -1);
 367     gtk_widget_set_sensitive(dialog.m_list, true);
 368
 369     if (verify_visitor.allow) {
 370         // clear the ACTUAL accelerator first
 371         disconnect_accelerator(commandName);
 372
 373         thisShortcutIterator->second.first = newAccel;
 374
 375         // write into the cell
 376         StringOutputStream modifiers;
 377         modifiers << newAccel;
 378         gtk_list_store_set(ui::ListStore::from(dialog.m_model), &dialog.m_command_iter, 1, modifiers.c_str(), -1);
 379
 380         // set the ACTUAL accelerator too!
 381         connect_accelerator(commandName);
 382     }
 383
 384     g_value_unset(&val);
 385
 386     dialog.m_model = ui::TreeModel(ui::null);
 387
 388     return true;
 389 }
 390
 391 /*
 392     GtkTreeIter row;
 393     GValue val;
 394     if(!model) {g_error("Unable to get model from cell renderer");}
 395     gtk_tree_model_get_iter_from_string(model, &row, path_string);
 396
 397     gtk_tree_model_get_value(model, &row, 0, &val);
 398     const char *name = g_value_get_string(&val);
 399     Shortcuts::iterator i = g_shortcuts.find(name);
 400     if(i != g_shortcuts.end())
 401     {
 402         accelerator_parse(i->second.first, new_text);
 403         StringOutputStream modifiers;
 404         modifiers << i->second.first;
 405         gtk_list_store_set(ui::ListStore::from(model), &row, 1, modifiers.c_str(), -1);
 406     }
 407    };
 408  */
 409
 410 void DoCommandListDlg()
 411 {
 412     command_list_dialog_t dialog;
 413
 414     ui::Window window = MainFrame_getWindow().create_modal_dialog_window("Mapped Commands", dialog, -1, 400);
 415     window.on_key_press([](ui::Widget widget, GdkEventKey *event, gpointer dialogptr) {
 416         return accelerator_window_key_press(ui::Window::from(widget), event, dialogptr);
 417     }, &dialog);
 418
 419     auto accel = ui::AccelGroup(ui::New);
 420     window.add_accel_group(accel);
 421
 422     auto hbox = create_dialog_hbox(4, 4);
 423     window.add(hbox);
 424
 425     {
 426         auto scr = create_scrolled_window(ui::Policy::NEVER, ui::Policy::AUTOMATIC);
 427         hbox.pack_start(scr, TRUE, TRUE, 0);
 428
 429         {
 430             auto store = ui::ListStore::from(
 431                     gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT));
 432
 433             auto view = ui::TreeView(ui::TreeModel::from(store._handle));
 434             dialog.m_list = view;
 435
 436             gtk_tree_view_set_enable_search(view, false); // annoying
 437
 438             {
 439                 auto renderer = ui::CellRendererText(ui::New);
 440                 auto column = ui::TreeViewColumn("Command", renderer, {{"text",       0},
 441                                                                        {"weight-set", 2},
 442                                                                        {"weight",     3}});
 443                 gtk_tree_view_append_column(view, column);
 444             }
 445
 446             {
 447                 auto renderer = ui::CellRendererText(ui::New);
 448                 auto column = ui::TreeViewColumn("Key", renderer, {{"text",       1},
 449                                                                    {"weight-set", 2},
 450                                                                    {"weight",     3}});
 451                 gtk_tree_view_append_column(view, column);
 452             }
 453
 454             view.show();
 455             scr.add(view);
 456
 457             {
 458                 // Initialize dialog
 459                 StringOutputStream path(256);
 460                 path << SettingsPath_get() << "commandlist.txt";
 461                 globalOutputStream() << "Writing the command list to " << path.c_str() << "\n";
 462                 class BuildCommandList : public CommandVisitor {
 463                     TextFileOutputStream m_commandList;
 464                     ui::ListStore m_store;
 465                 public:
 466                     BuildCommandList(const char *filename, ui::ListStore store) : m_commandList(filename),
 467                                                                                   m_store(store)
 468                     {
 469                     }
 470
 471                     void visit(const char *name, Accelerator &accelerator)
 472                     {
 473                         StringOutputStream modifiers;
 474                         modifiers << accelerator;
 475
 476                         m_store.append(0, name, 1, modifiers.c_str(), 2, false, 3, 800);
 477
 478                         if (!m_commandList.failed()) {
 479                             int l = strlen(name);
 480                             m_commandList << name;
 481                             while (l++ < 25) {
 482                                 m_commandList << ' ';
 483                             }
 484                             m_commandList << modifiers.c_str() << '\n';
 485                         }
 486                     }
 487                 } visitor(path.c_str(), store);
 488
 489                 GlobalShortcuts_foreach(visitor);
 490             }
 491
 492             store.unref();
 493         }
 494     }
 495
 496     auto vbox = create_dialog_vbox(4);
 497     hbox.pack_start(vbox, TRUE, TRUE, 0);
 498     {
 499         auto editbutton = create_dialog_button("Edit", (GCallback) accelerator_edit_button_clicked, &dialog);
 500         vbox.pack_start(editbutton, FALSE, FALSE, 0);
 501
 502         auto clearbutton = create_dialog_button("Clear", (GCallback) accelerator_clear_button_clicked, &dialog);
 503         vbox.pack_start(clearbutton, FALSE, FALSE, 0);
 504
 505         ui::Widget spacer = ui::Image(ui::New);
 506         spacer.show();
 507         vbox.pack_start(spacer, TRUE, TRUE, 0);
 508
 509         auto button = create_modal_dialog_button("Close", dialog.m_close_button);
 510         vbox.pack_start(button, FALSE, FALSE, 0);
 511         widget_make_default(button);
 512         gtk_widget_grab_default(button);
 513         gtk_widget_add_accelerator(button, "clicked", accel, GDK_KEY_Return, (GdkModifierType) 0, (GtkAccelFlags) 0);
 514         gtk_widget_add_accelerator(button, "clicked", accel, GDK_KEY_Escape, (GdkModifierType) 0, (GtkAccelFlags) 0);
 515     }
 516
 517     modal_dialog_show(window, dialog);
 518     window.destroy();
 519 }
 520
 521 #include "profile/profile.h"
 522
 523 const char *const COMMANDS_VERSION = "1.0-gtk-accelnames";
 524
 525 void SaveCommandMap(const char *path)
 526 {
 527     StringOutputStream strINI(256);
 528     strINI << path << "shortcuts.ini";
 529
 530     TextFileOutputStream file(strINI.c_str());
 531     if (!file.failed()) {
 532         file << "[Version]\n";
 533         file << "number=" << COMMANDS_VERSION << "\n";
 534         file << "\n";
 535         file << "[Commands]\n";
 536         class WriteCommandMap : public CommandVisitor {
 537             TextFileOutputStream &m_file;
 538         public:
 539             WriteCommandMap(TextFileOutputStream &file) : m_file(file)
 540             {
 541             }
 542
 543             void visit(const char *name, Accelerator &accelerator)
 544             {
 545                 m_file << name << "=";
 546
 547                 const char *key = gtk_accelerator_name(accelerator.key, accelerator.modifiers);
 548                 m_file << key;
 549                 m_file << "\n";
 550             }
 551         } visitor(file);
 552         GlobalShortcuts_foreach(visitor);
 553     }
 554 }
 555
 556 const char *stringrange_find(const char *first, const char *last, char c)
 557 {
 558     const char *p = strchr(first, '+');
 559     if (p == 0) {
 560         return last;
 561     }
 562     return p;
 563 }
 564
 565 class ReadCommandMap : public CommandVisitor {
 566     const char *m_filename;
 567     std::size_t m_count;
 568 public:
 569     ReadCommandMap(const char *filename) : m_filename(filename), m_count(0)
 570     {
 571     }
 572
 573     void visit(const char *name, Accelerator &accelerator)
 574     {
 575         char value[1024];
 576         if (read_var(m_filename, "Commands", name, value)) {
 577             if (string_empty(value)) {
 578                 accelerator.key = 0;
 579                 accelerator.modifiers = (GdkModifierType) 0;
 580                 return;
 581             }
 582
 583             gtk_accelerator_parse(value, &accelerator.key, &accelerator.modifiers);
 584             accelerator = accelerator; // fix modifiers
 585
 586             if (accelerator.key != 0) {
 587                 ++m_count;
 588             } else {
 589                 globalOutputStream() << "WARNING: failed to parse user command " << makeQuoted(name) << ": unknown key "
 590                                      << makeQuoted(value) << "\n";
 591             }
 592         }
 593     }
 594
 595     std::size_t count() const
 596     {
 597         return m_count;
 598     }
 599 };
 600
 601 void LoadCommandMap(const char *path)
 602 {
 603     StringOutputStream strINI(256);
 604     strINI << path << "shortcuts.ini";
 605
 606     FILE *f = fopen(strINI.c_str(), "r");
 607     if (f != 0) {
 608         fclose(f);
 609         globalOutputStream() << "loading custom shortcuts list from " << makeQuoted(strINI.c_str()) << "\n";
 610
 611         Version version = version_parse(COMMANDS_VERSION);
 612         Version dataVersion = {0, 0};
 613
 614         {
 615             char value[1024];
 616             if (read_var(strINI.c_str(), "Version", "number", value)) {
 617                 dataVersion = version_parse(value);
 618             }
 619         }
 620
 621         if (version_compatible(version, dataVersion)) {
 622             globalOutputStream() << "commands import: data version " << dataVersion
 623                                  << " is compatible with code version " << version << "\n";
 624             ReadCommandMap visitor(strINI.c_str());
 625             GlobalShortcuts_foreach(visitor);
 626             globalOutputStream() << "parsed " << Unsigned(visitor.count()) << " custom shortcuts\n";
 627         } else {
 628             globalOutputStream() << "commands import: data version " << dataVersion
 629                                  << " is not compatible with code version " << version << "\n";
 630         }
 631     } else {
 632         globalOutputStream() << "failed to load custom shortcuts from " << makeQuoted(strINI.c_str()) << "\n";
 633     }
 634 }