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