src/guiKeyChangeMenu.cpp

   1 /*
   2  Minetest-delta
   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
  80         {
  81                 core::rect < s32 > rect(0, 0, 125, 20);
  82                 rect += topleft + v2s32(25, 3);
  83                 const wchar_t *text = L"KEYBINDINGS";
  84                 //gui::IGUIStaticText *t =
  85                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Forward";
  95                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Backward";
 112                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Left";
 128                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Right";
 143                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Use";
 159                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Sneak";
 174                 Environment->addStaticText(text, 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                 const wchar_t *text = L"Jump";
 190                 Environment->addStaticText(text, rect, false, true, this, -1);
 191                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 192         }
 193
 194         {
 195                 core::rect < s32 > rect(0, 0, 100, 30);
 196                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 197                 this->jump = Environment->addButton(rect, this, GUI_ID_KEY_JUMP_BUTTON,
 198                                 narrow_to_wide(KeyNames[key_jump]).c_str());
 199         }
 200
 201         offset += v2s32(0, 25);
 202         {
 203                 core::rect < s32 > rect(0, 0, 100, 20);
 204                 rect += topleft + v2s32(offset.X, offset.Y);
 205                 const wchar_t *text = L"Inventory";
 206                 Environment->addStaticText(text, rect, false, true, this, -1);
 207                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 208         }
 209
 210         {
 211                 core::rect < s32 > rect(0, 0, 100, 30);
 212                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 213                 this->inventory = Environment->addButton(rect, this,
 214                                 GUI_ID_KEY_INVENTORY_BUTTON,
 215                                 narrow_to_wide(KeyNames[key_inventory]).c_str());
 216         }
 217         offset += v2s32(0, 25);
 218         {
 219                 core::rect < s32 > rect(0, 0, 100, 20);
 220                 rect += topleft + v2s32(offset.X, offset.Y);
 221                 const wchar_t *text = L"Chat";
 222                 Environment->addStaticText(text, rect, false, true, this, -1);
 223                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 224         }
 225
 226         {
 227                 core::rect < s32 > rect(0, 0, 100, 30);
 228                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 229                 this->chat = Environment->addButton(rect, this, GUI_ID_KEY_CHAT_BUTTON,
 230                                 narrow_to_wide(KeyNames[key_chat]).c_str());
 231         }
 232
 233         //next col
 234         offset = v2s32(250, 40);
 235         {
 236                 core::rect < s32 > rect(0, 0, 100, 20);
 237                 rect += topleft + v2s32(offset.X, offset.Y);
 238                 const wchar_t *text = L"Toggle fly";
 239                 Environment->addStaticText(text, 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->fly = Environment->addButton(rect, this, GUI_ID_KEY_FLY_BUTTON,
 247                                 narrow_to_wide(KeyNames[key_fly]).c_str());
 248         }
 249         offset += v2s32(0, 25);
 250         {
 251                 core::rect < s32 > rect(0, 0, 100, 20);
 252                 rect += topleft + v2s32(offset.X, offset.Y);
 253                 const wchar_t *text = L"Toggle fast";
 254                 Environment->addStaticText(text, rect, false, true, this, -1);
 255                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 256         }
 257
 258         {
 259                 core::rect < s32 > rect(0, 0, 100, 30);
 260                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 261                 this->fast = Environment->addButton(rect, this, GUI_ID_KEY_FAST_BUTTON,
 262                                 narrow_to_wide(KeyNames[key_fast]).c_str());
 263         }
 264         offset += v2s32(0, 25);
 265         {
 266                 core::rect < s32 > rect(0, 0, 100, 20);
 267                 rect += topleft + v2s32(offset.X, offset.Y);
 268                 const wchar_t *text = L"Range select";
 269                 Environment->addStaticText(text, rect, false, true, this, -1);
 270                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 271         }
 272
 273         {
 274                 core::rect < s32 > rect(0, 0, 100, 30);
 275                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 276                 this->range = Environment->addButton(rect, this,
 277                                 GUI_ID_KEY_RANGE_BUTTON,
 278                                 narrow_to_wide(KeyNames[key_range]).c_str());
 279         }
 280
 281         offset += v2s32(0, 25);
 282         {
 283                 core::rect < s32 > rect(0, 0, 100, 20);
 284                 rect += topleft + v2s32(offset.X, offset.Y);
 285                 const wchar_t *text = L"Print stacks";
 286                 Environment->addStaticText(text, rect, false, true, this, -1);
 287                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 288         }
 289
 290         {
 291                 core::rect < s32 > rect(0, 0, 100, 30);
 292                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 293                 this->dump = Environment->addButton(rect, this, GUI_ID_KEY_DUMP_BUTTON,
 294                                 narrow_to_wide(KeyNames[key_dump]).c_str());
 295         }
 296         {
 297                 core::rect < s32 > rect(0, 0, 100, 30);
 298                 rect += topleft + v2s32(size.X - 100 - 20, size.Y - 40);
 299                 Environment->addButton(rect, this, GUI_ID_BACK_BUTTON, L"Save");
 300         }
 301         {
 302                 core::rect < s32 > rect(0, 0, 100, 30);
 303                 rect += topleft + v2s32(size.X - 100 - 20 - 100 - 20, size.Y - 40);
 304                 Environment->addButton(rect, this, GUI_ID_ABORT_BUTTON, L"Cancel");
 305         }
 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", keycode_to_keyname(key_forward));
 329         g_settings.set("keymap_backward", keycode_to_keyname(key_backward));
 330         g_settings.set("keymap_left", keycode_to_keyname(key_left));
 331         g_settings.set("keymap_right", keycode_to_keyname(key_right));
 332         g_settings.set("keymap_jump", keycode_to_keyname(key_jump));
 333         g_settings.set("keymap_sneak", keycode_to_keyname(key_sneak));
 334         g_settings.set("keymap_inventory", keycode_to_keyname(key_inventory));
 335         g_settings.set("keymap_chat", keycode_to_keyname(key_chat));
 336         g_settings.set("keymap_rangeselect", keycode_to_keyname(key_range));
 337         g_settings.set("keymap_freemove", keycode_to_keyname(key_fly));
 338         g_settings.set("keymap_fastmove", keycode_to_keyname(key_fast));
 339         g_settings.set("keymap_special1", keycode_to_keyname(key_use));
 340         g_settings.set("keymap_print_debug_stacks", keycode_to_keyname(key_dump));
 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                                         narrow_to_wide(KeyNames[key_forward]).c_str());
 370                         break;
 371                 case GUI_ID_KEY_BACKWARD_BUTTON:
 372                         this->backward->setText(
 373                                         narrow_to_wide(KeyNames[key_backward]).c_str());
 374                         break;
 375                 case GUI_ID_KEY_LEFT_BUTTON:
 376                         this->left->setText(narrow_to_wide(KeyNames[key_left]).c_str());
 377                         break;
 378                 case GUI_ID_KEY_RIGHT_BUTTON:
 379                         this->right->setText(narrow_to_wide(KeyNames[key_right]).c_str());
 380                         break;
 381                 case GUI_ID_KEY_JUMP_BUTTON:
 382                         this->jump->setText(narrow_to_wide(KeyNames[key_jump]).c_str());
 383                         break;
 384                 case GUI_ID_KEY_SNEAK_BUTTON:
 385                         this->sneak->setText(narrow_to_wide(KeyNames[key_sneak]).c_str());
 386                         break;
 387                 case GUI_ID_KEY_INVENTORY_BUTTON:
 388                         this->inventory->setText(
 389                                         narrow_to_wide(KeyNames[key_inventory]).c_str());
 390                         break;
 391                 case GUI_ID_KEY_CHAT_BUTTON:
 392                         this->chat->setText(narrow_to_wide(KeyNames[key_chat]).c_str());
 393                         break;
 394                 case GUI_ID_KEY_RANGE_BUTTON:
 395                         this->range->setText(narrow_to_wide(KeyNames[key_range]).c_str());
 396                         break;
 397                 case GUI_ID_KEY_FLY_BUTTON:
 398                         this->fly->setText(narrow_to_wide(KeyNames[key_fly]).c_str());
 399                         break;
 400                 case GUI_ID_KEY_FAST_BUTTON:
 401                         this->fast->setText(narrow_to_wide(KeyNames[key_fast]).c_str());
 402                         break;
 403                 case GUI_ID_KEY_USE_BUTTON:
 404                         this->use->setText(narrow_to_wide(KeyNames[key_use]).c_str());
 405                         break;
 406                 case GUI_ID_KEY_DUMP_BUTTON:
 407                         this->dump->setText(narrow_to_wide(KeyNames[key_dump]).c_str());
 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                 if (activeKey == GUI_ID_KEY_FORWARD_BUTTON)
 421                 {
 422                         this->forward->setText(
 423                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 424                         this->key_forward = event.KeyInput.Key;
 425                 }
 426                 else if (activeKey == GUI_ID_KEY_BACKWARD_BUTTON)
 427                 {
 428                         this->backward->setText(
 429                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 430                         this->key_backward = event.KeyInput.Key;
 431                 }
 432                 else if (activeKey == GUI_ID_KEY_LEFT_BUTTON)
 433                 {
 434                         this->left->setText(
 435                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 436                         this->key_left = event.KeyInput.Key;
 437                 }
 438                 else if (activeKey == GUI_ID_KEY_RIGHT_BUTTON)
 439                 {
 440                         this->right->setText(
 441                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 442                         this->key_right = event.KeyInput.Key;
 443                 }
 444                 else if (activeKey == GUI_ID_KEY_JUMP_BUTTON)
 445                 {
 446                         this->jump->setText(
 447                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 448                         this->key_jump = event.KeyInput.Key;
 449                 }
 450                 else if (activeKey == GUI_ID_KEY_SNEAK_BUTTON)
 451                 {
 452                         this->sneak->setText(
 453                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 454                         this->key_sneak = event.KeyInput.Key;
 455                 }
 456                 else if (activeKey == GUI_ID_KEY_INVENTORY_BUTTON)
 457                 {
 458                         this->inventory->setText(
 459                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 460                         this->key_inventory = event.KeyInput.Key;
 461                 }
 462                 else if (activeKey == GUI_ID_KEY_CHAT_BUTTON)
 463                 {
 464                         this->chat->setText(
 465                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 466                         this->key_chat = event.KeyInput.Key;
 467                 }
 468                 else if (activeKey == GUI_ID_KEY_RANGE_BUTTON)
 469                 {
 470                         this->range->setText(
 471                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 472                         this->key_range = event.KeyInput.Key;
 473                 }
 474                 else if (activeKey == GUI_ID_KEY_FLY_BUTTON)
 475                 {
 476                         this->fly->setText(
 477                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 478                         this->key_fly = event.KeyInput.Key;
 479                 }
 480                 else if (activeKey == GUI_ID_KEY_FAST_BUTTON)
 481                 {
 482                         this->fast->setText(
 483                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 484                         this->key_fast = event.KeyInput.Key;
 485                 }
 486                 else if (activeKey == GUI_ID_KEY_USE_BUTTON)
 487                 {
 488                         this->use->setText(
 489                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 490                         this->key_use = event.KeyInput.Key;
 491                 }
 492                 else if (activeKey == GUI_ID_KEY_DUMP_BUTTON)
 493                 {
 494                         this->dump->setText(
 495                                         narrow_to_wide(KeyNames[event.KeyInput.Key]).c_str());
 496                         this->key_dump = event.KeyInput.Key;
 497                 }
 498
 499                 activeKey = -1;
 500                 return true;
 501         }
 502         if (event.EventType == EET_GUI_EVENT)
 503         {
 504                 if (event.GUIEvent.EventType == gui::EGET_ELEMENT_FOCUS_LOST
 505                                 && isVisible())
 506                 {
 507                         if (!canTakeFocus(event.GUIEvent.Element))
 508                         {
 509                                 dstream << "GUIMainMenu: Not allowing focus change."
 510                                                 << std::endl;
 511                                 // Returning true disables focus change
 512                                 return true;
 513                         }
 514                 }
 515                 if (event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED)
 516                 {
 517                         switch (event.GUIEvent.Caller->getID())
 518                         {
 519                         case GUI_ID_BACK_BUTTON: //back
 520                                 acceptInput();
 521                                 quitMenu();
 522                                 return true;
 523                         case GUI_ID_ABORT_BUTTON: //abort
 524                                 quitMenu();
 525                                 return true;
 526                         case GUI_ID_KEY_FORWARD_BUTTON:
 527                                 resetMenu();
 528                                 activeKey = event.GUIEvent.Caller->getID();
 529                                 this->forward->setText(L"press Key");
 530                                 break;
 531                         case GUI_ID_KEY_BACKWARD_BUTTON:
 532                                 resetMenu();
 533                                 activeKey = event.GUIEvent.Caller->getID();
 534                                 this->backward->setText(L"press Key");
 535                                 break;
 536                         case GUI_ID_KEY_LEFT_BUTTON:
 537                                 resetMenu();
 538                                 activeKey = event.GUIEvent.Caller->getID();
 539                                 this->left->setText(L"press Key");
 540                                 break;
 541                         case GUI_ID_KEY_RIGHT_BUTTON:
 542                                 resetMenu();
 543                                 activeKey = event.GUIEvent.Caller->getID();
 544                                 this->right->setText(L"press Key");
 545                                 break;
 546                         case GUI_ID_KEY_USE_BUTTON:
 547                                 resetMenu();
 548                                 activeKey = event.GUIEvent.Caller->getID();
 549                                 this->use->setText(L"press Key");
 550                                 break;
 551                         case GUI_ID_KEY_FLY_BUTTON:
 552                                 resetMenu();
 553                                 activeKey = event.GUIEvent.Caller->getID();
 554                                 this->fly->setText(L"press Key");
 555                                 break;
 556                         case GUI_ID_KEY_FAST_BUTTON:
 557                                 resetMenu();
 558                                 activeKey = event.GUIEvent.Caller->getID();
 559                                 this->fast->setText(L"press Key");
 560                                 break;
 561                         case GUI_ID_KEY_JUMP_BUTTON:
 562                                 resetMenu();
 563                                 activeKey = event.GUIEvent.Caller->getID();
 564                                 this->jump->setText(L"press Key");
 565                                 break;
 566                         case GUI_ID_KEY_CHAT_BUTTON:
 567                                 resetMenu();
 568                                 activeKey = event.GUIEvent.Caller->getID();
 569                                 this->chat->setText(L"press Key");
 570                                 break;
 571                         case GUI_ID_KEY_SNEAK_BUTTON:
 572                                 resetMenu();
 573                                 activeKey = event.GUIEvent.Caller->getID();
 574                                 this->sneak->setText(L"press Key");
 575                                 break;
 576                         case GUI_ID_KEY_INVENTORY_BUTTON:
 577                                 resetMenu();
 578                                 activeKey = event.GUIEvent.Caller->getID();
 579                                 this->inventory->setText(L"press Key");
 580                                 break;
 581                         case GUI_ID_KEY_DUMP_BUTTON:
 582                                 resetMenu();
 583                                 activeKey = event.GUIEvent.Caller->getID();
 584                                 this->dump->setText(L"press Key");
 585                                 break;
 586                         case GUI_ID_KEY_RANGE_BUTTON:
 587                                 resetMenu();
 588                                 activeKey = event.GUIEvent.Caller->getID();
 589                                 this->range->setText(L"press Key");
 590                                 break;
 591                         }
 592                         //Buttons
 593
 594                 }
 595         }
 596         return Parent ? Parent->OnEvent(event) : false;
 597 }
 598