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
  80         {
  81                 core::rect < s32 > rect(0, 0, 125, 20);
  82                 rect += topleft + v2s32(25, 3);
  83                 //gui::IGUIStaticText *t =
  84                 Environment->addStaticText(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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(chartowchar_t(gettext("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                 const wchar_t *text = L"Range select";
 267                 Environment->addStaticText(chartowchar_t(gettext("Range select")),
 268                                 rect, false, true, this, -1);
 269                 //t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 270         }
 271
 272         {
 273                 core::rect < s32 > rect(0, 0, 100, 30);
 274                 rect += topleft + v2s32(offset.X + 105, offset.Y - 5);
 275                 this->range = Environment->addButton(rect, this,
 276                                 GUI_ID_KEY_RANGE_BUTTON,
 277                                 narrow_to_wide(KeyNames[key_range]).c_str());
 278         }
 279
 280         offset += v2s32(0, 25);
 281         {
 282                 core::rect < s32 > rect(0, 0, 100, 20);
 283                 rect += topleft + v2s32(offset.X, offset.Y);
 284                 const wchar_t *text = L"Print stacks";
 285                 Environment->addStaticText(chartowchar_t(gettext("Print stacks")),
 286                                 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,
 300                 chartowchar_t(gettext("Save")));
 301         }
 302         {
 303                 core::rect < s32 > rect(0, 0, 100, 30);
 304                 rect += topleft + v2s32(size.X - 100 - 20 - 100 - 20, size.Y - 40);
 305                 Environment->addButton(rect, this, GUI_ID_ABORT_BUTTON,
 306                 chartowchar_t(gettext("Cancel")));
 307         }
 308 }
 309
 310 void GUIKeyChangeMenu::drawMenu()
 311 {
 312         gui::IGUISkin* skin = Environment->getSkin();
 313         if (!skin)
 314                 return;
 315         video::IVideoDriver* driver = Environment->getVideoDriver();
 316
 317         video::SColor bgcolor(140, 0, 0, 0);
 318
 319         {
 320                 core::rect < s32 > rect(0, 0, 620, 620);
 321                 rect += AbsoluteRect.UpperLeftCorner;
 322                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 323         }
 324
 325         gui::IGUIElement::draw();
 326 }
 327
 328 bool GUIKeyChangeMenu::acceptInput()
 329 {
 330         g_settings.set("keymap_forward", keycode_to_keyname(key_forward));
 331         g_settings.set("keymap_backward", keycode_to_keyname(key_backward));
 332         g_settings.set("keymap_left", keycode_to_keyname(key_left));
 333         g_settings.set("keymap_right", keycode_to_keyname(key_right));
 334         g_settings.set("keymap_jump", keycode_to_keyname(key_jump));
 335         g_settings.set("keymap_sneak", keycode_to_keyname(key_sneak));
 336         g_settings.set("keymap_inventory", keycode_to_keyname(key_inventory));
 337         g_settings.set("keymap_chat", keycode_to_keyname(key_chat));
 338         g_settings.set("keymap_rangeselect", keycode_to_keyname(key_range));
 339         g_settings.set("keymap_freemove", keycode_to_keyname(key_fly));
 340         g_settings.set("keymap_fastmove", keycode_to_keyname(key_fast));
 341         g_settings.set("keymap_special1", keycode_to_keyname(key_use));
 342         g_settings.set("keymap_print_debug_stacks", keycode_to_keyname(key_dump));
 343         clearKeyCache();
 344         return true;
 345 }
 346 void GUIKeyChangeMenu::init_keys()
 347 {
 348         key_forward = getKeySetting("keymap_forward");
 349         key_backward = getKeySetting("keymap_backward");
 350         key_left = getKeySetting("keymap_left");
 351         key_right = getKeySetting("keymap_right");
 352         key_jump = getKeySetting("keymap_jump");
 353         key_sneak = getKeySetting("keymap_sneak");
 354         key_inventory = getKeySetting("keymap_inventory");
 355         key_chat = getKeySetting("keymap_chat");
 356         key_range = getKeySetting("keymap_rangeselect");
 357         key_fly = getKeySetting("keymap_freemove");
 358         key_fast = getKeySetting("keymap_fastmove");
 359         key_use = getKeySetting("keymap_special1");
 360         key_dump = getKeySetting("keymap_print_debug_stacks");
 361 }
 362
 363 bool GUIKeyChangeMenu::resetMenu()
 364 {
 365         if (activeKey >= 0)
 366         {
 367                 switch (activeKey)
 368                 {
 369                 case GUI_ID_KEY_FORWARD_BUTTON:
 370                         this->forward->setText(
 371                                         narrow_to_wide(KeyNames[key_forward]).c_str());
 372                         break;
 373                 case GUI_ID_KEY_BACKWARD_BUTTON:
 374                         this->backward->setText(
 375                                         narrow_to_wide(KeyNames[key_backward]).c_str());
 376                         break;
 377                 case GUI_ID_KEY_LEFT_BUTTON:
 378                         this->left->setText(narrow_to_wide(KeyNames[key_left]).c_str());
 379                         break;
 380                 case GUI_ID_KEY_RIGHT_BUTTON:
 381                         this->right->setText(narrow_to_wide(KeyNames[key_right]).c_str());
 382                         break;
 383                 case GUI_ID_KEY_JUMP_BUTTON:
 384                         this->jump->setText(narrow_to_wide(KeyNames[key_jump]).c_str());
 385                         break;
 386                 case GUI_ID_KEY_SNEAK_BUTTON:
 387                         this->sneak->setText(narrow_to_wide(KeyNames[key_sneak]).c_str());
 388                         break;
 389                 case GUI_ID_KEY_INVENTORY_BUTTON:
 390                         this->inventory->setText(
 391                                         narrow_to_wide(KeyNames[key_inventory]).c_str());
 392                         break;
 393                 case GUI_ID_KEY_CHAT_BUTTON:
 394                         this->chat->setText(narrow_to_wide(KeyNames[key_chat]).c_str());
 395                         break;
 396                 case GUI_ID_KEY_RANGE_BUTTON:
 397                         this->range->setText(narrow_to_wide(KeyNames[key_range]).c_str());
 398                         break;
 399                 case GUI_ID_KEY_FLY_BUTTON:
 400                         this->fly->setText(narrow_to_wide(KeyNames[key_fly]).c_str());
 401                         break;
 402                 case GUI_ID_KEY_FAST_BUTTON:
 403                         this->fast->setText(narrow_to_wide(KeyNames[key_fast]).c_str());
 404                         break;
 405                 case GUI_ID_KEY_USE_BUTTON:
 406                         this->use->setText(narrow_to_wide(KeyNames[key_use]).c_str());
 407                         break;
 408                 case GUI_ID_KEY_DUMP_BUTTON:
 409                         this->dump->setText(narrow_to_wide(KeyNames[key_dump]).c_str());
 410                         break;
 411                 }
 412                 activeKey = -1;
 413                 return false;
 414         }
 415         return true;
 416 }
 417 bool GUIKeyChangeMenu::OnEvent(const SEvent& event)
 418 {
 419         if (event.EventType == EET_KEY_INPUT_EVENT && activeKey >= 0
 420                         && event.KeyInput.PressedDown)
 421         {
 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
 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                         switch (event.GUIEvent.Caller->getID())
 520                         {
 521                         case GUI_ID_BACK_BUTTON: //back
 522                                 acceptInput();
 523                                 quitMenu();
 524                                 return true;
 525                         case GUI_ID_ABORT_BUTTON: //abort
 526                                 quitMenu();
 527                                 return true;
 528                         case GUI_ID_KEY_FORWARD_BUTTON:
 529                                 resetMenu();
 530                                 activeKey = event.GUIEvent.Caller->getID();
 531                                 this->forward->setText(chartowchar_t(gettext("press Key")));
 532                                 break;
 533                         case GUI_ID_KEY_BACKWARD_BUTTON:
 534                                 resetMenu();
 535                                 activeKey = event.GUIEvent.Caller->getID();
 536                                 this->backward->setText(chartowchar_t(gettext("press Key")));
 537                                 break;
 538                         case GUI_ID_KEY_LEFT_BUTTON:
 539                                 resetMenu();
 540                                 activeKey = event.GUIEvent.Caller->getID();
 541                                 this->left->setText(chartowchar_t(gettext("press Key")));
 542                                 break;
 543                         case GUI_ID_KEY_RIGHT_BUTTON:
 544                                 resetMenu();
 545                                 activeKey = event.GUIEvent.Caller->getID();
 546                                 this->right->setText(chartowchar_t(gettext("press Key")));
 547                                 break;
 548                         case GUI_ID_KEY_USE_BUTTON:
 549                                 resetMenu();
 550                                 activeKey = event.GUIEvent.Caller->getID();
 551                                 this->use->setText(chartowchar_t(gettext("press Key")));
 552                                 break;
 553                         case GUI_ID_KEY_FLY_BUTTON:
 554                                 resetMenu();
 555                                 activeKey = event.GUIEvent.Caller->getID();
 556                                 this->fly->setText(chartowchar_t(gettext("press Key")));
 557                                 break;
 558                         case GUI_ID_KEY_FAST_BUTTON:
 559                                 resetMenu();
 560                                 activeKey = event.GUIEvent.Caller->getID();
 561                                 this->fast->setText(chartowchar_t(gettext("press Key")));
 562                                 break;
 563                         case GUI_ID_KEY_JUMP_BUTTON:
 564                                 resetMenu();
 565                                 activeKey = event.GUIEvent.Caller->getID();
 566                                 this->jump->setText(chartowchar_t(gettext("press Key")));
 567                                 break;
 568                         case GUI_ID_KEY_CHAT_BUTTON:
 569                                 resetMenu();
 570                                 activeKey = event.GUIEvent.Caller->getID();
 571                                 this->chat->setText(chartowchar_t(gettext("press Key")));
 572                                 break;
 573                         case GUI_ID_KEY_SNEAK_BUTTON:
 574                                 resetMenu();
 575                                 activeKey = event.GUIEvent.Caller->getID();
 576                                 this->sneak->setText(chartowchar_t(gettext("press Key")));
 577                                 break;
 578                         case GUI_ID_KEY_INVENTORY_BUTTON:
 579                                 resetMenu();
 580                                 activeKey = event.GUIEvent.Caller->getID();
 581                                 this->inventory->setText(chartowchar_t(gettext("press Key")));
 582                                 break;
 583                         case GUI_ID_KEY_DUMP_BUTTON:
 584                                 resetMenu();
 585                                 activeKey = event.GUIEvent.Caller->getID();
 586                                 this->dump->setText(chartowchar_t(gettext("press Key")));
 587                                 break;
 588                         case GUI_ID_KEY_RANGE_BUTTON:
 589                                 resetMenu();
 590                                 activeKey = event.GUIEvent.Caller->getID();
 591                                 this->range->setText(chartowchar_t(gettext("press Key")));
 592                                 break;
 593                         }
 594                         //Buttons
 595
 596                 }
 597         }
 598         return Parent ? Parent->OnEvent(event) : false;
 599 }
 600