gui/console.h

   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 #ifndef CONSOLE_DIALOG_H
  26 #define CONSOLE_DIALOG_H
  27
  28 #include "gui/dialog.h"
  29 #include "gui/GuiManager.h"
  30
  31 namespace GUI {
  32
  33 class ScrollBarWidget;
  34
  35 /*
  36  FIXME #1: The console dialog code has some fundamental problems.
  37  First of, note the conflict between the (constant) value kCharsPerLine, and the
  38  (variable) value _pageWidth. Look a bit at the code get familiar with them,
  39  then return...
  40  Now, why don't we just drop kCharsPerLine? Because of the problem of resizing!
  41  When the user changes the scaler, the console will get resized. If the dialog
  42  becomes smaller because of this, we may have to rewrap text. If the resolution
  43  is then increased again, we'd end up with garbled content.
  44
  45  One can now either ignore this problem (and modify our code accordingly to
  46  implement this simple rewrapping -- we currently don't do that at all!).
  47
  48  Or, one can go and implement a more complete console, by replacing the
  49  _buffer by a real line buffer -- an array of char* pointers.
  50  This will allow one to implement resizing perfectly, but has the drawback
  51  of making things like scrolling, drawing etc. more complicated.
  52
  53  Either way, the current situation is bad, and we should resolve it one way
  54  or the other (and if you can think of a thirds, feel free to suggest it).
  55
  56
  57
  58  FIXME #2: Another problem is that apparently _pageWidth isn't computed quite
  59  correctly. The current line ends well before reaching the right side of the
  60  console dialog. That's irritating and should be fixed.
  61
  62
  63  FIXME #3: The scroll bar is not shown initially, but the area it would
  64  occupy is not used for anything else. As a result, the gap described above
  65  becomes even wider and thus even more irritating.
  66 */
  67 class ConsoleDialog : public Dialog {
  68 public:
  69         typedef bool (*InputCallbackProc)(ConsoleDialog *console, const char *input, void *refCon);
  70         typedef bool (*CompletionCallbackProc)(ConsoleDialog* console, const char *input, Common::String &completion, void *refCon);
  71
  72 protected:
  73         enum {
  74                 kBufferSize     = 32768,
  75                 kCharsPerLine = 128,
  76                 kLineBufferSize = 256,
  77
  78                 kHistorySize = 20
  79         };
  80
  81         const Graphics::Font *_font;
  82
  83         char    _buffer[kBufferSize];
  84         int             _linesInBuffer;
  85
  86         int             _pageWidth;
  87         int             _linesPerPage;
  88
  89         int             _currentPos;
  90         int             _scrollLine;
  91         int             _firstLineInBuffer;
  92
  93         int             _promptStartPos;
  94         int             _promptEndPos;
  95
  96         bool    _caretVisible;
  97         uint32  _caretTime;
  98
  99         enum SlideMode {
 100                 kNoSlideMode,
 101                 kUpSlideMode,
 102                 kDownSlideMode
 103         };
 104
 105         SlideMode       _slideMode;
 106         uint32  _slideTime;
 107
 108         ScrollBarWidget *_scrollBar;
 109
 110         // The _callbackProc is called whenver a data line is entered
 111         //
 112         InputCallbackProc _callbackProc;
 113         void *_callbackRefCon;
 114
 115         // _completionCallbackProc is called when tab is pressed
 116         CompletionCallbackProc _completionCallbackProc;
 117         void *_completionCallbackRefCon;
 118
 119         char _history[kHistorySize][kLineBufferSize];
 120         int _historySize;
 121         int _historyIndex;
 122         int _historyLine;
 123
 124         float _widthPercent, _heightPercent;
 125
 126         int     _leftPadding;
 127         int     _rightPadding;
 128         int     _topPadding;
 129         int     _bottomPadding;
 130
 131         void slideUpAndClose();
 132
 133 public:
 134         ConsoleDialog(float widthPercent, float heightPercent);
 135
 136         void open();
 137         void close();
 138         void drawDialog();
 139
 140         void handleTickle();
 141         void reflowLayout();
 142         void handleMouseWheel(int x, int y, int direction);
 143         void handleKeyDown(Common::KeyState state);
 144         void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
 145
 146         int printf(const char *format, ...) GCC_PRINTF(2, 3);
 147         int vprintf(const char *format, va_list argptr);
 148 #undef putchar
 149         void putchar(int c);
 150
 151         void setInputCallback(InputCallbackProc proc, void *refCon) {
 152                 _callbackProc = proc;
 153                 _callbackRefCon = refCon;
 154         }
 155         void setCompletionCallback(CompletionCallbackProc proc, void *refCon) {
 156                 _completionCallbackProc = proc;
 157                 _completionCallbackRefCon = refCon;
 158         }
 159
 160         int getCharsPerLine() {
 161                 return _pageWidth;
 162         }
 163
 164 protected:
 165         inline char &buffer(int idx) {
 166                 return _buffer[idx % kBufferSize];
 167         }
 168
 169         void init();
 170
 171         int pos2line(int pos) { return (pos - (_scrollLine - _linesPerPage + 1) * kCharsPerLine) / kCharsPerLine; }
 172
 173         void drawLine(int line, bool restoreBg = true);
 174         void drawCaret(bool erase);
 175         void putcharIntern(int c);
 176         void insertIntoPrompt(const char *str);
 177         void print(const char *str);
 178         void updateScrollBuffer();
 179         void scrollToCurrent();
 180
 181         // Line editing
 182         void specialKeys(int keycode);
 183         void nextLine();
 184         void killChar();
 185         void killLine();
 186         void killLastWord();
 187
 188         // History
 189         void addToHistory(const char *str);
 190         void historyScroll(int direction);
 191 };
 192
 193 } // End of namespace GUI
 194
 195 #endif