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