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