gemrb/core/GUI/Console.cpp

   1 /* GemRB - Infinity Engine Emulator
   2  * Copyright (C) 2003 The GemRB Project
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *
  19  */
  20
  21 #include "GUI/Console.h"
  22
  23 #include "win32def.h"
  24
  25 #include "GameData.h"
  26 #include "Interface.h"
  27 #include "Palette.h"
  28 #include "ScriptEngine.h"
  29 #include "Video.h"
  30
  31 Console::Console(void)
  32 {
  33         Cursor = NULL;
  34         Back = NULL;
  35         max = 128;
  36         Buffer = ( unsigned char * ) malloc( max );
  37         Buffer[0] = 0;
  38         for(size_t i=0;i<HISTORY_SIZE;i++) {
  39                 History[i] = ( unsigned char * ) malloc( max );
  40                 History[i][0] = 0;
  41         }
  42         CurPos = 0;
  43         HistPos = 0;
  44         HistMax = 0;
  45         palette = NULL;
  46 }
  47
  48 Console::~Console(void)
  49 {
  50         free( Buffer );
  51         for (size_t i=0;i<HISTORY_SIZE;i++) {
  52                 free( History[i] );
  53         }
  54         Video *video = core->GetVideoDriver();
  55
  56         gamedata->FreePalette( palette );
  57         video->FreeSprite( Cursor );
  58 }
  59
  60 /** Draws the Console on the Output Display */
  61 void Console::Draw(unsigned short x, unsigned short y)
  62 {
  63         if (Back) {
  64                 core->GetVideoDriver()->BlitSprite( Back, 0, y, true );
  65         }
  66         Color black = {
  67                 0x00, 0x00, 0x00, 0xff
  68         };
  69         Region r( x + XPos, y + YPos, Width, Height );
  70         core->GetVideoDriver()->DrawRect( r, black );
  71         font->Print( r, Buffer, palette,
  72                         IE_FONT_ALIGN_LEFT | IE_FONT_ALIGN_MIDDLE, true, NULL,
  73                         Cursor, CurPos, true );
  74 }
  75 /** Set Font */
  76 void Console::SetFont(Font* f)
  77 {
  78         if (f != NULL) {
  79                 font = f;
  80         }
  81 }
  82 /** Set Cursor */
  83 void Console::SetCursor(Sprite2D* cur)
  84 {
  85         if (cur != NULL) {
  86                 Cursor = cur;
  87         }
  88 }
  89 /** Set BackGround */
  90 void Console::SetBackGround(Sprite2D* back)
  91 {
  92         //if 'back' is NULL then no BackGround will be drawn
  93         Back = back;
  94 }
  95 /** Sets the Text of the current control */
  96 int Console::SetText(const char* string, int /*pos*/)
  97 {
  98         strncpy( ( char * ) Buffer, string, max );
  99         return 0;
 100 }
 101 /** Key Press Event */
 102 void Console::OnKeyPress(unsigned char Key, unsigned short /*Mod*/)
 103 {
 104         if (Key >= 0x20) {
 105                 size_t len = strlen( ( char* ) Buffer );
 106                 if (len + 1 < max) {
 107                         for (size_t i = len; i > CurPos; i--) {
 108                                 Buffer[i] = Buffer[i - 1];
 109                         }
 110                         Buffer[CurPos++] = Key;
 111                         Buffer[len + 1] = 0;
 112                 }
 113         }
 114 }
 115 /** Special Key Press */
 116 void Console::OnSpecialKeyPress(unsigned char Key)
 117 {
 118         size_t len;
 119
 120         switch (Key) {
 121                 case GEM_BACKSP:
 122                         if (CurPos != 0) {
 123                                 size_t len = strlen( ( const char * ) Buffer );
 124                                 for (size_t i = CurPos; i < len; i++) {
 125                                         Buffer[i - 1] = Buffer[i];
 126                                 }
 127                                 Buffer[len - 1] = 0;
 128                                 CurPos--;
 129                         }
 130                         break;
 131                 case GEM_HOME:
 132                         CurPos = 0;
 133                         break;
 134                 case GEM_END:
 135                         CurPos = (unsigned short) strlen( (const char * ) Buffer);
 136                         break;
 137                 case GEM_UP:
 138                         HistoryBack();
 139                         break;
 140                 case GEM_DOWN:
 141                         HistoryForward();
 142                         break;
 143                 case GEM_LEFT:
 144                         if (CurPos > 0)
 145                                 CurPos--;
 146                         break;
 147                 case GEM_RIGHT:
 148                         len = strlen( ( const char * ) Buffer );
 149                         if (CurPos < len) {
 150                                 CurPos++;
 151                         }
 152                         break;
 153                 case GEM_DELETE:
 154                         len = strlen( ( const char * ) Buffer );
 155                         if (CurPos < len) {
 156                                 for (size_t i = CurPos; i < len; i++) {
 157                                         Buffer[i] = Buffer[i + 1];
 158                                 }
 159                         }
 160                         break;
 161                 case GEM_RETURN:
 162                         core->GetGUIScriptEngine()->ExecString( ( char* ) Buffer );
 163                         HistoryAdd(false);
 164                         Buffer[0] = 0;
 165                         CurPos = 0;
 166                         HistPos = 0;
 167                         Changed = true;
 168                         break;
 169         }
 170 }
 171
 172 //ctrl-up
 173 void Console::HistoryBack()
 174 {
 175         HistoryAdd(false);
 176         if (HistPos < HistMax-1 && Buffer[0]) {
 177                 HistPos++;
 178         }
 179         memcpy(Buffer, History[HistPos], max);
 180         CurPos = (unsigned short) strlen ((const char *) Buffer);
 181 }
 182
 183 //ctrl-down
 184 void Console::HistoryForward()
 185 {
 186         HistoryAdd(false);
 187         if (HistPos == 0) {
 188                 Buffer[0]=0;
 189                 CurPos=0;
 190                 return;
 191         }
 192         HistPos--;
 193         memcpy(Buffer, History[HistPos], max);
 194         CurPos = (unsigned short) strlen ((const char *) Buffer);
 195 }
 196
 197 void Console::HistoryAdd(bool force)
 198 {
 199         int i;
 200
 201         if (!force && !Buffer[0])
 202                 return;
 203         for (i=0;i<HistMax;i++) {
 204                 if (!strnicmp((const char *) History[i],(const char *) Buffer,max) )
 205                         return;
 206         }
 207         if (History[0][0]) {
 208                 for (i=HISTORY_SIZE-1; i>0; i--) {
 209                         memcpy(History[i], History[i-1], max);
 210                 }
 211         }
 212         memcpy(History[0], Buffer, max);
 213         if (HistMax<HISTORY_SIZE) {
 214                 HistMax++;
 215         }
 216 }
 217
 218 bool Console::SetEvent(int /*eventType*/, EventHandler /*handler*/)
 219 {
 220         return false;
 221 }