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