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 "main.h"
  26 #include <string>
  27 #include <IGUICheckBox.h>
  28 #include <IGUIEditBox.h>
  29 #include <IGUIButton.h>
  30 #include <IGUIStaticText.h>
  31 #include <IGUIFont.h>
  32 #include "settings.h"
  33
  34 GUIKeyChangeMenu::GUIKeyChangeMenu(gui::IGUIEnvironment* env,
  35                 gui::IGUIElement* parent, s32 id, IMenuManager *menumgr) :
  36         GUIModalMenu(env, parent, id, menumgr)
  37 {
  38         activeKey = -1;
  39         init_keys();
  40 }
  41
  42 GUIKeyChangeMenu::~GUIKeyChangeMenu()
  43 {
  44         removeChildren();
  45 }
  46
  47 void GUIKeyChangeMenu::removeChildren()
  48 {
  49         const core::list<gui::IGUIElement*> &children = getChildren();
  50         core::list<gui::IGUIElement*> children_copy;
  51         for (core::list<gui::IGUIElement*>::ConstIterator i = children.begin(); i
  52                         != children.end(); i++)
  53         {
  54                 children_copy.push_back(*i);
  55         }
  56         for (core::list<gui::IGUIElement*>::Iterator i = children_copy.begin(); i
  57                         != children_copy.end(); i++)
  58         {
  59                 (*i)->remove();
  60         }
  61 }
  62
  63 void GUIKeyChangeMenu::regenerateGui(v2u32 screensize)
  64 {
  65         /*
  66          Remove stuff
  67          */
  68         removeChildren();
  69
  70         /*
  71          Calculate new sizes and positions
  72          */
  73
  74         v2s32 size(620, 430);
  75
  76         core::rect < s32 > rect(screensize.X / 2 - size.X / 2,
  77                         screensize.Y / 2 - size.Y / 2, screensize.X / 2 + size.X / 2,
  78                         screensize.Y / 2 + size.Y / 2);
  79
  80         DesiredRect = rect;
  81         recalculateAbsolutePosition(false);
  82
  83         v2s32 topleft(0, 0);
  84         changeCtype("");
  85         {
  86                 core::rect < s32 > rect(0, 0, 500, 20);
  87                 rect += topleft + v2s32(25, 3);
  88                 //gui::IGUIStaticText *t =
  89                 Environment->addStaticText(wgettext("KEYBINDINGS (If this menu screws up, see minetest.conf)"),
  90                                 rect, false, true, this, -1);
  91                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
  92         }
  93         v2s32 offset(25, 40);
  94         // buttons
  95
  96         {
  97                 core::rect < s32 > rect(0, 0, 100, 20);
  98                 rect += topleft + v2s32(offset.X, offset.Y);
  99                 Environment->addStaticText(wgettext("Forward"),
 100                                 rect, false, true, this, -1);
 101                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 102         }
 103
 104         {
 105                 core::rect < s32 > rect(0, 0, 100, 30);
 106                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 107                 this->forward = Environment->addButton(rect, this,
 108                                 GUI_ID_KEY_FORWARD_BUTTON,
 109                                 wgettext(key_forward.name()));
 110         }
 111
 112         offset += v2s32(0, 25);
 113         {
 114                 core::rect < s32 > rect(0, 0, 100, 20);
 115                 rect += topleft + v2s32(offset.X, offset.Y);
 116                 Environment->addStaticText(wgettext("Backward"),
 117                                 rect, false, true, this, -1);
 118                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 119         }
 120
 121         {
 122                 core::rect < s32 > rect(0, 0, 100, 30);
 123                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 124                 this->backward = Environment->addButton(rect, this,
 125                                 GUI_ID_KEY_BACKWARD_BUTTON,
 126                                 wgettext(key_backward.name()));
 127         }
 128         offset += v2s32(0, 25);
 129         {
 130                 core::rect < s32 > rect(0, 0, 100, 20);
 131                 rect += topleft + v2s32(offset.X, offset.Y);
 132                 Environment->addStaticText(wgettext("Left"),
 133                                 rect, false, true, this, -1);
 134                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 135         }
 136
 137         {
 138                 core::rect < s32 > rect(0, 0, 100, 30);
 139                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 140                 this->left = Environment->addButton(rect, this, GUI_ID_KEY_LEFT_BUTTON,
 141                                 wgettext(key_left.name()));
 142         }
 143         offset += v2s32(0, 25);
 144         {
 145                 core::rect < s32 > rect(0, 0, 100, 20);
 146                 rect += topleft + v2s32(offset.X, offset.Y);
 147                 Environment->addStaticText(wgettext("Right"),
 148                                 rect, false, true, this, -1);
 149                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 150         }
 151
 152         {
 153                 core::rect < s32 > rect(0, 0, 100, 30);
 154                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 155                 this->right = Environment->addButton(rect, this,
 156                                 GUI_ID_KEY_RIGHT_BUTTON,
 157                                 wgettext(key_right.name()));
 158         }
 159         offset += v2s32(0, 25);
 160         {
 161                 core::rect < s32 > rect(0, 0, 100, 20);
 162                 rect += topleft + v2s32(offset.X, offset.Y);
 163                 Environment->addStaticText(wgettext("Use"),
 164                                 rect, false, true, this, -1);
 165                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 166         }
 167
 168         {
 169                 core::rect < s32 > rect(0, 0, 100, 30);
 170                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 171                 this->use = Environment->addButton(rect, this, GUI_ID_KEY_USE_BUTTON,
 172                                 wgettext(key_use.name()));
 173         }
 174         offset += v2s32(0, 25);
 175         {
 176                 core::rect < s32 > rect(0, 0, 100, 20);
 177                 rect += topleft + v2s32(offset.X, offset.Y);
 178                 Environment->addStaticText(wgettext("Sneak"),
 179                                 rect, false, true, this, -1);
 180                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 181         }
 182
 183         {
 184                 core::rect < s32 > rect(0, 0, 100, 30);
 185                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 186                 this->sneak = Environment->addButton(rect, this,
 187                                 GUI_ID_KEY_SNEAK_BUTTON,
 188                                 wgettext(key_sneak.name()));
 189         }
 190         offset += v2s32(0, 25);
 191         {
 192                 core::rect < s32 > rect(0, 0, 100, 20);
 193                 rect += topleft + v2s32(offset.X, offset.Y);
 194                 Environment->addStaticText(wgettext("Jump"), rect, false, true, this, -1);
 195                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 196         }
 197
 198         {
 199                 core::rect < s32 > rect(0, 0, 100, 30);
 200                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 201                 this->jump = Environment->addButton(rect, this, GUI_ID_KEY_JUMP_BUTTON,
 202                                 wgettext(key_jump.name()));
 203         }
 204
 205         offset += v2s32(0, 25);
 206         {
 207                 core::rect < s32 > rect(0, 0, 100, 20);
 208                 rect += topleft + v2s32(offset.X, offset.Y);
 209                 Environment->addStaticText(wgettext("Drop"), rect, false, true, this, -1);
 210                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 211         }
 212
 213         {
 214                 core::rect < s32 > rect(0, 0, 100, 30);
 215                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 216                 this->dropbtn = Environment->addButton(rect, this, GUI_ID_KEY_DROP_BUTTON,
 217                                 wgettext(key_drop.name()));
 218         }
 219
 220         offset += v2s32(0, 25);
 221         {
 222                 core::rect < s32 > rect(0, 0, 100, 20);
 223                 rect += topleft + v2s32(offset.X, offset.Y);
 224                 Environment->addStaticText(wgettext("Inventory"),
 225                                 rect, false, true, this, -1);
 226                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 227         }
 228
 229         {
 230                 core::rect < s32 > rect(0, 0, 100, 30);
 231                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 232                 this->inventory = Environment->addButton(rect, this,
 233                                 GUI_ID_KEY_INVENTORY_BUTTON,
 234                                 wgettext(key_inventory.name()));
 235         }
 236         offset += v2s32(0, 25);
 237         {
 238                 core::rect < s32 > rect(0, 0, 100, 20);
 239                 rect += topleft + v2s32(offset.X, offset.Y);
 240                 Environment->addStaticText(wgettext("Chat"), rect, false, true, this, -1);
 241                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 242         }
 243
 244         {
 245                 core::rect < s32 > rect(0, 0, 100, 30);
 246                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 247                 this->chat = Environment->addButton(rect, this, GUI_ID_KEY_CHAT_BUTTON,
 248                                 wgettext(key_chat.name()));
 249         }
 250         offset += v2s32(0, 25);
 251         {
 252                 core::rect < s32 > rect(0, 0, 100, 20);
 253                 rect += topleft + v2s32(offset.X, offset.Y);
 254                 Environment->addStaticText(wgettext("Command"), rect, false, true, this, -1);
 255                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 256         }
 257
 258         {
 259                 core::rect < s32 > rect(0, 0, 100, 30);
 260                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 261                 this->cmd = Environment->addButton(rect, this, GUI_ID_KEY_CMD_BUTTON,
 262                                 wgettext(key_cmd.name()));
 263         }
 264         offset += v2s32(0, 25);
 265         {
 266                 core::rect < s32 > rect(0, 0, 100, 20);
 267                 rect += topleft + v2s32(offset.X, offset.Y);
 268                 Environment->addStaticText(wgettext("Console"), rect, false, true, this, -1);
 269                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 270         }
 271
 272         {
 273                 core::rect < s32 > rect(0, 0, 100, 30);
 274                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 275                 this->console = Environment->addButton(rect, this, GUI_ID_KEY_CONSOLE_BUTTON,
 276                                 wgettext(key_console.name()));
 277         }
 278
 279         //next col
 280         offset = v2s32(250, 40);
 281         {
 282                 core::rect < s32 > rect(0, 0, 100, 20);
 283                 rect += topleft + v2s32(offset.X, offset.Y);
 284                 Environment->addStaticText(wgettext("Toggle fly"),
 285                                 rect, false, true, this, -1);
 286                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 287         }
 288
 289         {
 290                 core::rect < s32 > rect(0, 0, 100, 30);
 291                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 292                 this->fly = Environment->addButton(rect, this, GUI_ID_KEY_FLY_BUTTON,
 293                                 wgettext(key_fly.name()));
 294         }
 295         offset += v2s32(0, 25);
 296         {
 297                 core::rect < s32 > rect(0, 0, 100, 20);
 298                 rect += topleft + v2s32(offset.X, offset.Y);
 299                 Environment->addStaticText(wgettext("Toggle fast"),
 300                                 rect, false, true, this, -1);
 301                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 302         }
 303
 304         {
 305                 core::rect < s32 > rect(0, 0, 100, 30);
 306                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 307                 this->fast = Environment->addButton(rect, this, GUI_ID_KEY_FAST_BUTTON,
 308                                 wgettext(key_fast.name()));
 309         }
 310         offset += v2s32(0, 25);
 311         {
 312                 core::rect < s32 > rect(0, 0, 100, 20);
 313                 rect += topleft + v2s32(offset.X, offset.Y);
 314                 Environment->addStaticText(wgettext("Range select"),
 315                                 rect, false, true, this, -1);
 316                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 317         }
 318
 319         {
 320                 core::rect < s32 > rect(0, 0, 100, 30);
 321                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 322                 this->range = Environment->addButton(rect, this,
 323                                 GUI_ID_KEY_RANGE_BUTTON,
 324                                 wgettext(key_range.name()));
 325         }
 326
 327         offset += v2s32(0, 25);
 328         {
 329                 core::rect < s32 > rect(0, 0, 100, 20);
 330                 rect += topleft + v2s32(offset.X, offset.Y);
 331                 Environment->addStaticText(wgettext("Print stacks"),
 332                                 rect, false, true, this, -1);
 333                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 334         }
 335
 336         {
 337                 core::rect < s32 > rect(0, 0, 100, 30);
 338                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 339                 this->dump = Environment->addButton(rect, this, GUI_ID_KEY_DUMP_BUTTON,
 340                                 wgettext(key_dump.name()));
 341         }
 342         {
 343                 core::rect < s32 > rect(0, 0, 100, 30);
 344                 rect += topleft + v2s32(size.X - 100 - 20, size.Y - 40);
 345                 Environment->addButton(rect, this, GUI_ID_BACK_BUTTON,
 346                 wgettext("Save"));
 347         }
 348         {
 349                 core::rect < s32 > rect(0, 0, 100, 30);
 350                 rect += topleft + v2s32(size.X - 100 - 20 - 100 - 20, size.Y - 40);
 351                 Environment->addButton(rect, this, GUI_ID_ABORT_BUTTON,
 352                 wgettext("Cancel"));
 353         }
 354         changeCtype("C");
 355 }
 356
 357 void GUIKeyChangeMenu::drawMenu()
 358 {
 359         gui::IGUISkin* skin = Environment->getSkin();
 360         if (!skin)
 361                 return;
 362         video::IVideoDriver* driver = Environment->getVideoDriver();
 363
 364         video::SColor bgcolor(140, 0, 0, 0);
 365
 366         {
 367                 core::rect < s32 > rect(0, 0, 620, 620);
 368                 rect += AbsoluteRect.UpperLeftCorner;
 369                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 370         }
 371
 372         gui::IGUIElement::draw();
 373 }
 374
 375 bool GUIKeyChangeMenu::acceptInput()
 376 {
 377         g_settings->set("keymap_forward", key_forward.sym());
 378         g_settings->set("keymap_backward", key_backward.sym());
 379         g_settings->set("keymap_left", key_left.sym());
 380         g_settings->set("keymap_right", key_right.sym());
 381         g_settings->set("keymap_jump", key_jump.sym());
 382         g_settings->set("keymap_sneak", key_sneak.sym());
 383         g_settings->set("keymap_drop", key_drop.sym());
 384         g_settings->set("keymap_inventory", key_inventory.sym());
 385         g_settings->set("keymap_chat", key_chat.sym());
 386         g_settings->set("keymap_cmd", key_cmd.sym());
 387         g_settings->set("keymap_console", key_console.sym());
 388         g_settings->set("keymap_rangeselect", key_range.sym());
 389         g_settings->set("keymap_freemove", key_fly.sym());
 390         g_settings->set("keymap_fastmove", key_fast.sym());
 391         g_settings->set("keymap_special1", key_use.sym());
 392         g_settings->set("keymap_print_debug_stacks", key_dump.sym());
 393         clearKeyCache();
 394         return true;
 395 }
 396 void GUIKeyChangeMenu::init_keys()
 397 {
 398         key_forward = getKeySetting("keymap_forward");
 399         key_backward = getKeySetting("keymap_backward");
 400         key_left = getKeySetting("keymap_left");
 401         key_right = getKeySetting("keymap_right");
 402         key_jump = getKeySetting("keymap_jump");
 403         key_sneak = getKeySetting("keymap_sneak");
 404         key_drop = getKeySetting("keymap_drop");
 405         key_inventory = getKeySetting("keymap_inventory");
 406         key_chat = getKeySetting("keymap_chat");
 407         key_cmd = getKeySetting("keymap_cmd");
 408         key_console = getKeySetting("keymap_console");
 409         key_range = getKeySetting("keymap_rangeselect");
 410         key_fly = getKeySetting("keymap_freemove");
 411         key_fast = getKeySetting("keymap_fastmove");
 412         key_use = getKeySetting("keymap_special1");
 413         key_dump = getKeySetting("keymap_print_debug_stacks");
 414 }
 415
 416 bool GUIKeyChangeMenu::resetMenu()
 417 {
 418         if (activeKey >= 0)
 419         {
 420                 switch (activeKey)
 421                 {
 422                 case GUI_ID_KEY_FORWARD_BUTTON:
 423                         this->forward->setText(
 424                                         wgettext(key_forward.name()));
 425                         break;
 426                 case GUI_ID_KEY_BACKWARD_BUTTON:
 427                         this->backward->setText(
 428                                         wgettext(key_backward.name()));
 429                         break;
 430                 case GUI_ID_KEY_LEFT_BUTTON:
 431                         this->left->setText(wgettext(key_left.name()));
 432                         break;
 433                 case GUI_ID_KEY_RIGHT_BUTTON:
 434                         this->right->setText(wgettext(key_right.name()));
 435                         break;
 436                 case GUI_ID_KEY_JUMP_BUTTON:
 437                         this->jump->setText(wgettext(key_jump.name()));
 438                         break;
 439                 case GUI_ID_KEY_SNEAK_BUTTON:
 440                         this->sneak->setText(wgettext(key_sneak.name()));
 441                         break;
 442                 case GUI_ID_KEY_DROP_BUTTON:
 443                         this->dropbtn->setText(wgettext(key_drop.name()));
 444                         break;
 445                 case GUI_ID_KEY_INVENTORY_BUTTON:
 446                         this->inventory->setText(
 447                                         wgettext(key_inventory.name()));
 448                         break;
 449                 case GUI_ID_KEY_CHAT_BUTTON:
 450                         this->chat->setText(wgettext(key_chat.name()));
 451                         break;
 452                 case GUI_ID_KEY_CMD_BUTTON:
 453                         this->cmd->setText(wgettext(key_cmd.name()));
 454                         break;
 455                 case GUI_ID_KEY_CONSOLE_BUTTON:
 456                         this->console->setText(wgettext(key_console.name()));
 457                         break;
 458                 case GUI_ID_KEY_RANGE_BUTTON:
 459                         this->range->setText(wgettext(key_range.name()));
 460                         break;
 461                 case GUI_ID_KEY_FLY_BUTTON:
 462                         this->fly->setText(wgettext(key_fly.name()));
 463                         break;
 464                 case GUI_ID_KEY_FAST_BUTTON:
 465                         this->fast->setText(wgettext(key_fast.name()));
 466                         break;
 467                 case GUI_ID_KEY_USE_BUTTON:
 468                         this->use->setText(wgettext(key_use.name()));
 469                         break;
 470                 case GUI_ID_KEY_DUMP_BUTTON:
 471                         this->dump->setText(wgettext(key_dump.name()));
 472                         break;
 473                 }
 474                 activeKey = -1;
 475                 return false;
 476         }
 477         return true;
 478 }
 479 bool GUIKeyChangeMenu::OnEvent(const SEvent& event)
 480 {
 481         if (event.EventType == EET_KEY_INPUT_EVENT && activeKey >= 0
 482                         && event.KeyInput.PressedDown)
 483         {
 484                 changeCtype("");
 485                 KeyPress kp(event.KeyInput);
 486
 487                 if (activeKey == GUI_ID_KEY_FORWARD_BUTTON)
 488                 {
 489                         this->forward->setText(wgettext(kp.name()));
 490                         this->key_forward = kp;
 491                 }
 492                 else if (activeKey == GUI_ID_KEY_BACKWARD_BUTTON)
 493                 {
 494                         this->backward->setText(wgettext(kp.name()));
 495                         this->key_backward = kp;
 496                 }
 497                 else if (activeKey == GUI_ID_KEY_LEFT_BUTTON)
 498                 {
 499                         this->left->setText(wgettext(kp.name()));
 500                         this->key_left = kp;
 501                 }
 502                 else if (activeKey == GUI_ID_KEY_RIGHT_BUTTON)
 503                 {
 504                         this->right->setText(wgettext(kp.name()));
 505                         this->key_right = kp;
 506                 }
 507                 else if (activeKey == GUI_ID_KEY_JUMP_BUTTON)
 508                 {
 509                         this->jump->setText(wgettext(kp.name()));
 510                         this->key_jump = kp;
 511                 }
 512                 else if (activeKey == GUI_ID_KEY_SNEAK_BUTTON)
 513                 {
 514                         this->sneak->setText(wgettext(kp.name()));
 515                         this->key_sneak = kp;
 516                 }
 517                 else if (activeKey == GUI_ID_KEY_DROP_BUTTON)
 518                 {
 519                         this->dropbtn->setText(wgettext(kp.name()));
 520                         this->key_drop = kp;
 521                 }
 522                 else if (activeKey == GUI_ID_KEY_INVENTORY_BUTTON)
 523                 {
 524                         this->inventory->setText(wgettext(kp.name()));
 525                         this->key_inventory = kp;
 526                 }
 527                 else if (activeKey == GUI_ID_KEY_CHAT_BUTTON)
 528                 {
 529                         this->chat->setText(wgettext(kp.name()));
 530                         this->key_chat = kp;
 531                 }
 532                 else if (activeKey == GUI_ID_KEY_CMD_BUTTON)
 533                 {
 534                         this->cmd->setText(wgettext(kp.name()));
 535                         this->key_cmd = kp;
 536                 }
 537                 else if (activeKey == GUI_ID_KEY_CONSOLE_BUTTON)
 538                 {
 539                         this->console->setText(wgettext(kp.name()));
 540                         this->key_console = kp;
 541                 }
 542                 else if (activeKey == GUI_ID_KEY_RANGE_BUTTON)
 543                 {
 544                         this->range->setText(wgettext(kp.name()));
 545                         this->key_range = kp;
 546                 }
 547                 else if (activeKey == GUI_ID_KEY_FLY_BUTTON)
 548                 {
 549                         this->fly->setText(wgettext(kp.name()));
 550                         this->key_fly = kp;
 551                 }
 552                 else if (activeKey == GUI_ID_KEY_FAST_BUTTON)
 553                 {
 554                         this->fast->setText(wgettext(kp.name()));
 555                         this->key_fast = kp;
 556                 }
 557                 else if (activeKey == GUI_ID_KEY_USE_BUTTON)
 558                 {
 559                         this->use->setText(wgettext(kp.name()));
 560                         this->key_use = kp;
 561                 }
 562                 else if (activeKey == GUI_ID_KEY_DUMP_BUTTON)
 563                 {
 564                         this->dump->setText(wgettext(kp.name()));
 565                         this->key_dump = kp;
 566                 }
 567                 changeCtype("C");
 568                 activeKey = -1;
 569                 return true;
 570         }
 571         if (event.EventType == EET_GUI_EVENT)
 572         {
 573                 if (event.GUIEvent.EventType == gui::EGET_ELEMENT_FOCUS_LOST
 574                                 && isVisible())
 575                 {
 576                         if (!canTakeFocus(event.GUIEvent.Element))
 577                         {
 578                                 dstream << "GUIMainMenu: Not allowing focus change."
 579                                                 << std::endl;
 580                                 // Returning true disables focus change
 581                                 return true;
 582                         }
 583                 }
 584                 if (event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED)
 585                 {
 586                         if(event.GUIEvent.Caller->getID() != GUI_ID_BACK_BUTTON &&
 587                                 event.GUIEvent.Caller->getID() != GUI_ID_ABORT_BUTTON)
 588                         {
 589                                 changeCtype("");
 590                         }
 591
 592                         switch (event.GUIEvent.Caller->getID())
 593                         {
 594                         case GUI_ID_BACK_BUTTON: //back
 595                                 acceptInput();
 596                                 quitMenu();
 597                                 return true;
 598                         case GUI_ID_ABORT_BUTTON: //abort
 599                                 quitMenu();
 600                                 return true;
 601                         case GUI_ID_KEY_FORWARD_BUTTON:
 602                                 resetMenu();
 603                                 activeKey = event.GUIEvent.Caller->getID();
 604                                 this->forward->setText(wgettext("press Key"));
 605                                 break;
 606                         case GUI_ID_KEY_BACKWARD_BUTTON:
 607                                 resetMenu();
 608                                 activeKey = event.GUIEvent.Caller->getID();
 609                                 this->backward->setText(wgettext("press Key"));
 610                                 break;
 611                         case GUI_ID_KEY_LEFT_BUTTON:
 612                                 resetMenu();
 613                                 activeKey = event.GUIEvent.Caller->getID();
 614                                 this->left->setText(wgettext("press Key"));
 615                                 break;
 616                         case GUI_ID_KEY_RIGHT_BUTTON:
 617                                 resetMenu();
 618                                 activeKey = event.GUIEvent.Caller->getID();
 619                                 this->right->setText(wgettext("press Key"));
 620                                 break;
 621                         case GUI_ID_KEY_USE_BUTTON:
 622                                 resetMenu();
 623                                 activeKey = event.GUIEvent.Caller->getID();
 624                                 this->use->setText(wgettext("press Key"));
 625                                 break;
 626                         case GUI_ID_KEY_FLY_BUTTON:
 627                                 resetMenu();
 628                                 activeKey = event.GUIEvent.Caller->getID();
 629                                 this->fly->setText(wgettext("press Key"));
 630                                 break;
 631                         case GUI_ID_KEY_FAST_BUTTON:
 632                                 resetMenu();
 633                                 activeKey = event.GUIEvent.Caller->getID();
 634                                 this->fast->setText(wgettext("press Key"));
 635                                 break;
 636                         case GUI_ID_KEY_JUMP_BUTTON:
 637                                 resetMenu();
 638                                 activeKey = event.GUIEvent.Caller->getID();
 639                                 this->jump->setText(wgettext("press Key"));
 640                                 break;
 641                         case GUI_ID_KEY_DROP_BUTTON:
 642                                 resetMenu();
 643                                 activeKey = event.GUIEvent.Caller->getID();
 644                                 this->dropbtn->setText(wgettext("press Key"));
 645                                 break;
 646                         case GUI_ID_KEY_CHAT_BUTTON:
 647                                 resetMenu();
 648                                 activeKey = event.GUIEvent.Caller->getID();
 649                                 this->chat->setText(wgettext("press Key"));
 650                                 break;
 651                         case GUI_ID_KEY_CMD_BUTTON:
 652                                 resetMenu();
 653                                 activeKey = event.GUIEvent.Caller->getID();
 654                                 this->cmd->setText(wgettext("press Key"));
 655                                 break;
 656                         case GUI_ID_KEY_CONSOLE_BUTTON:
 657                                 resetMenu();
 658                                 activeKey = event.GUIEvent.Caller->getID();
 659                                 this->console->setText(wgettext("press Key"));
 660                                 break;
 661                         case GUI_ID_KEY_SNEAK_BUTTON:
 662                                 resetMenu();
 663                                 activeKey = event.GUIEvent.Caller->getID();
 664                                 this->sneak->setText(wgettext("press Key"));
 665                                 break;
 666                         case GUI_ID_KEY_INVENTORY_BUTTON:
 667                                 resetMenu();
 668                                 activeKey = event.GUIEvent.Caller->getID();
 669                                 this->inventory->setText(wgettext("press Key"));
 670                                 break;
 671                         case GUI_ID_KEY_DUMP_BUTTON:
 672                                 resetMenu();
 673                                 activeKey = event.GUIEvent.Caller->getID();
 674                                 this->dump->setText(wgettext("press Key"));
 675                                 break;
 676                         case GUI_ID_KEY_RANGE_BUTTON:
 677                                 resetMenu();
 678                                 activeKey = event.GUIEvent.Caller->getID();
 679                                 this->range->setText(wgettext("press Key"));
 680                                 break;
 681                         }
 682                         //Buttons
 683                         changeCtype("C");
 684
 685                 }
 686         }
 687         return Parent ? Parent->OnEvent(event) : false;
 688 }
 689