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