src/guiKeyChangeMenu.cpp

   1 /*
   2  Minetest-c55
   3  Copyright (C) 2010-11 celeron55, Perttu Ahola <celeron55@gmail.com>
   4  Copyright (C) 2011 Ciaran Gultnieks <ciaran@ciarang.com>
   5  Copyright (C) 2011 teddydestodes <derkomtur@schattengang.net>
   6
   7  This program 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  This program 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 along
  18  with this program; if not, write to the Free Software Foundation, Inc.,
  19  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "guiKeyChangeMenu.h"
  23 #include "debug.h"
  24 #include "serialization.h"
  25 #include "keycode.h"
  26 #include "main.h"
  27 #include <string>
  28
  29 static const char *KeyNamesLang[] =
  30         { "-", N_("Left Button"), N_("Right Button"), N_("Cancel"), N_("Middle Button"), N_("X Button 1"),
  31                         N_("X Button 2"), "-", N_("Back"), N_("Tab"), "-", "-", N_("Clear"), N_("Return"), "-",
  32                         "-", N_("Shift"), N_("Control"), N_("Menu"), N_("Pause"), N_("Capital"), N_("Kana"), "-",
  33                         N_("Junja"), N_("Final"), N_("Kanji"), "-", N_("Escape"), N_("Convert"), N_("Nonconvert"),
  34                         N_("Accept"), N_("Mode Change"), N_("Space"), N_("Priot"), N_("Next"), N_("End"), N_("Home"),
  35                         N_("Left"), N_("Up"), N_("Right"), N_("Down"), N_("Select"), N_("Print"), N_("Execute"),
  36                         N_("Snapshot"), N_("Insert"), N_("Delete"), N_("Help"), "0", "1", "2", "3", "4", "5",
  37                         "6", "7", "8", "9", "-", "-", "-", "-", "-", "-", "-", "A", "B", "C",
  38                         "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q",
  39                         "R", "S", "T", "U", "V", "W", "X", "Y", "Z", N_("Left Windows"),
  40                         N_("Right Windows"), N_("Apps"), "-", N_("Sleep"), N_("Numpad 0"), N_("Numpad 1"),
  41                         N_("Numpad 2"), N_("Numpad 3"), N_("Numpad 4"), N_("Numpad 5"), N_("Numpad 6"), N_("Numpad 7"),
  42                         N_("Numpad 8"), N_("Numpad 9"), N_("Numpad *"), N_("Numpad +"), N_("Numpad /"), N_("Numpad -"),
  43                         "Numpad .", "Numpad /", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8",
  44                         "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18",
  45                         "F19", "F20", "F21", "F22", "F23", "F24", "-", "-", "-", "-", "-", "-",
  46                         "-", "-", N_("Num Lock"), N_("Scroll Lock"), "-", "-", "-", "-", "-", "-", "-",
  47                         "-", "-", "-", "-", "-", "-", "-", N_("Left Shift"), N_("Right Shight"),
  48                         N_("Left Control"), N_("Right Control"), N_("Left Menu"), N_("Right Menu"), "-", "-",
  49                         "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-",
  50                         "-", "-", "-", "-", "-", N_("Plus"), N_("Comma"), N_("Minus"), N_("Period"), "-", "-",
  51                         "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-",
  52                         "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-",
  53                         "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-",
  54                         "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", N_("Attn"), N_("CrSel"),
  55                         N_("ExSel"), N_("Erase OEF"), N_("Play"), N_("Zoom"), N_("PA1"), N_("OEM Clear"), "-" };
  56
  57 GUIKeyChangeMenu::GUIKeyChangeMenu(gui::IGUIEnvironment* env,
  58                 gui::IGUIElement* parent, s32 id, IMenuManager *menumgr) :
  59         GUIModalMenu(env, parent, id, menumgr)
  60 {
  61         activeKey = -1;
  62         init_keys();
  63 }
  64
  65 GUIKeyChangeMenu::~GUIKeyChangeMenu()
  66 {
  67         removeChildren();
  68 }
  69
  70 void GUIKeyChangeMenu::removeChildren()
  71 {
  72         const core::list<gui::IGUIElement*> &children = getChildren();
  73         core::list<gui::IGUIElement*> children_copy;
  74         for (core::list<gui::IGUIElement*>::ConstIterator i = children.begin(); i
  75                         != children.end(); i++)
  76         {
  77                 children_copy.push_back(*i);
  78         }
  79         for (core::list<gui::IGUIElement*>::Iterator i = children_copy.begin(); i
  80                         != children_copy.end(); i++)
  81         {
  82                 (*i)->remove();
  83         }
  84 }
  85
  86 void GUIKeyChangeMenu::regenerateGui(v2u32 screensize)
  87 {
  88         /*
  89          Remove stuff
  90          */
  91         removeChildren();
  92
  93         /*
  94          Calculate new sizes and positions
  95          */
  96
  97         v2s32 size(620, 430);
  98
  99         core::rect < s32 > rect(screensize.X / 2 - size.X / 2,
 100                         screensize.Y / 2 - size.Y / 2, screensize.X / 2 + size.X / 2,
 101                         screensize.Y / 2 + size.Y / 2);
 102
 103         DesiredRect = rect;
 104         recalculateAbsolutePosition(false);
 105
 106         v2s32 topleft(0, 0);
 107         changeCtype("");
 108         {
 109                 core::rect < s32 > rect(0, 0, 125, 20);
 110                 rect += topleft + v2s32(25, 3);
 111                 //gui::IGUIStaticText *t =
 112                 Environment->addStaticText(wgettext("KEYBINDINGS"),
 113                                 rect, false, true, this, -1);
 114                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 115         }
 116         v2s32 offset(25, 40);
 117         // buttons
 118
 119         {
 120                 core::rect < s32 > rect(0, 0, 100, 20);
 121                 rect += topleft + v2s32(offset.X, offset.Y);
 122                 Environment->addStaticText(wgettext("Forward"),
 123                                 rect, false, true, this, -1);
 124                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 125         }
 126
 127         {
 128                 core::rect < s32 > rect(0, 0, 100, 30);
 129                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 130                 this->forward = Environment->addButton(rect, this,
 131                                 GUI_ID_KEY_FORWARD_BUTTON,
 132                                 wgettext(KeyNamesLang[key_forward]));
 133         }
 134
 135         offset += v2s32(0, 25);
 136         {
 137                 core::rect < s32 > rect(0, 0, 100, 20);
 138                 rect += topleft + v2s32(offset.X, offset.Y);
 139                 Environment->addStaticText(wgettext("Backward"),
 140                                 rect, false, true, this, -1);
 141                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 142         }
 143
 144         {
 145                 core::rect < s32 > rect(0, 0, 100, 30);
 146                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 147                 this->backward = Environment->addButton(rect, this,
 148                                 GUI_ID_KEY_BACKWARD_BUTTON,
 149                                 wgettext(KeyNamesLang[key_backward]));
 150         }
 151         offset += v2s32(0, 25);
 152         {
 153                 core::rect < s32 > rect(0, 0, 100, 20);
 154                 rect += topleft + v2s32(offset.X, offset.Y);
 155                 Environment->addStaticText(wgettext("Left"),
 156                                 rect, false, true, this, -1);
 157                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 158         }
 159
 160         {
 161                 core::rect < s32 > rect(0, 0, 100, 30);
 162                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 163                 this->left = Environment->addButton(rect, this, GUI_ID_KEY_LEFT_BUTTON,
 164                                 wgettext(KeyNamesLang[key_left]));
 165         }
 166         offset += v2s32(0, 25);
 167         {
 168                 core::rect < s32 > rect(0, 0, 100, 20);
 169                 rect += topleft + v2s32(offset.X, offset.Y);
 170                 Environment->addStaticText(wgettext("Right"),
 171                                 rect, false, true, this, -1);
 172                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 173         }
 174
 175         {
 176                 core::rect < s32 > rect(0, 0, 100, 30);
 177                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 178                 this->right = Environment->addButton(rect, this,
 179                                 GUI_ID_KEY_RIGHT_BUTTON,
 180                                 wgettext(KeyNamesLang[key_right]));
 181         }
 182         offset += v2s32(0, 25);
 183         {
 184                 core::rect < s32 > rect(0, 0, 100, 20);
 185                 rect += topleft + v2s32(offset.X, offset.Y);
 186                 Environment->addStaticText(wgettext("Use"),
 187                                 rect, false, true, this, -1);
 188                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 189         }
 190
 191         {
 192                 core::rect < s32 > rect(0, 0, 100, 30);
 193                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 194                 this->use = Environment->addButton(rect, this, GUI_ID_KEY_USE_BUTTON,
 195                                 wgettext(KeyNamesLang[key_use]));
 196         }
 197         offset += v2s32(0, 25);
 198         {
 199                 core::rect < s32 > rect(0, 0, 100, 20);
 200                 rect += topleft + v2s32(offset.X, offset.Y);
 201                 Environment->addStaticText(wgettext("Sneak"),
 202                                 rect, false, true, this, -1);
 203                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 204         }
 205
 206         {
 207                 core::rect < s32 > rect(0, 0, 100, 30);
 208                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 209                 this->sneak = Environment->addButton(rect, this,
 210                                 GUI_ID_KEY_SNEAK_BUTTON,
 211                                 wgettext(KeyNamesLang[key_sneak]));
 212         }
 213         offset += v2s32(0, 25);
 214         {
 215                 core::rect < s32 > rect(0, 0, 100, 20);
 216                 rect += topleft + v2s32(offset.X, offset.Y);
 217                 Environment->addStaticText(wgettext("Jump"), rect, false, true, this, -1);
 218                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 219         }
 220
 221         {
 222                 core::rect < s32 > rect(0, 0, 100, 30);
 223                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 224                 this->jump = Environment->addButton(rect, this, GUI_ID_KEY_JUMP_BUTTON,
 225                                 wgettext(KeyNamesLang[key_jump]));
 226         }
 227
 228         offset += v2s32(0, 25);
 229         {
 230                 core::rect < s32 > rect(0, 0, 100, 20);
 231                 rect += topleft + v2s32(offset.X, offset.Y);
 232                 Environment->addStaticText(wgettext("Inventory"),
 233                                 rect, false, true, this, -1);
 234                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 235         }
 236
 237         {
 238                 core::rect < s32 > rect(0, 0, 100, 30);
 239                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 240                 this->inventory = Environment->addButton(rect, this,
 241                                 GUI_ID_KEY_INVENTORY_BUTTON,
 242                                 wgettext(KeyNamesLang[key_inventory]));
 243         }
 244         offset += v2s32(0, 25);
 245         {
 246                 core::rect < s32 > rect(0, 0, 100, 20);
 247                 rect += topleft + v2s32(offset.X, offset.Y);
 248                 Environment->addStaticText(wgettext("Chat"), rect, false, true, this, -1);
 249                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 250         }
 251
 252         {
 253                 core::rect < s32 > rect(0, 0, 100, 30);
 254                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 255                 this->chat = Environment->addButton(rect, this, GUI_ID_KEY_CHAT_BUTTON,
 256                                 wgettext(KeyNamesLang[key_chat]));
 257         }
 258
 259         //next col
 260         offset = v2s32(250, 40);
 261         {
 262                 core::rect < s32 > rect(0, 0, 100, 20);
 263                 rect += topleft + v2s32(offset.X, offset.Y);
 264                 Environment->addStaticText(wgettext("Toggle fly"),
 265                                 rect, false, true, this, -1);
 266                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 267         }
 268
 269         {
 270                 core::rect < s32 > rect(0, 0, 100, 30);
 271                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 272                 this->fly = Environment->addButton(rect, this, GUI_ID_KEY_FLY_BUTTON,
 273                                 wgettext(KeyNamesLang[key_fly]));
 274         }
 275         offset += v2s32(0, 25);
 276         {
 277                 core::rect < s32 > rect(0, 0, 100, 20);
 278                 rect += topleft + v2s32(offset.X, offset.Y);
 279                 Environment->addStaticText(wgettext("Toggle fast"),
 280                                 rect, false, true, this, -1);
 281                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 282         }
 283
 284         {
 285                 core::rect < s32 > rect(0, 0, 100, 30);
 286                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 287                 this->fast = Environment->addButton(rect, this, GUI_ID_KEY_FAST_BUTTON,
 288                                 wgettext(KeyNamesLang[key_fast]));
 289         }
 290         offset += v2s32(0, 25);
 291         {
 292                 core::rect < s32 > rect(0, 0, 100, 20);
 293                 rect += topleft + v2s32(offset.X, offset.Y);
 294                 Environment->addStaticText(wgettext("Range select"),
 295                                 rect, false, true, this, -1);
 296                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 297         }
 298
 299         {
 300                 core::rect < s32 > rect(0, 0, 100, 30);
 301                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 302                 this->range = Environment->addButton(rect, this,
 303                                 GUI_ID_KEY_RANGE_BUTTON,
 304                                 wgettext(KeyNamesLang[key_range]));
 305         }
 306
 307         offset += v2s32(0, 25);
 308         {
 309                 core::rect < s32 > rect(0, 0, 100, 20);
 310                 rect += topleft + v2s32(offset.X, offset.Y);
 311                 Environment->addStaticText(wgettext("Print stacks"),
 312                                 rect, false, true, this, -1);
 313                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 314         }
 315
 316         {
 317                 core::rect < s32 > rect(0, 0, 100, 30);
 318                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 319                 this->dump = Environment->addButton(rect, this, GUI_ID_KEY_DUMP_BUTTON,
 320                                 wgettext(KeyNamesLang[key_dump]));
 321         }
 322         {
 323                 core::rect < s32 > rect(0, 0, 100, 30);
 324                 rect += topleft + v2s32(size.X - 100 - 20, size.Y - 40);
 325                 Environment->addButton(rect, this, GUI_ID_BACK_BUTTON,
 326                 wgettext("Save"));
 327         }
 328         {
 329                 core::rect < s32 > rect(0, 0, 100, 30);
 330                 rect += topleft + v2s32(size.X - 100 - 20 - 100 - 20, size.Y - 40);
 331                 Environment->addButton(rect, this, GUI_ID_ABORT_BUTTON,
 332                 wgettext("Cancel"));
 333         }
 334         changeCtype("C");
 335 }
 336
 337 void GUIKeyChangeMenu::drawMenu()
 338 {
 339         gui::IGUISkin* skin = Environment->getSkin();
 340         if (!skin)
 341                 return;
 342         video::IVideoDriver* driver = Environment->getVideoDriver();
 343
 344         video::SColor bgcolor(140, 0, 0, 0);
 345
 346         {
 347                 core::rect < s32 > rect(0, 0, 620, 620);
 348                 rect += AbsoluteRect.UpperLeftCorner;
 349                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 350         }
 351
 352         gui::IGUIElement::draw();
 353 }
 354
 355 bool GUIKeyChangeMenu::acceptInput()
 356 {
 357         g_settings.set("keymap_forward", keycode_to_keyname(key_forward));
 358         g_settings.set("keymap_backward", keycode_to_keyname(key_backward));
 359         g_settings.set("keymap_left", keycode_to_keyname(key_left));
 360         g_settings.set("keymap_right", keycode_to_keyname(key_right));
 361         g_settings.set("keymap_jump", keycode_to_keyname(key_jump));
 362         g_settings.set("keymap_sneak", keycode_to_keyname(key_sneak));
 363         g_settings.set("keymap_inventory", keycode_to_keyname(key_inventory));
 364         g_settings.set("keymap_chat", keycode_to_keyname(key_chat));
 365         g_settings.set("keymap_rangeselect", keycode_to_keyname(key_range));
 366         g_settings.set("keymap_freemove", keycode_to_keyname(key_fly));
 367         g_settings.set("keymap_fastmove", keycode_to_keyname(key_fast));
 368         g_settings.set("keymap_special1", keycode_to_keyname(key_use));
 369         g_settings.set("keymap_print_debug_stacks", keycode_to_keyname(key_dump));
 370         clearKeyCache();
 371         return true;
 372 }
 373 void GUIKeyChangeMenu::init_keys()
 374 {
 375         key_forward = getKeySetting("keymap_forward");
 376         key_backward = getKeySetting("keymap_backward");
 377         key_left = getKeySetting("keymap_left");
 378         key_right = getKeySetting("keymap_right");
 379         key_jump = getKeySetting("keymap_jump");
 380         key_sneak = getKeySetting("keymap_sneak");
 381         key_inventory = getKeySetting("keymap_inventory");
 382         key_chat = getKeySetting("keymap_chat");
 383         key_range = getKeySetting("keymap_rangeselect");
 384         key_fly = getKeySetting("keymap_freemove");
 385         key_fast = getKeySetting("keymap_fastmove");
 386         key_use = getKeySetting("keymap_special1");
 387         key_dump = getKeySetting("keymap_print_debug_stacks");
 388 }
 389
 390 bool GUIKeyChangeMenu::resetMenu()
 391 {
 392         if (activeKey >= 0)
 393         {
 394                 switch (activeKey)
 395                 {
 396                 case GUI_ID_KEY_FORWARD_BUTTON:
 397                         this->forward->setText(
 398                                         wgettext(KeyNamesLang[key_forward]));
 399                         break;
 400                 case GUI_ID_KEY_BACKWARD_BUTTON:
 401                         this->backward->setText(
 402                                         wgettext(KeyNamesLang[key_backward]));
 403                         break;
 404                 case GUI_ID_KEY_LEFT_BUTTON:
 405                         this->left->setText(wgettext(KeyNamesLang[key_left]));
 406                         break;
 407                 case GUI_ID_KEY_RIGHT_BUTTON:
 408                         this->right->setText(wgettext(KeyNamesLang[key_right]));
 409                         break;
 410                 case GUI_ID_KEY_JUMP_BUTTON:
 411                         this->jump->setText(wgettext(KeyNamesLang[key_jump]));
 412                         break;
 413                 case GUI_ID_KEY_SNEAK_BUTTON:
 414                         this->sneak->setText(wgettext(KeyNamesLang[key_sneak]));
 415                         break;
 416                 case GUI_ID_KEY_INVENTORY_BUTTON:
 417                         this->inventory->setText(
 418                                         wgettext(KeyNamesLang[key_inventory]));
 419                         break;
 420                 case GUI_ID_KEY_CHAT_BUTTON:
 421                         this->chat->setText(wgettext(KeyNamesLang[key_chat]));
 422                         break;
 423                 case GUI_ID_KEY_RANGE_BUTTON:
 424                         this->range->setText(wgettext(KeyNamesLang[key_range]));
 425                         break;
 426                 case GUI_ID_KEY_FLY_BUTTON:
 427                         this->fly->setText(wgettext(KeyNamesLang[key_fly]));
 428                         break;
 429                 case GUI_ID_KEY_FAST_BUTTON:
 430                         this->fast->setText(wgettext(KeyNamesLang[key_fast]));
 431                         break;
 432                 case GUI_ID_KEY_USE_BUTTON:
 433                         this->use->setText(wgettext(KeyNamesLang[key_use]));
 434                         break;
 435                 case GUI_ID_KEY_DUMP_BUTTON:
 436                         this->dump->setText(wgettext(KeyNamesLang[key_dump]));
 437                         break;
 438                 }
 439                 activeKey = -1;
 440                 return false;
 441         }
 442         return true;
 443 }
 444 bool GUIKeyChangeMenu::OnEvent(const SEvent& event)
 445 {
 446         if (event.EventType == EET_KEY_INPUT_EVENT && activeKey >= 0
 447                         && event.KeyInput.PressedDown)
 448         {
 449                 changeCtype("");
 450                 if (activeKey == GUI_ID_KEY_FORWARD_BUTTON)
 451                 {
 452                         this->forward->setText(
 453                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 454                         this->key_forward = event.KeyInput.Key;
 455                 }
 456                 else if (activeKey == GUI_ID_KEY_BACKWARD_BUTTON)
 457                 {
 458                         this->backward->setText(
 459                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 460                         this->key_backward = event.KeyInput.Key;
 461                 }
 462                 else if (activeKey == GUI_ID_KEY_LEFT_BUTTON)
 463                 {
 464                         this->left->setText(
 465                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 466                         this->key_left = event.KeyInput.Key;
 467                 }
 468                 else if (activeKey == GUI_ID_KEY_RIGHT_BUTTON)
 469                 {
 470                         this->right->setText(
 471                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 472                         this->key_right = event.KeyInput.Key;
 473                 }
 474                 else if (activeKey == GUI_ID_KEY_JUMP_BUTTON)
 475                 {
 476                         this->jump->setText(
 477                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 478                         this->key_jump = event.KeyInput.Key;
 479                 }
 480                 else if (activeKey == GUI_ID_KEY_SNEAK_BUTTON)
 481                 {
 482                         this->sneak->setText(
 483                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 484                         this->key_sneak = event.KeyInput.Key;
 485                 }
 486                 else if (activeKey == GUI_ID_KEY_INVENTORY_BUTTON)
 487                 {
 488                         this->inventory->setText(
 489                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 490                         this->key_inventory = event.KeyInput.Key;
 491                 }
 492                 else if (activeKey == GUI_ID_KEY_CHAT_BUTTON)
 493                 {
 494                         this->chat->setText(
 495                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 496                         this->key_chat = event.KeyInput.Key;
 497                 }
 498                 else if (activeKey == GUI_ID_KEY_RANGE_BUTTON)
 499                 {
 500                         this->range->setText(
 501                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 502                         this->key_range = event.KeyInput.Key;
 503                 }
 504                 else if (activeKey == GUI_ID_KEY_FLY_BUTTON)
 505                 {
 506                         this->fly->setText(
 507                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 508                         this->key_fly = event.KeyInput.Key;
 509                 }
 510                 else if (activeKey == GUI_ID_KEY_FAST_BUTTON)
 511                 {
 512                         this->fast->setText(
 513                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 514                         this->key_fast = event.KeyInput.Key;
 515                 }
 516                 else if (activeKey == GUI_ID_KEY_USE_BUTTON)
 517                 {
 518                         this->use->setText(
 519                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 520                         this->key_use = event.KeyInput.Key;
 521                 }
 522                 else if (activeKey == GUI_ID_KEY_DUMP_BUTTON)
 523                 {
 524                         this->dump->setText(
 525                                         wgettext(KeyNamesLang[event.KeyInput.Key]));
 526                         this->key_dump = event.KeyInput.Key;
 527                 }
 528                 changeCtype("C");
 529                 activeKey = -1;
 530                 return true;
 531         }
 532         if (event.EventType == EET_GUI_EVENT)
 533         {
 534                 if (event.GUIEvent.EventType == gui::EGET_ELEMENT_FOCUS_LOST
 535                                 && isVisible())
 536                 {
 537                         if (!canTakeFocus(event.GUIEvent.Element))
 538                         {
 539                                 dstream << "GUIMainMenu: Not allowing focus change."
 540                                                 << std::endl;
 541                                 // Returning true disables focus change
 542                                 return true;
 543                         }
 544                 }
 545                 if (event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED)
 546                 {
 547                         if(event.GUIEvent.Caller->getID() != GUI_ID_BACK_BUTTON &&
 548                                 event.GUIEvent.Caller->getID() != GUI_ID_ABORT_BUTTON)
 549                         {
 550                                 changeCtype("");
 551                         }
 552
 553                         switch (event.GUIEvent.Caller->getID())
 554                         {
 555                         case GUI_ID_BACK_BUTTON: //back
 556                                 acceptInput();
 557                                 quitMenu();
 558                                 return true;
 559                         case GUI_ID_ABORT_BUTTON: //abort
 560                                 quitMenu();
 561                                 return true;
 562                         case GUI_ID_KEY_FORWARD_BUTTON:
 563                                 resetMenu();
 564                                 activeKey = event.GUIEvent.Caller->getID();
 565                                 this->forward->setText(wgettext("press Key"));
 566                                 break;
 567                         case GUI_ID_KEY_BACKWARD_BUTTON:
 568                                 resetMenu();
 569                                 activeKey = event.GUIEvent.Caller->getID();
 570                                 this->backward->setText(wgettext("press Key"));
 571                                 break;
 572                         case GUI_ID_KEY_LEFT_BUTTON:
 573                                 resetMenu();
 574                                 activeKey = event.GUIEvent.Caller->getID();
 575                                 this->left->setText(wgettext("press Key"));
 576                                 break;
 577                         case GUI_ID_KEY_RIGHT_BUTTON:
 578                                 resetMenu();
 579                                 activeKey = event.GUIEvent.Caller->getID();
 580                                 this->right->setText(wgettext("press Key"));
 581                                 break;
 582                         case GUI_ID_KEY_USE_BUTTON:
 583                                 resetMenu();
 584                                 activeKey = event.GUIEvent.Caller->getID();
 585                                 this->use->setText(wgettext("press Key"));
 586                                 break;
 587                         case GUI_ID_KEY_FLY_BUTTON:
 588                                 resetMenu();
 589                                 activeKey = event.GUIEvent.Caller->getID();
 590                                 this->fly->setText(wgettext("press Key"));
 591                                 break;
 592                         case GUI_ID_KEY_FAST_BUTTON:
 593                                 resetMenu();
 594                                 activeKey = event.GUIEvent.Caller->getID();
 595                                 this->fast->setText(wgettext("press Key"));
 596                                 break;
 597                         case GUI_ID_KEY_JUMP_BUTTON:
 598                                 resetMenu();
 599                                 activeKey = event.GUIEvent.Caller->getID();
 600                                 this->jump->setText(wgettext("press Key"));
 601                                 break;
 602                         case GUI_ID_KEY_CHAT_BUTTON:
 603                                 resetMenu();
 604                                 activeKey = event.GUIEvent.Caller->getID();
 605                                 this->chat->setText(wgettext("press Key"));
 606                                 break;
 607                         case GUI_ID_KEY_SNEAK_BUTTON:
 608                                 resetMenu();
 609                                 activeKey = event.GUIEvent.Caller->getID();
 610                                 this->sneak->setText(wgettext("press Key"));
 611                                 break;
 612                         case GUI_ID_KEY_INVENTORY_BUTTON:
 613                                 resetMenu();
 614                                 activeKey = event.GUIEvent.Caller->getID();
 615                                 this->inventory->setText(wgettext("press Key"));
 616                                 break;
 617                         case GUI_ID_KEY_DUMP_BUTTON:
 618                                 resetMenu();
 619                                 activeKey = event.GUIEvent.Caller->getID();
 620                                 this->dump->setText(wgettext("press Key"));
 621                                 break;
 622                         case GUI_ID_KEY_RANGE_BUTTON:
 623                                 resetMenu();
 624                                 activeKey = event.GUIEvent.Caller->getID();
 625                                 this->range->setText(wgettext("press Key"));
 626                                 break;
 627                         }
 628                         //Buttons
 629                         changeCtype("C");
 630
 631                 }
 632         }
 633         return Parent ? Parent->OnEvent(event) : false;
 634 }
 635