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