gui/editable.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (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
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  */
  24
  25 #include "common/events.h"
  26 #include "gui/editable.h"
  27 #include "gui/GuiManager.h"
  28
  29 namespace GUI {
  30
  31 EditableWidget::EditableWidget(GuiObject *boss, int x, int y, int w, int h, uint32 cmd)
  32  : Widget(boss, x, y, w, h), CommandSender(boss), _cmd(cmd) {
  33         init();
  34 }
  35
  36 EditableWidget::EditableWidget(GuiObject *boss, const String &name, uint32 cmd)
  37  : Widget(boss, name), CommandSender(boss), _cmd(cmd) {
  38         init();
  39 }
  40
  41 void EditableWidget::init() {
  42         _caretVisible = false;
  43         _caretTime = 0;
  44         _caretPos = 0;
  45
  46         _caretInverse = false;
  47
  48         _editScrollOffset = 0;
  49
  50         _font = ThemeEngine::kFontStyleBold;
  51 }
  52
  53 EditableWidget::~EditableWidget() {
  54 }
  55
  56 void EditableWidget::reflowLayout() {
  57         Widget::reflowLayout();
  58
  59         _editScrollOffset = g_gui.getStringWidth(_editString, _font) - getEditRect().width();
  60         if (_editScrollOffset < 0)
  61                 _editScrollOffset = 0;
  62 }
  63
  64 void EditableWidget::setEditString(const String &str) {
  65         // TODO: We probably should filter the input string here,
  66         // e.g. using tryInsertChar.
  67         _editString = str;
  68         _caretPos = _editString.size();
  69 }
  70
  71 bool EditableWidget::tryInsertChar(byte c, int pos) {
  72         if ((c >= 32 && c <= 127) || c >= 160) {
  73                 _editString.insertChar(c, pos);
  74                 return true;
  75         }
  76         return false;
  77 }
  78
  79 void EditableWidget::handleTickle() {
  80         uint32 time = getMillis();
  81         if (_caretTime < time) {
  82                 _caretTime = time + kCaretBlinkTime;
  83                 drawCaret(_caretVisible);
  84         }
  85 }
  86
  87 bool EditableWidget::handleKeyDown(Common::KeyState state) {
  88         bool handled = true;
  89         bool dirty = false;
  90         bool forcecaret = false;
  91
  92         // First remove caret
  93         if (_caretVisible)
  94                 drawCaret(true);
  95
  96         switch (state.keycode) {
  97         case Common::KEYCODE_RETURN:
  98         case Common::KEYCODE_KP_ENTER:
  99                 // confirm edit and exit editmode
 100                 endEditMode();
 101                 dirty = true;
 102                 break;
 103         case Common::KEYCODE_ESCAPE:
 104                 abortEditMode();
 105                 dirty = true;
 106                 break;
 107         case Common::KEYCODE_BACKSPACE:
 108                 if (_caretPos > 0) {
 109                         _caretPos--;
 110                         _editString.deleteChar(_caretPos);
 111                         dirty = true;
 112
 113                         sendCommand(_cmd, 0);
 114                 }
 115                 forcecaret = true;
 116                 break;
 117         case Common::KEYCODE_DELETE:
 118                 if (_caretPos < (int)_editString.size()) {
 119                         _editString.deleteChar(_caretPos);
 120                         dirty = true;
 121
 122                         sendCommand(_cmd, 0);
 123                 }
 124                 forcecaret = true;
 125                 break;
 126         case Common::KEYCODE_LEFT:
 127                 if (_caretPos > 0) {
 128                         dirty = setCaretPos(_caretPos - 1);
 129                 }
 130                 forcecaret = true;
 131                 dirty = true;
 132                 break;
 133         case Common::KEYCODE_RIGHT:
 134                 if (_caretPos < (int)_editString.size()) {
 135                         dirty = setCaretPos(_caretPos + 1);
 136                 }
 137                 forcecaret = true;
 138                 dirty = true;
 139                 break;
 140         case Common::KEYCODE_HOME:
 141                 dirty = setCaretPos(0);
 142                 forcecaret = true;
 143                 break;
 144         case Common::KEYCODE_END:
 145                 dirty = setCaretPos(_editString.size());
 146                 forcecaret = true;
 147                 break;
 148         default:
 149                 if (tryInsertChar((byte)state.ascii, _caretPos)) {
 150                         _caretPos++;
 151                         dirty = true;
 152                         forcecaret = true;
 153
 154                         sendCommand(_cmd, 0);
 155                 } else {
 156                         handled = false;
 157                 }
 158         }
 159
 160         if (dirty)
 161                 draw();
 162
 163         if (forcecaret)
 164                 makeCaretVisible();
 165
 166         return handled;
 167 }
 168
 169 int EditableWidget::getCaretOffset() const {
 170         int caretpos = 0;
 171         for (int i = 0; i < _caretPos; i++)
 172                 caretpos += g_gui.getCharWidth(_editString[i], _font);
 173
 174         caretpos -= _editScrollOffset;
 175
 176         return caretpos;
 177 }
 178
 179 void EditableWidget::drawCaret(bool erase) {
 180         // Only draw if item is visible
 181         if (!isVisible() || !_boss->isVisible())
 182                 return;
 183
 184         Common::Rect editRect = getEditRect();
 185
 186         int x = editRect.left;
 187         int y = editRect.top + 1;
 188
 189         x += getCaretOffset();
 190
 191         if (y < 0 || y + editRect.height() - 2 >= _h)
 192                 return;
 193
 194         x += getAbsX();
 195         y += getAbsY();
 196
 197         g_gui.theme()->drawCaret(Common::Rect(x, y, x + 1, y + editRect.height() - 2), erase);
 198
 199         _caretVisible = !erase;
 200 }
 201
 202 bool EditableWidget::setCaretPos(int newPos) {
 203         assert(newPos >= 0 && newPos <= (int)_editString.size());
 204         _caretPos = newPos;
 205         return adjustOffset();
 206 }
 207
 208 bool EditableWidget::adjustOffset() {
 209         // check if the caret is still within the textbox; if it isn't,
 210         // adjust _editScrollOffset
 211
 212         int caretpos = getCaretOffset();
 213         const int editWidth = getEditRect().width();
 214
 215         if (caretpos < 0) {
 216                 // scroll left
 217                 _editScrollOffset += caretpos;
 218                 return true;
 219         } else if (caretpos >= editWidth) {
 220                 // scroll right
 221                 _editScrollOffset -= (editWidth - caretpos);
 222                 return true;
 223         } else if (_editScrollOffset > 0) {
 224                 const int strWidth = g_gui.getStringWidth(_editString, _font);
 225                 if (strWidth - _editScrollOffset < editWidth) {
 226                         // scroll right
 227                         _editScrollOffset = (strWidth - editWidth);
 228                         if (_editScrollOffset < 0)
 229                                 _editScrollOffset = 0;
 230                 }
 231         }
 232
 233         return false;
 234 }
 235
 236 void EditableWidget::makeCaretVisible() {
 237         _caretTime = getMillis() + kCaretBlinkTime;
 238         _caretVisible = true;
 239         drawCaret(false);
 240 }
 241
 242 } // End of namespace GUI