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 "debugging/debugging.h"
  25 #include "warnings.h"
  26
  27 #include <map>
  28 #include "string/string.h"
  29 #include "versionlib.h"
  30 #include "gtkutil/accelerator.h"
  31
  32 typedef std::pair<Accelerator, bool> ShortcutValue; // accelerator, isRegistered
  33 typedef std::map<CopiedString, ShortcutValue> Shortcuts;
  34
  35 void Shortcuts_foreach(Shortcuts& shortcuts, CommandVisitor& visitor)
  36 {
  37   for(Shortcuts::iterator i = shortcuts.begin(); i != shortcuts.end(); ++i)
  38   {
  39     visitor.visit((*i).first.c_str(), (*i).second.first);
  40   }
  41 }
  42
  43 Shortcuts g_shortcuts;
  44
  45 const Accelerator& GlobalShortcuts_insert(const char* name, const Accelerator& accelerator)
  46 {
  47   return (*g_shortcuts.insert(Shortcuts::value_type(name, ShortcutValue(accelerator, false))).first).second.first;
  48 }
  49
  50 void GlobalShortcuts_foreach(CommandVisitor& visitor)
  51 {
  52   Shortcuts_foreach(g_shortcuts, visitor);
  53 }
  54
  55 void GlobalShortcuts_register(const char* name)
  56 {
  57   Shortcuts::iterator i = g_shortcuts.find(name);
  58   if(i != g_shortcuts.end())
  59   {
  60     (*i).second.second = true;
  61   }
  62 }
  63
  64 void GlobalShortcuts_reportUnregistered()
  65 {
  66   for(Shortcuts::iterator i = g_shortcuts.begin(); i != g_shortcuts.end(); ++i)
  67   {
  68     if((*i).second.first.key != 0 && !(*i).second.second)
  69     {
  70       globalOutputStream() << "shortcut not registered: " << (*i).first.c_str() << "\n";
  71     }
  72   }
  73 }
  74
  75 typedef std::map<CopiedString, Command> Commands;
  76
  77 Commands g_commands;
  78
  79 void GlobalCommands_insert(const char* name, const Callback& callback, const Accelerator& accelerator)
  80 {
  81   bool added = g_commands.insert(Commands::value_type(name, Command(callback, GlobalShortcuts_insert(name, accelerator)))).second;
  82   ASSERT_MESSAGE(added, "command already registered: " << makeQuoted(name));
  83 }
  84
  85 const Command& GlobalCommands_find(const char* command)
  86 {
  87   Commands::iterator i = g_commands.find(command);
  88   ASSERT_MESSAGE(i != g_commands.end(), "failed to lookup command " << makeQuoted(command));
  89   return (*i).second;
  90 }
  91
  92 typedef std::map<CopiedString, Toggle> Toggles;
  93
  94
  95 Toggles g_toggles;
  96
  97 void GlobalToggles_insert(const char* name, const Callback& callback, const BoolExportCallback& exportCallback, const Accelerator& accelerator)
  98 {
  99   bool added = g_toggles.insert(Toggles::value_type(name, Toggle(callback, GlobalShortcuts_insert(name, accelerator), exportCallback))).second;
 100   ASSERT_MESSAGE(added, "toggle already registered: " << makeQuoted(name));
 101 }
 102 const Toggle& GlobalToggles_find(const char* name)
 103 {
 104   Toggles::iterator i = g_toggles.find(name);
 105   ASSERT_MESSAGE(i != g_toggles.end(), "failed to lookup toggle " << makeQuoted(name));
 106   return (*i).second;
 107 }
 108
 109 typedef std::map<CopiedString, KeyEvent> KeyEvents;
 110
 111
 112 KeyEvents g_keyEvents;
 113
 114 void GlobalKeyEvents_insert(const char* name, const Accelerator& accelerator, const Callback& keyDown, const Callback& keyUp)
 115 {
 116   bool added = g_keyEvents.insert(KeyEvents::value_type(name, KeyEvent(GlobalShortcuts_insert(name, accelerator), keyDown, keyUp))).second;
 117   ASSERT_MESSAGE(added, "command already registered: " << makeQuoted(name));
 118 }
 119 const KeyEvent& GlobalKeyEvents_find(const char* name)
 120 {
 121   KeyEvents::iterator i = g_keyEvents.find(name);
 122   ASSERT_MESSAGE(i != g_keyEvents.end(), "failed to lookup keyEvent " << makeQuoted(name));
 123   return (*i).second;
 124 }
 125
 126
 127
 128
 129 #include <ctype.h>
 130
 131 #ifdef __APPLE__
 132 #define __toascii(c)    ((c) & 0x7f)
 133 #endif
 134
 135 inline char ascii_for_keyval(int keyval)
 136 {
 137   return __toascii(keyval);
 138 }
 139
 140
 141
 142 #include <gtk/gtkbox.h>
 143 #include <gtk/gtkliststore.h>
 144 #include <gtk/gtktreemodel.h>
 145 #include <gtk/gtktreeview.h>
 146 #include <gtk/gtkcellrenderertext.h>
 147
 148 #include "gtkutil/dialog.h"
 149 #include "mainframe.h"
 150
 151 #include "stream/textfilestream.h"
 152 #include "stream/stringstream.h"
 153
 154
 155 struct command_list_dialog_t : public ModalDialog
 156 {
 157   command_list_dialog_t()
 158     : m_close_button(*this, eIDCANCEL)
 159   {
 160   }
 161   ModalDialogButton m_close_button;
 162 };
 163
 164 void DoCommandListDlg()
 165 {
 166   command_list_dialog_t dialog;
 167
 168   GtkWindow* window = create_modal_dialog_window(MainFrame_getWindow(), "Mapped Commands", dialog, -1, 400);
 169
 170   GtkAccelGroup* accel = gtk_accel_group_new();
 171   gtk_window_add_accel_group(window, accel);
 172
 173   GtkHBox* hbox = create_dialog_hbox(4, 4);
 174   gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(hbox));
 175
 176   {
 177     GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 178     gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(scr), TRUE, TRUE, 0);
 179
 180     {
 181       GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
 182
 183       GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 184
 185       {
 186         GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
 187         GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Command", renderer, "text", 0, 0);
 188         gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
 189       }
 190
 191       {
 192         GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
 193         GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Key", renderer, "text", 1, 0);
 194         gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
 195       }
 196
 197       gtk_widget_show(view);
 198       gtk_container_add(GTK_CONTAINER (scr), view);
 199
 200       {
 201         // Initialize dialog
 202         StringOutputStream path(256);
 203         path << SettingsPath_get() << "commandlist.txt";
 204         globalOutputStream() << "Writing the command list to " << path.c_str() << "\n";
 205         class BuildCommandList : public CommandVisitor
 206         {
 207           TextFileOutputStream m_commandList;
 208           GtkListStore* m_store;
 209         public:
 210           BuildCommandList(const char* filename, GtkListStore* store) : m_commandList(filename), m_store(store)
 211           {
 212           }
 213           void visit(const char* name, Accelerator& accelerator)
 214           {
 215             StringOutputStream modifiers;
 216             modifiers << accelerator;
 217
 218             {
 219               GtkTreeIter iter;
 220               gtk_list_store_append(m_store, &iter);
 221               gtk_list_store_set(m_store, &iter, 0, name, 1, modifiers.c_str(), -1);
 222             }
 223
 224             if(!m_commandList.failed())
 225             {
 226               m_commandList << makeLeftJustified(name, 25) << " " << modifiers.c_str() << '\n';
 227             }
 228           }
 229         } visitor(path.c_str(), store);
 230
 231         GlobalShortcuts_foreach(visitor);
 232       }
 233
 234       g_object_unref(G_OBJECT(store));
 235     }
 236   }
 237
 238   GtkVBox* vbox = create_dialog_vbox(4);
 239   gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 0);
 240   {
 241     GtkButton* button = create_modal_dialog_button("Close", dialog.m_close_button);
 242     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
 243     widget_make_default(GTK_WIDGET(button));
 244     gtk_widget_grab_focus(GTK_WIDGET(button));
 245     gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
 246     gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
 247   }
 248
 249   modal_dialog_show(window, dialog);
 250   gtk_widget_destroy(GTK_WIDGET(window));
 251 }
 252
 253 #include "profile/profile.h"
 254
 255 const char* const COMMANDS_VERSION = "1.0";
 256
 257 void SaveCommandMap(const char* path)
 258 {
 259   StringOutputStream strINI(256);
 260   strINI << path << "shortcuts.ini";
 261
 262   TextFileOutputStream file(strINI.c_str());
 263   if(!file.failed())
 264   {
 265     file << "[Version]\n";
 266     file << "number=" << COMMANDS_VERSION << "\n";
 267     file << "\n";
 268     file << "[Commands]\n";
 269     class WriteCommandMap : public CommandVisitor
 270     {
 271       TextFileOutputStream& m_file;
 272     public:
 273       WriteCommandMap(TextFileOutputStream& file) : m_file(file)
 274       {
 275       }
 276       void visit(const char* name, Accelerator& accelerator)
 277       {
 278         m_file << name << "=";
 279
 280         const char* key = global_keys_find(accelerator.key);
 281         if(!string_empty(key))
 282         {
 283           m_file << key;
 284         }
 285         else if(accelerator.key != 0)
 286         {
 287           m_file << ascii_for_keyval(accelerator.key);
 288         }
 289
 290         if(accelerator.modifiers & GDK_MOD1_MASK)
 291         {
 292           m_file << "+Alt";
 293         }
 294         if(accelerator.modifiers & GDK_CONTROL_MASK)
 295         {
 296           m_file << "+Ctrl";
 297         }
 298         if(accelerator.modifiers & GDK_SHIFT_MASK)
 299         {
 300           m_file << "+Shift";
 301         }
 302
 303         m_file << "\n";
 304       }
 305     } visitor(file);
 306     GlobalShortcuts_foreach(visitor);
 307   }
 308 }
 309
 310 const char* stringrange_find(const char* first, const char* last, char c)
 311 {
 312   const char* p = strchr(first, '+');
 313   if(p == 0)
 314   {
 315     return last;
 316   }
 317   return p;
 318 }
 319
 320 class ReadCommandMap : public CommandVisitor
 321 {
 322   const char* m_filename;
 323   std::size_t m_count;
 324 public:
 325   ReadCommandMap(const char* filename) : m_filename(filename), m_count(0)
 326   {
 327   }
 328   void visit(const char* name, Accelerator& accelerator)
 329   {
 330     char value[1024];
 331     if (read_var(m_filename, "Commands", name, value ))
 332     {
 333       if(string_empty(value))
 334       {
 335         accelerator.key = 0;
 336         accelerator.modifiers = (GdkModifierType)0;
 337         return;
 338       }
 339       int modifiers = 0;
 340       const char* last = value + string_length(value);
 341       const char* keyEnd = stringrange_find(value, last, '+');
 342       for(const char* modifier = keyEnd; modifier != last;)
 343       {
 344         const char* next = stringrange_find(modifier + 1, last, '+');
 345         if(next - modifier == 4
 346           && string_equal_nocase_n(modifier, "+alt", 4))
 347         {
 348           modifiers |= GDK_MOD1_MASK;
 349         }
 350         else if(next - modifier == 5
 351           && string_equal_nocase_n(modifier, "+ctrl", 5) != 0)
 352         {
 353           modifiers |= GDK_CONTROL_MASK;
 354         }
 355         else if(next - modifier == 6
 356           && string_equal_nocase_n(modifier, "+shift", 6) != 0)
 357         {
 358           modifiers |= GDK_SHIFT_MASK;
 359         }
 360         else
 361         {
 362           globalOutputStream() << "WARNING: failed to parse user command " << makeQuoted(value) << ": unknown modifier " << makeQuoted(StringRange(modifier, next)) << "\n";
 363         }
 364         modifier = next;
 365       }
 366       accelerator.modifiers = (GdkModifierType)modifiers;
 367
 368
 369       // strBuff has been cleaned of it's modifiers .. switch between a regular key and a virtual one
 370       // based on length
 371       if(keyEnd - value == 1) // most often case.. deal with first
 372       {
 373         accelerator.key = std::toupper(value[0]);
 374         ++m_count;
 375       }
 376       else // special key
 377       {
 378         CopiedString keyName(StringRange(value, keyEnd));
 379         accelerator.key = global_keys_find(keyName.c_str());
 380         if(accelerator.key != 0)
 381         {
 382           ++m_count;
 383         }
 384         else
 385         {
 386           globalOutputStream() << "WARNING: failed to parse user command " << makeQuoted(value) << ": unknown key " << makeQuoted(keyName.c_str()) << "\n";
 387         }
 388       }
 389     }
 390   }
 391   std::size_t count() const
 392   {
 393     return m_count;
 394   }
 395 };
 396
 397 void LoadCommandMap(const char* path)
 398 {
 399   StringOutputStream strINI(256);
 400   strINI << path << "shortcuts.ini";
 401
 402   FILE* f = fopen (strINI.c_str(), "r");
 403   if (f != 0)
 404   {
 405     fclose(f);
 406     globalOutputStream() << "loading custom shortcuts list from " << makeQuoted(strINI.c_str()) << "\n";
 407
 408     Version version = version_parse(COMMANDS_VERSION);
 409     Version dataVersion = { 0, 0 };
 410
 411     {
 412       char value[1024];
 413       if(read_var(strINI.c_str(), "Version", "number", value))
 414       {
 415         dataVersion = version_parse(value);
 416       }
 417     }
 418
 419     if(version_compatible(version, dataVersion))
 420     {
 421       globalOutputStream() << "commands import: data version " << dataVersion << " is compatible with code version " << version << "\n";
 422       ReadCommandMap visitor(strINI.c_str());
 423       GlobalShortcuts_foreach(visitor);
 424       globalOutputStream() << "parsed " << Unsigned(visitor.count()) << " custom shortcuts\n";
 425     }
 426     else
 427     {
 428       globalOutputStream() << "commands import: data version " << dataVersion << " is not compatible with code version " << version << "\n";
 429     }
 430   }
 431   else
 432   {
 433     globalOutputStream() << "failed to load custom shortcuts from " << makeQuoted(strINI.c_str()) << "\n";
 434   }
 435 }