3015414323cfb9b79404d3a0fc261aea85affe59
[xonotic/netradiant.git] / 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
31 typedef std::pair<Accelerator, bool> ShortcutValue; // accelerator, isRegistered
32 typedef std::map<CopiedString, ShortcutValue> Shortcuts;
33
34 void Shortcuts_foreach(Shortcuts& shortcuts, CommandVisitor& visitor)
35 {
36   for(Shortcuts::iterator i = shortcuts.begin(); i != shortcuts.end(); ++i)
37   {
38     visitor.visit((*i).first.c_str(), (*i).second.first);
39   }
40 }
41
42 Shortcuts g_shortcuts;
43
44 const Accelerator& GlobalShortcuts_insert(const char* name, const Accelerator& accelerator)
45 {
46   return (*g_shortcuts.insert(Shortcuts::value_type(name, ShortcutValue(accelerator, false))).first).second.first;
47 }
48
49 void GlobalShortcuts_foreach(CommandVisitor& visitor)
50 {
51   Shortcuts_foreach(g_shortcuts, visitor);
52 }
53
54 void GlobalShortcuts_register(const char* name)
55 {
56   Shortcuts::iterator i = g_shortcuts.find(name);
57   if(i != g_shortcuts.end())
58   {
59     (*i).second.second = true;
60   }
61 }
62
63 void GlobalShortcuts_reportUnregistered()
64 {
65   for(Shortcuts::iterator i = g_shortcuts.begin(); i != g_shortcuts.end(); ++i)
66   {
67     if((*i).second.first.key != 0 && !(*i).second.second)
68     {
69       globalOutputStream() << "shortcut not registered: " << (*i).first.c_str() << "\n";
70     }
71   }
72 }
73
74 typedef std::map<CopiedString, Command> Commands;
75
76 Commands g_commands;
77
78 void GlobalCommands_insert(const char* name, const Callback& callback, const Accelerator& accelerator)
79 {
80   bool added = g_commands.insert(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& callback, const BoolExportCallback& exportCallback, const Accelerator& accelerator)
97 {
98   bool added = g_toggles.insert(Toggles::value_type(name, Toggle(callback, GlobalShortcuts_insert(name, accelerator), exportCallback))).second;
99   ASSERT_MESSAGE(added, "toggle already registered: " << makeQuoted(name));
100 }
101 const Toggle& GlobalToggles_find(const char* name)
102 {
103   Toggles::iterator i = g_toggles.find(name);
104   ASSERT_MESSAGE(i != g_toggles.end(), "failed to lookup toggle " << makeQuoted(name));
105   return (*i).second;
106 }
107
108 typedef std::map<CopiedString, KeyEvent> KeyEvents;
109
110
111 KeyEvents g_keyEvents;
112
113 void GlobalKeyEvents_insert(const char* name, const Accelerator& accelerator, const Callback& keyDown, const Callback& keyUp)
114 {
115   bool added = g_keyEvents.insert(KeyEvents::value_type(name, KeyEvent(GlobalShortcuts_insert(name, accelerator), keyDown, keyUp))).second;
116   ASSERT_MESSAGE(added, "command already registered: " << makeQuoted(name));
117 }
118 const KeyEvent& GlobalKeyEvents_find(const char* name)
119 {
120   KeyEvents::iterator i = g_keyEvents.find(name);
121   ASSERT_MESSAGE(i != g_keyEvents.end(), "failed to lookup keyEvent " << makeQuoted(name));
122   return (*i).second;
123 }
124
125
126
127
128 #include <gdk/gdkkeysyms.h>
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 struct SKeyInfo
143 {
144   const char* m_strName;
145   unsigned int m_nVKKey;
146 };
147
148 SKeyInfo g_Keys[] =
149 {
150   {"Space", GDK_space},
151   {"Backspace", GDK_BackSpace},
152   {"Escape", GDK_Escape},
153   {"End", GDK_End},
154   {"Insert", GDK_Insert},
155   {"Delete", GDK_Delete},
156   {"PageUp", GDK_Prior},
157   {"PageDown", GDK_Next},
158   {"Up", GDK_Up},
159   {"Down", GDK_Down},
160   {"Left", GDK_Left},
161   {"Right", GDK_Right},
162   {"F1", GDK_F1},
163   {"F2", GDK_F2},
164   {"F3", GDK_F3},
165   {"F4", GDK_F4},
166   {"F5", GDK_F5},
167   {"F6", GDK_F6},
168   {"F7", GDK_F7},
169   {"F8", GDK_F8},
170   {"F9", GDK_F9},
171   {"F10", GDK_F10},
172   {"F11", GDK_F11},
173   {"F12", GDK_F12},
174   {"Tab", GDK_Tab},
175   {"Return", GDK_Return},                           
176   {"Comma", GDK_comma},
177   {"Period", GDK_period},
178   {"Plus", GDK_KP_Add},
179   {"Multiply", GDK_multiply},
180   {"Minus", GDK_KP_Subtract},
181   {"NumPad0", GDK_KP_0},
182   {"NumPad1", GDK_KP_1},
183   {"NumPad2", GDK_KP_2},
184   {"NumPad3", GDK_KP_3},
185   {"NumPad4", GDK_KP_4},
186   {"NumPad5", GDK_KP_5},
187   {"NumPad6", GDK_KP_6},
188   {"NumPad7", GDK_KP_7},
189   {"NumPad8", GDK_KP_8},
190   {"NumPad9", GDK_KP_9},
191   {"[", 219},
192   {"]", 221},
193   {"\\", 220},
194   {"Home", GDK_Home}
195 };
196
197 int g_nKeyCount = sizeof(g_Keys) / sizeof(SKeyInfo);
198
199 const char* global_keys_find(unsigned int key)
200 {
201   for(int i = 0; i < g_nKeyCount; ++i)
202   {
203     if(g_Keys[i].m_nVKKey == key)
204     {
205       return g_Keys[i].m_strName;
206     }
207   }
208   return "";
209 }
210
211 unsigned int global_keys_find(const char* name)
212 {
213   for(int i = 0; i < g_nKeyCount; ++i)
214   {
215     if(string_equal_nocase(g_Keys[i].m_strName, name))
216     {
217       return g_Keys[i].m_nVKKey;
218     }
219   }
220   return 0;
221 }
222
223
224 #include <gtk/gtkbox.h>
225 #include <gtk/gtkliststore.h>
226 #include <gtk/gtktreemodel.h>
227 #include <gtk/gtktreeview.h>
228 #include <gtk/gtkcellrenderertext.h>
229
230 #include "gtkutil/dialog.h"
231 #include "mainframe.h"
232
233 #include "stream/textfilestream.h"
234 #include "stream/stringstream.h"
235
236
237 struct command_list_dialog_t : public ModalDialog
238 {
239   command_list_dialog_t()
240     : m_close_button(*this, eIDCANCEL)
241   {
242   }
243   ModalDialogButton m_close_button;
244 };
245
246 template<typename TextOutputStreamType>
247 TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const Accelerator& accelerator)
248 {
249   if(accelerator.modifiers & GDK_SHIFT_MASK)
250   {
251     ostream << "Shift + ";
252   }
253   if(accelerator.modifiers & GDK_MOD1_MASK)
254   {
255     ostream << "Alt + ";
256   }
257   if(accelerator.modifiers & GDK_CONTROL_MASK)
258   {
259     ostream << "Control + ";
260   }
261
262   const char* keyName = global_keys_find(accelerator.key);
263   if(!string_empty(keyName))
264   {
265     ostream << keyName;
266   }
267   else
268   {
269     ostream << static_cast<char>(accelerator.key);
270   }
271
272   return ostream;
273 }
274
275 void DoCommandListDlg()
276 {
277   command_list_dialog_t dialog;
278
279   GtkWindow* window = create_modal_dialog_window(MainFrame_getWindow(), "Mapped Commands", dialog, -1, 400);
280
281   GtkAccelGroup* accel = gtk_accel_group_new();
282   gtk_window_add_accel_group(window, accel);
283
284   GtkHBox* hbox = create_dialog_hbox(4, 4);
285   gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(hbox));
286
287   {
288     GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
289     gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(scr), TRUE, TRUE, 0);
290
291     {
292       GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
293
294       GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
295
296       {
297         GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
298         GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Command", renderer, "text", 0, 0);
299         gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
300       }
301
302       {
303         GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
304         GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Key", renderer, "text", 1, 0);
305         gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
306       }
307
308       gtk_widget_show(view);
309       gtk_container_add(GTK_CONTAINER (scr), view);
310
311       {
312         // Initialize dialog
313         StringOutputStream path(256);
314         path << SettingsPath_get() << "commandlist.txt";
315         globalOutputStream() << "Writing the command list to " << path.c_str() << "\n";
316         class BuildCommandList : public CommandVisitor
317         {
318           TextFileOutputStream m_commandList;
319           GtkListStore* m_store;
320         public:
321           BuildCommandList(const char* filename, GtkListStore* store) : m_commandList(filename), m_store(store)
322           {
323           }
324           void visit(const char* name, Accelerator& accelerator)
325           {
326             StringOutputStream modifiers;
327             modifiers << accelerator;
328
329             {
330               GtkTreeIter iter;
331               gtk_list_store_append(m_store, &iter);
332               gtk_list_store_set(m_store, &iter, 0, name, 1, modifiers.c_str(), -1);
333             }
334  
335             if(!m_commandList.failed())
336             {
337               m_commandList << makeLeftJustified(name, 25) << " " << modifiers.c_str() << '\n';
338             }
339           }
340         } visitor(path.c_str(), store);
341
342         GlobalShortcuts_foreach(visitor);
343       }
344     
345       g_object_unref(G_OBJECT(store));
346     }
347   }
348
349   GtkVBox* vbox = create_dialog_vbox(4);
350   gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 0);
351   {
352     GtkButton* button = create_modal_dialog_button("Close", dialog.m_close_button);
353     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
354     widget_make_default(GTK_WIDGET(button));
355     gtk_widget_grab_focus(GTK_WIDGET(button));
356     gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
357     gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
358   }
359
360   modal_dialog_show(window, dialog);
361   gtk_widget_destroy(GTK_WIDGET(window));
362 }
363
364 #include "profile/profile.h"
365
366 const char* const COMMANDS_VERSION = "1.0";
367
368 void SaveCommandMap(const char* path)
369 {
370   StringOutputStream strINI(256);
371   strINI << path << "shortcuts.ini";
372
373   TextFileOutputStream file(strINI.c_str());
374   if(!file.failed())
375   {
376     file << "[Version]\n";
377     file << "number=" << COMMANDS_VERSION << "\n";
378     file << "\n";
379     file << "[Commands]\n";
380     class WriteCommandMap : public CommandVisitor
381     {
382       TextFileOutputStream& m_file;
383     public:
384       WriteCommandMap(TextFileOutputStream& file) : m_file(file)
385       {
386       }
387       void visit(const char* name, Accelerator& accelerator)
388       {
389         m_file << name << "=";
390
391         const char* key = global_keys_find(accelerator.key);
392         if(!string_empty(key))
393         {
394           m_file << key;
395         }
396         else if(accelerator.key != 0)
397         {
398           m_file << ascii_for_keyval(accelerator.key);
399         }
400
401         if(accelerator.modifiers & GDK_MOD1_MASK)
402         {
403           m_file << "+Alt";
404         }
405         if(accelerator.modifiers & GDK_CONTROL_MASK)
406         {
407           m_file << "+Ctrl";
408         }
409         if(accelerator.modifiers & GDK_SHIFT_MASK)
410         {
411           m_file << "+Shift";
412         }
413
414         m_file << "\n";
415       }
416     } visitor(file);
417     GlobalShortcuts_foreach(visitor);
418   }
419 }
420
421 const char* stringrange_find(const char* first, const char* last, char c)
422 {
423   const char* p = strchr(first, '+');
424   if(p == 0)
425   {
426     return last;
427   }
428   return p;
429 }
430
431 class ReadCommandMap : public CommandVisitor
432 {
433   const char* m_filename;
434   std::size_t m_count;
435 public:
436   ReadCommandMap(const char* filename) : m_filename(filename), m_count(0)
437   {
438   }
439   void visit(const char* name, Accelerator& accelerator)
440   {
441     char value[1024];
442     if (read_var(m_filename, "Commands", name, value ))
443     {
444       if(string_empty(value))
445       {
446         accelerator.key = 0;
447         accelerator.modifiers = (GdkModifierType)0;
448         return;
449       }
450       int modifiers = 0;
451       const char* last = value + string_length(value);
452       const char* keyEnd = stringrange_find(value, last, '+');
453       for(const char* modifier = keyEnd; modifier != last;)
454       {
455         const char* next = stringrange_find(modifier + 1, last, '+');
456         if(next - modifier == 4
457           && string_equal_nocase_n(modifier, "+alt", 4))
458         {
459           modifiers |= GDK_MOD1_MASK;
460         }
461         else if(next - modifier == 5
462           && string_equal_nocase_n(modifier, "+ctrl", 5) != 0)
463         {
464           modifiers |= GDK_CONTROL_MASK;
465         }
466         else if(next - modifier == 6
467           && string_equal_nocase_n(modifier, "+shift", 6) != 0)
468         {
469           modifiers |= GDK_SHIFT_MASK;
470         }
471         else
472         {
473           globalOutputStream() << "WARNING: failed to parse user command " << makeQuoted(value) << ": unknown modifier " << makeQuoted(StringRange(modifier, next)) << "\n";
474         }
475         modifier = next;
476       }
477       accelerator.modifiers = (GdkModifierType)modifiers;
478
479
480       // strBuff has been cleaned of it's modifiers .. switch between a regular key and a virtual one
481       // based on length
482       if(keyEnd - value == 1) // most often case.. deal with first
483       {
484         accelerator.key = std::toupper(value[0]);
485         ++m_count;
486       }
487       else // special key
488       {
489         CopiedString keyName(StringRange(value, keyEnd));
490         accelerator.key = global_keys_find(keyName.c_str());
491         if(accelerator.key != 0)
492         {
493           ++m_count;
494         }
495         else
496         {
497           globalOutputStream() << "WARNING: failed to parse user command " << makeQuoted(value) << ": unknown key " << makeQuoted(keyName.c_str()) << "\n";
498         }
499       }
500     }
501   }
502   std::size_t count() const
503   {
504     return m_count;
505   }
506 };
507     
508 void LoadCommandMap(const char* path)
509 {
510   StringOutputStream strINI(256);
511   strINI << path << "shortcuts.ini";
512
513   FILE* f = fopen (strINI.c_str(), "r");
514   if (f != 0)
515   {
516     fclose(f);
517     globalOutputStream() << "loading custom shortcuts list from " << makeQuoted(strINI.c_str()) << "\n";
518
519     Version version = version_parse(COMMANDS_VERSION);
520     Version dataVersion = { 0, 0 };
521
522     {
523       char value[1024];
524       if(read_var(strINI.c_str(), "Version", "number", value))
525       {
526         dataVersion = version_parse(value);
527       }
528     }
529
530     if(version_compatible(version, dataVersion))
531     {
532       globalOutputStream() << "commands import: data version " << dataVersion << " is compatible with code version " << version << "\n";
533       ReadCommandMap visitor(strINI.c_str());
534       GlobalShortcuts_foreach(visitor);
535       globalOutputStream() << "parsed " << Unsigned(visitor.count()) << " custom shortcuts\n";
536     }
537     else
538     {
539       globalOutputStream() << "commands import: data version " << dataVersion << " is not compatible with code version " << version << "\n";
540     }
541   }
542   else
543   {
544     globalOutputStream() << "failed to load custom shortcuts from " << makeQuoted(strINI.c_str()) << "\n";
545   }
546 }