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 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, 500, 20);
 109                 rect += topleft + v2s32(25, 3);
 110                 //gui::IGUIStaticText *t =
 111                 Environment->addStaticText(wgettext("KEYBINDINGS (If this menu screws up, see minetest.conf)"),
 112                                 rect, false, true, this, -1);
 113                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 114         }
 115         v2s32 offset(25, 40);
 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, 40);
 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