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