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, 125, 20);
  87                 rect += topleft + v2s32(25, 3);
  88                 //gui::IGUIStaticText *t =
  89                 Environment->addStaticText(wgettext("KEYBINDINGS"),
  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("Inventory"),
 210                                 rect, false, true, this, -1);
 211                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 212         }
 213
 214         {
 215                 core::rect < s32 > rect(0, 0, 100, 30);
 216                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 217                 this->inventory = Environment->addButton(rect, this,
 218                                 GUI_ID_KEY_INVENTORY_BUTTON,
 219                                 wgettext(key_inventory.name()));
 220         }
 221         offset += v2s32(0, 25);
 222         {
 223                 core::rect < s32 > rect(0, 0, 100, 20);
 224                 rect += topleft + v2s32(offset.X, offset.Y);
 225                 Environment->addStaticText(wgettext("Chat"), 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->chat = Environment->addButton(rect, this, GUI_ID_KEY_CHAT_BUTTON,
 233                                 wgettext(key_chat.name()));
 234         }
 235         offset += v2s32(0, 25);
 236         {
 237                 core::rect < s32 > rect(0, 0, 100, 20);
 238                 rect += topleft + v2s32(offset.X, offset.Y);
 239                 Environment->addStaticText(wgettext("Command"), rect, false, true, this, -1);
 240                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 241         }
 242
 243         {
 244                 core::rect < s32 > rect(0, 0, 100, 30);
 245                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 246                 this->cmd = Environment->addButton(rect, this, GUI_ID_KEY_CMD_BUTTON,
 247                                 wgettext(key_cmd.name()));
 248         }
 249
 250
 251         //next col
 252         offset = v2s32(250, 40);
 253         {
 254                 core::rect < s32 > rect(0, 0, 100, 20);
 255                 rect += topleft + v2s32(offset.X, offset.Y);
 256                 Environment->addStaticText(wgettext("Toggle fly"),
 257                                 rect, false, true, this, -1);
 258                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 259         }
 260
 261         {
 262                 core::rect < s32 > rect(0, 0, 100, 30);
 263                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 264                 this->fly = Environment->addButton(rect, this, GUI_ID_KEY_FLY_BUTTON,
 265                                 wgettext(key_fly.name()));
 266         }
 267         offset += v2s32(0, 25);
 268         {
 269                 core::rect < s32 > rect(0, 0, 100, 20);
 270                 rect += topleft + v2s32(offset.X, offset.Y);
 271                 Environment->addStaticText(wgettext("Toggle fast"),
 272                                 rect, false, true, this, -1);
 273                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 274         }
 275
 276         {
 277                 core::rect < s32 > rect(0, 0, 100, 30);
 278                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 279                 this->fast = Environment->addButton(rect, this, GUI_ID_KEY_FAST_BUTTON,
 280                                 wgettext(key_fast.name()));
 281         }
 282         offset += v2s32(0, 25);
 283         {
 284                 core::rect < s32 > rect(0, 0, 100, 20);
 285                 rect += topleft + v2s32(offset.X, offset.Y);
 286                 Environment->addStaticText(wgettext("Range select"),
 287                                 rect, false, true, this, -1);
 288                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 289         }
 290
 291         {
 292                 core::rect < s32 > rect(0, 0, 100, 30);
 293                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 294                 this->range = Environment->addButton(rect, this,
 295                                 GUI_ID_KEY_RANGE_BUTTON,
 296                                 wgettext(key_range.name()));
 297         }
 298
 299         offset += v2s32(0, 25);
 300         {
 301                 core::rect < s32 > rect(0, 0, 100, 20);
 302                 rect += topleft + v2s32(offset.X, offset.Y);
 303                 Environment->addStaticText(wgettext("Print stacks"),
 304                                 rect, false, true, this, -1);
 305                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 306         }
 307
 308         {
 309                 core::rect < s32 > rect(0, 0, 100, 30);
 310                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 311                 this->dump = Environment->addButton(rect, this, GUI_ID_KEY_DUMP_BUTTON,
 312                                 wgettext(key_dump.name()));
 313         }
 314         {
 315                 core::rect < s32 > rect(0, 0, 100, 30);
 316                 rect += topleft + v2s32(size.X - 100 - 20, size.Y - 40);
 317                 Environment->addButton(rect, this, GUI_ID_BACK_BUTTON,
 318                 wgettext("Save"));
 319         }
 320         {
 321                 core::rect < s32 > rect(0, 0, 100, 30);
 322                 rect += topleft + v2s32(size.X - 100 - 20 - 100 - 20, size.Y - 40);
 323                 Environment->addButton(rect, this, GUI_ID_ABORT_BUTTON,
 324                 wgettext("Cancel"));
 325         }
 326         changeCtype("C");
 327 }
 328
 329 void GUIKeyChangeMenu::drawMenu()
 330 {
 331         gui::IGUISkin* skin = Environment->getSkin();
 332         if (!skin)
 333                 return;
 334         video::IVideoDriver* driver = Environment->getVideoDriver();
 335
 336         video::SColor bgcolor(140, 0, 0, 0);
 337
 338         {
 339                 core::rect < s32 > rect(0, 0, 620, 620);
 340                 rect += AbsoluteRect.UpperLeftCorner;
 341                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 342         }
 343
 344         gui::IGUIElement::draw();
 345 }
 346
 347 bool GUIKeyChangeMenu::acceptInput()
 348 {
 349         g_settings->set("keymap_forward", key_forward.sym());
 350         g_settings->set("keymap_backward", key_backward.sym());
 351         g_settings->set("keymap_left", key_left.sym());
 352         g_settings->set("keymap_right", key_right.sym());
 353         g_settings->set("keymap_jump", key_jump.sym());
 354         g_settings->set("keymap_sneak", key_sneak.sym());
 355         g_settings->set("keymap_inventory", key_inventory.sym());
 356         g_settings->set("keymap_chat", key_chat.sym());
 357         g_settings->set("keymap_cmd", key_cmd.sym());
 358         g_settings->set("keymap_rangeselect", key_range.sym());
 359         g_settings->set("keymap_freemove", key_fly.sym());
 360         g_settings->set("keymap_fastmove", key_fast.sym());
 361         g_settings->set("keymap_special1", key_use.sym());
 362         g_settings->set("keymap_print_debug_stacks", key_dump.sym());
 363         clearKeyCache();
 364         return true;
 365 }
 366 void GUIKeyChangeMenu::init_keys()
 367 {
 368         key_forward = getKeySetting("keymap_forward");
 369         key_backward = getKeySetting("keymap_backward");
 370         key_left = getKeySetting("keymap_left");
 371         key_right = getKeySetting("keymap_right");
 372         key_jump = getKeySetting("keymap_jump");
 373         key_sneak = getKeySetting("keymap_sneak");
 374         key_inventory = getKeySetting("keymap_inventory");
 375         key_chat = getKeySetting("keymap_chat");
 376         key_cmd = getKeySetting("keymap_cmd");
 377         key_range = getKeySetting("keymap_rangeselect");
 378         key_fly = getKeySetting("keymap_freemove");
 379         key_fast = getKeySetting("keymap_fastmove");
 380         key_use = getKeySetting("keymap_special1");
 381         key_dump = getKeySetting("keymap_print_debug_stacks");
 382 }
 383
 384 bool GUIKeyChangeMenu::resetMenu()
 385 {
 386         if (activeKey >= 0)
 387         {
 388                 switch (activeKey)
 389                 {
 390                 case GUI_ID_KEY_FORWARD_BUTTON:
 391                         this->forward->setText(
 392                                         wgettext(key_forward.name()));
 393                         break;
 394                 case GUI_ID_KEY_BACKWARD_BUTTON:
 395                         this->backward->setText(
 396                                         wgettext(key_backward.name()));
 397                         break;
 398                 case GUI_ID_KEY_LEFT_BUTTON:
 399                         this->left->setText(wgettext(key_left.name()));
 400                         break;
 401                 case GUI_ID_KEY_RIGHT_BUTTON:
 402                         this->right->setText(wgettext(key_right.name()));
 403                         break;
 404                 case GUI_ID_KEY_JUMP_BUTTON:
 405                         this->jump->setText(wgettext(key_jump.name()));
 406                         break;
 407                 case GUI_ID_KEY_SNEAK_BUTTON:
 408                         this->sneak->setText(wgettext(key_sneak.name()));
 409                         break;
 410                 case GUI_ID_KEY_INVENTORY_BUTTON:
 411                         this->inventory->setText(
 412                                         wgettext(key_inventory.name()));
 413                         break;
 414                 case GUI_ID_KEY_CHAT_BUTTON:
 415                         this->chat->setText(wgettext(key_chat.name()));
 416                         break;
 417                 case GUI_ID_KEY_CMD_BUTTON:
 418                         this->cmd->setText(wgettext(key_cmd.name()));
 419                         break;
 420                 case GUI_ID_KEY_RANGE_BUTTON:
 421                         this->range->setText(wgettext(key_range.name()));
 422                         break;
 423                 case GUI_ID_KEY_FLY_BUTTON:
 424                         this->fly->setText(wgettext(key_fly.name()));
 425                         break;
 426                 case GUI_ID_KEY_FAST_BUTTON:
 427                         this->fast->setText(wgettext(key_fast.name()));
 428                         break;
 429                 case GUI_ID_KEY_USE_BUTTON:
 430                         this->use->setText(wgettext(key_use.name()));
 431                         break;
 432                 case GUI_ID_KEY_DUMP_BUTTON:
 433                         this->dump->setText(wgettext(key_dump.name()));
 434                         break;
 435                 }
 436                 activeKey = -1;
 437                 return false;
 438         }
 439         return true;
 440 }
 441 bool GUIKeyChangeMenu::OnEvent(const SEvent& event)
 442 {
 443         if (event.EventType == EET_KEY_INPUT_EVENT && activeKey >= 0
 444                         && event.KeyInput.PressedDown)
 445         {
 446                 changeCtype("");
 447                 KeyPress kp(event.KeyInput);
 448
 449                 if (activeKey == GUI_ID_KEY_FORWARD_BUTTON)
 450                 {
 451                         this->forward->setText(wgettext(kp.name()));
 452                         this->key_forward = kp;
 453                 }
 454                 else if (activeKey == GUI_ID_KEY_BACKWARD_BUTTON)
 455                 {
 456                         this->backward->setText(wgettext(kp.name()));
 457                         this->key_backward = kp;
 458                 }
 459                 else if (activeKey == GUI_ID_KEY_LEFT_BUTTON)
 460                 {
 461                         this->left->setText(wgettext(kp.name()));
 462                         this->key_left = kp;
 463                 }
 464                 else if (activeKey == GUI_ID_KEY_RIGHT_BUTTON)
 465                 {
 466                         this->right->setText(wgettext(kp.name()));
 467                         this->key_right = kp;
 468                 }
 469                 else if (activeKey == GUI_ID_KEY_JUMP_BUTTON)
 470                 {
 471                         this->jump->setText(wgettext(kp.name()));
 472                         this->key_jump = kp;
 473                 }
 474                 else if (activeKey == GUI_ID_KEY_SNEAK_BUTTON)
 475                 {
 476                         this->sneak->setText(wgettext(kp.name()));
 477                         this->key_sneak = kp;
 478                 }
 479                 else if (activeKey == GUI_ID_KEY_INVENTORY_BUTTON)
 480                 {
 481                         this->inventory->setText(wgettext(kp.name()));
 482                         this->key_inventory = kp;
 483                 }
 484                 else if (activeKey == GUI_ID_KEY_CHAT_BUTTON)
 485                 {
 486                         this->chat->setText(wgettext(kp.name()));
 487                         this->key_chat = kp;
 488                 }
 489                 else if (activeKey == GUI_ID_KEY_CMD_BUTTON)
 490                 {
 491                         this->cmd->setText(wgettext(kp.name()));
 492                         this->key_cmd = kp;
 493                 }
 494                 else if (activeKey == GUI_ID_KEY_RANGE_BUTTON)
 495                 {
 496                         this->range->setText(wgettext(kp.name()));
 497                         this->key_range = kp;
 498                 }
 499                 else if (activeKey == GUI_ID_KEY_FLY_BUTTON)
 500                 {
 501                         this->fly->setText(wgettext(kp.name()));
 502                         this->key_fly = kp;
 503                 }
 504                 else if (activeKey == GUI_ID_KEY_FAST_BUTTON)
 505                 {
 506                         this->fast->setText(wgettext(kp.name()));
 507                         this->key_fast = kp;
 508                 }
 509                 else if (activeKey == GUI_ID_KEY_USE_BUTTON)
 510                 {
 511                         this->use->setText(wgettext(kp.name()));
 512                         this->key_use = kp;
 513                 }
 514                 else if (activeKey == GUI_ID_KEY_DUMP_BUTTON)
 515                 {
 516                         this->dump->setText(wgettext(kp.name()));
 517                         this->key_dump = kp;
 518                 }
 519                 changeCtype("C");
 520                 activeKey = -1;
 521                 return true;
 522         }
 523         if (event.EventType == EET_GUI_EVENT)
 524         {
 525                 if (event.GUIEvent.EventType == gui::EGET_ELEMENT_FOCUS_LOST
 526                                 && isVisible())
 527                 {
 528                         if (!canTakeFocus(event.GUIEvent.Element))
 529                         {
 530                                 dstream << "GUIMainMenu: Not allowing focus change."
 531                                                 << std::endl;
 532                                 // Returning true disables focus change
 533                                 return true;
 534                         }
 535                 }
 536                 if (event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED)
 537                 {
 538                         if(event.GUIEvent.Caller->getID() != GUI_ID_BACK_BUTTON &&
 539                                 event.GUIEvent.Caller->getID() != GUI_ID_ABORT_BUTTON)
 540                         {
 541                                 changeCtype("");
 542                         }
 543
 544                         switch (event.GUIEvent.Caller->getID())
 545                         {
 546                         case GUI_ID_BACK_BUTTON: //back
 547                                 acceptInput();
 548                                 quitMenu();
 549                                 return true;
 550                         case GUI_ID_ABORT_BUTTON: //abort
 551                                 quitMenu();
 552                                 return true;
 553                         case GUI_ID_KEY_FORWARD_BUTTON:
 554                                 resetMenu();
 555                                 activeKey = event.GUIEvent.Caller->getID();
 556                                 this->forward->setText(wgettext("press Key"));
 557                                 break;
 558                         case GUI_ID_KEY_BACKWARD_BUTTON:
 559                                 resetMenu();
 560                                 activeKey = event.GUIEvent.Caller->getID();
 561                                 this->backward->setText(wgettext("press Key"));
 562                                 break;
 563                         case GUI_ID_KEY_LEFT_BUTTON:
 564                                 resetMenu();
 565                                 activeKey = event.GUIEvent.Caller->getID();
 566                                 this->left->setText(wgettext("press Key"));
 567                                 break;
 568                         case GUI_ID_KEY_RIGHT_BUTTON:
 569                                 resetMenu();
 570                                 activeKey = event.GUIEvent.Caller->getID();
 571                                 this->right->setText(wgettext("press Key"));
 572                                 break;
 573                         case GUI_ID_KEY_USE_BUTTON:
 574                                 resetMenu();
 575                                 activeKey = event.GUIEvent.Caller->getID();
 576                                 this->use->setText(wgettext("press Key"));
 577                                 break;
 578                         case GUI_ID_KEY_FLY_BUTTON:
 579                                 resetMenu();
 580                                 activeKey = event.GUIEvent.Caller->getID();
 581                                 this->fly->setText(wgettext("press Key"));
 582                                 break;
 583                         case GUI_ID_KEY_FAST_BUTTON:
 584                                 resetMenu();
 585                                 activeKey = event.GUIEvent.Caller->getID();
 586                                 this->fast->setText(wgettext("press Key"));
 587                                 break;
 588                         case GUI_ID_KEY_JUMP_BUTTON:
 589                                 resetMenu();
 590                                 activeKey = event.GUIEvent.Caller->getID();
 591                                 this->jump->setText(wgettext("press Key"));
 592                                 break;
 593                         case GUI_ID_KEY_CHAT_BUTTON:
 594                                 resetMenu();
 595                                 activeKey = event.GUIEvent.Caller->getID();
 596                                 this->chat->setText(wgettext("press Key"));
 597                                 break;
 598                         case GUI_ID_KEY_CMD_BUTTON:
 599                                 resetMenu();
 600                                 activeKey = event.GUIEvent.Caller->getID();
 601                                 this->cmd->setText(wgettext("press Key"));
 602                                 break;
 603                         case GUI_ID_KEY_SNEAK_BUTTON:
 604                                 resetMenu();
 605                                 activeKey = event.GUIEvent.Caller->getID();
 606                                 this->sneak->setText(wgettext("press Key"));
 607                                 break;
 608                         case GUI_ID_KEY_INVENTORY_BUTTON:
 609                                 resetMenu();
 610                                 activeKey = event.GUIEvent.Caller->getID();
 611                                 this->inventory->setText(wgettext("press Key"));
 612                                 break;
 613                         case GUI_ID_KEY_DUMP_BUTTON:
 614                                 resetMenu();
 615                                 activeKey = event.GUIEvent.Caller->getID();
 616                                 this->dump->setText(wgettext("press Key"));
 617                                 break;
 618                         case GUI_ID_KEY_RANGE_BUTTON:
 619                                 resetMenu();
 620                                 activeKey = event.GUIEvent.Caller->getID();
 621                                 this->range->setText(wgettext("press Key"));
 622                                 break;
 623                         }
 624                         //Buttons
 625                         changeCtype("C");
 626
 627                 }
 628         }
 629         return Parent ? Parent->OnEvent(event) : false;
 630 }
 631