Kernel/drv/vterm.c

   1 /*
   2  * Acess2 Virtual Terminal Driver
   3  */
   4 #define DEBUG   0
   5 #include <acess.h>
   6 #include <fs_devfs.h>
   7 #include <modules.h>
   8 #include <tpl_drv_video.h>
   9 #include <tpl_drv_keyboard.h>
  10 #include <tpl_drv_terminal.h>
  11 #include <errno.h>
  12
  13 #define USE_CTRL_ALT    0
  14
  15 // === CONSTANTS ===
  16 #define VERSION ((0<<8)|(50))
  17
  18 #define NUM_VTS 8
  19 #define MAX_INPUT_CHARS32       64
  20 #define MAX_INPUT_CHARS8        (MAX_INPUT_CHARS32*4)
  21 //#define DEFAULT_OUTPUT        "BochsGA"
  22 #define DEFAULT_OUTPUT  "Vesa"
  23 #define DEFAULT_INPUT   "PS2Keyboard"
  24 #define DEFAULT_WIDTH   640
  25 #define DEFAULT_HEIGHT  480
  26 #define DEFAULT_SCROLLBACK      2       // 2 Screens of text + current screen
  27 #define DEFAULT_COLOUR  (VT_COL_BLACK|(0xAAA<<16))
  28
  29 #define VT_FLAG_HIDECSR 0x01
  30 #define VT_FLAG_HASFB   0x10    //!< Set if the VTerm has requested the Framebuffer
  31
  32 enum eVT_InModes {
  33         VT_INMODE_TEXT8,        // UTF-8 Text Mode (VT100 Emulation)
  34         VT_INMODE_TEXT32,       // UTF-32 Text Mode (Acess Native)
  35         NUM_VT_INMODES
  36 };
  37
  38 // === TYPES ===
  39 typedef struct {
  40          int    Mode;   //!< Current Mode (see ::eTplTerminal_Modes)
  41          int    Flags;  //!< Flags (see VT_FLAG_*)
  42
  43
  44         short   NewWidth;       //!< Un-applied dimensions (Width)
  45         short   NewHeight;      //!< Un-applied dimensions (Height)
  46         short   Width;  //!< Virtual Width
  47         short   Height; //!< Virtual Height
  48         short   TextWidth;      //!< Text Virtual Width
  49         short   TextHeight;     //!< Text Virtual Height
  50
  51          int    ViewPos;        //!< View Buffer Offset (Text Only)
  52          int    WritePos;       //!< Write Buffer Offset (Text Only)
  53         Uint32  CurColour;      //!< Current Text Colour
  54
  55          int    InputRead;      //!< Input buffer read position
  56          int    InputWrite;     //!< Input buffer write position
  57         char    InputBuffer[MAX_INPUT_CHARS8];
  58
  59         tVT_Char        *Text;
  60         Uint32          *Buffer;
  61
  62         char    Name[2];        //!< Name of the terminal
  63         tVFS_Node       Node;
  64 } tVTerm;
  65
  66 // === IMPORTS ===
  67 extern void     Debug_SetKTerminal(char *File);
  68
  69 // === PROTOTYPES ===
  70  int    VT_Install(char **Arguments);
  71 void    VT_InitOutput(void);
  72 void    VT_InitInput(void);
  73 char    *VT_ReadDir(tVFS_Node *Node, int Pos);
  74 tVFS_Node       *VT_FindDir(tVFS_Node *Node, char *Name);
  75  int    VT_Root_IOCtl(tVFS_Node *Node, int Id, void *Data);
  76 Uint64  VT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  77 Uint64  VT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  78  int    VT_Terminal_IOCtl(tVFS_Node *Node, int Id, void *Data);
  79 void    VT_SetResolution(int Width, int Height);
  80 void    VT_SetMode(int Mode);
  81 void    VT_SetTerminal(int ID);
  82 void    VT_KBCallBack(Uint32 Codepoint);
  83 void    VT_int_PutString(tVTerm *Term, Uint8 *Buffer, Uint Count);
  84  int    VT_int_ParseEscape(tVTerm *Term, char *Buffer);
  85 void    VT_int_PutChar(tVTerm *Term, Uint32 Ch);
  86 void    VT_int_ScrollFramebuffer( tVTerm *Term );
  87 void    VT_int_UpdateScreen( tVTerm *Term, int UpdateAll );
  88 void    VT_int_ChangeMode(tVTerm *Term, int NewMode, int NewWidth, int NewHeight);
  89
  90 // === CONSTANTS ===
  91 const Uint16    caVT100Colours[] = {
  92                 // Black, Red, Green, Yellow, Blue, Purple, Cyan, Gray
  93                 // Same again, but bright
  94                 VT_COL_BLACK, 0x700, 0x070, 0x770, 0x007, 0x707, 0x077, 0xAAA,
  95                 VT_COL_GREY, 0xF00, 0x0F0, 0xFF0, 0x00F, 0xF0F, 0x0FF, VT_COL_WHITE
  96         };
  97
  98 // === GLOBALS ===
  99 MODULE_DEFINE(0, VERSION, VTerm, VT_Install, NULL, DEFAULT_OUTPUT, DEFAULT_INPUT, NULL);
 100 tDevFS_Driver   gVT_DrvInfo = {
 101         NULL, "VTerm",
 102         {
 103         .Flags = VFS_FFLAG_DIRECTORY,
 104         .Size = NUM_VTS,
 105         .Inode = -1,
 106         .NumACLs = 0,
 107         .ReadDir = VT_ReadDir,
 108         .FindDir = VT_FindDir,
 109         .IOCtl = VT_Root_IOCtl
 110         }
 111 };
 112 // --- Terminals ---
 113 tVTerm  gVT_Terminals[NUM_VTS];
 114  int    giVT_CurrentTerminal = 0;
 115 tVTerm  *gpVT_CurTerm = &gVT_Terminals[0];
 116 // --- Video State ---
 117 short   giVT_RealWidth  = DEFAULT_WIDTH;        //!< Screen Width
 118 short   giVT_RealHeight = DEFAULT_HEIGHT;       //!< Screen Height
 119  int    giVT_Scrollback = DEFAULT_SCROLLBACK;
 120 // --- Driver Handles ---
 121 char    *gsVT_OutputDevice = NULL;
 122 char    *gsVT_InputDevice = NULL;
 123  int    giVT_OutputDevHandle = -2;
 124  int    giVT_InputDevHandle = -2;
 125 // --- Key States --- (Used for VT Switching/Magic Combos)
 126  int    gbVT_CtrlDown = 0;
 127  int    gbVT_AltDown = 0;
 128  int    gbVT_SysrqDown = 0;
 129
 130 // === CODE ===
 131 /**
 132  * \fn int VT_Install(char **Arguments)
 133  * \brief Installs the Virtual Terminal Driver
 134  */
 135 int VT_Install(char **Arguments)
 136 {
 137          int    i;
 138
 139         // Scan Arguments
 140         if(Arguments)
 141         {
 142                 char    **args = Arguments;
 143                 char    *arg, *opt, *val;
 144                 for( ; (arg = *args); args++ )
 145                 {
 146                         Log_Debug("VTerm", "Argument '%s'", arg);
 147                         opt = arg;
 148                         val = arg + strpos(arg, '=');   *val++ = '\0';
 149
 150                         if( strcmp(opt, "Video") == 0 ) {
 151                                 if(gsVT_OutputDevice)   free(gsVT_OutputDevice);
 152                                 gsVT_OutputDevice = strdup(val);
 153                         }
 154                         else if( strcmp(opt, "Input") == 0 ) {
 155                                 if(gsVT_InputDevice)    free(gsVT_InputDevice);
 156                                 gsVT_InputDevice = strdup(val);
 157                         }
 158                         else if( strcmp(opt, "Width") == 0 ) {
 159                                 giVT_RealWidth = atoi( val );
 160                         }
 161                         else if( strcmp(opt, "Height") == 0 ) {
 162                                 giVT_RealHeight = atoi( val );
 163                         }
 164                         else if( strcmp(opt, "Scrollback") == 0 ) {
 165                                 giVT_Scrollback = atoi( val );
 166                         }
 167                 }
 168         }
 169
 170         // Apply Defaults
 171         if(!gsVT_OutputDevice)  gsVT_OutputDevice = "/Devices/"DEFAULT_OUTPUT;
 172         if(!gsVT_InputDevice)   gsVT_InputDevice = "/Devices/"DEFAULT_INPUT;
 173
 174         Log_Log("VTerm", "Using '%s' as output", gsVT_OutputDevice);
 175         Log_Log("VTerm", "Using '%s' as input", gsVT_InputDevice);
 176
 177         // Create Nodes
 178         for( i = 0; i < NUM_VTS; i++ )
 179         {
 180                 gVT_Terminals[i].Mode = TERM_MODE_TEXT;
 181                 gVT_Terminals[i].Flags = 0;
 182                 gVT_Terminals[i].CurColour = DEFAULT_COLOUR;
 183                 gVT_Terminals[i].WritePos = 0;
 184                 gVT_Terminals[i].ViewPos = 0;
 185
 186                 // Initialise
 187                 VT_int_ChangeMode( &gVT_Terminals[i],
 188                         TERM_MODE_TEXT, giVT_RealWidth, giVT_RealHeight );
 189
 190                 gVT_Terminals[i].Name[0] = '0'+i;
 191                 gVT_Terminals[i].Name[1] = '\0';
 192                 gVT_Terminals[i].Node.Inode = i;
 193                 gVT_Terminals[i].Node.ImplPtr = &gVT_Terminals[i];
 194                 gVT_Terminals[i].Node.NumACLs = 0;      // Only root can open virtual terminals
 195
 196                 gVT_Terminals[i].Node.Read = VT_Read;
 197                 gVT_Terminals[i].Node.Write = VT_Write;
 198                 gVT_Terminals[i].Node.IOCtl = VT_Terminal_IOCtl;
 199         }
 200
 201         // Add to DevFS
 202         DevFS_AddDevice( &gVT_DrvInfo );
 203
 204         VT_InitOutput();
 205         VT_InitInput();
 206
 207         // Set kernel output to VT0
 208         Debug_SetKTerminal("/Devices/VTerm/0");
 209
 210         Log_Log("VTerm", "Returning %i", MODULE_ERR_OK);
 211         return MODULE_ERR_OK;
 212 }
 213
 214 /**
 215  * \fn void VT_InitOutput()
 216  * \brief Initialise Video Output
 217  */
 218 void VT_InitOutput()
 219 {
 220         giVT_OutputDevHandle = VFS_Open(gsVT_OutputDevice, VFS_OPENFLAG_WRITE);
 221         if(giVT_InputDevHandle == -1) {
 222                 Log_Warning("VTerm", "Oh F**k, I can't open the video device '%s'", gsVT_OutputDevice);
 223                 return ;
 224         }
 225         VT_SetResolution(giVT_RealWidth, giVT_RealHeight);
 226         VT_SetTerminal( 0 );
 227         VT_SetMode( VIDEO_BUFFMT_TEXT );
 228 }
 229
 230 /**
 231  * \fn void VT_InitInput()
 232  * \brief Initialises the input
 233  */
 234 void VT_InitInput()
 235 {
 236         giVT_InputDevHandle = VFS_Open(gsVT_InputDevice, VFS_OPENFLAG_READ);
 237         if(giVT_InputDevHandle == -1)   return ;
 238         VFS_IOCtl(giVT_InputDevHandle, KB_IOCTL_SETCALLBACK, VT_KBCallBack);
 239 }
 240
 241 /**
 242  * \fn char *VT_ReadDir(tVFS_Node *Node, int Pos)
 243  * \brief Read from the VTerm Directory
 244  */
 245 char *VT_ReadDir(tVFS_Node *Node, int Pos)
 246 {
 247         if(Pos < 0)     return NULL;
 248         if(Pos >= NUM_VTS)      return NULL;
 249         return strdup( gVT_Terminals[Pos].Name );
 250 }
 251
 252 /**
 253  * \fn tVFS_Node *VT_FindDir(tVFS_Node *Node, char *Name)
 254  * \brief Find an item in the VTerm directory
 255  */
 256 tVFS_Node *VT_FindDir(tVFS_Node *Node, char *Name)
 257 {
 258          int    num;
 259
 260         ENTER("pNode sName", Node, Name);
 261
 262         // Open the input and output files if needed
 263         if(giVT_OutputDevHandle == -2)  VT_InitOutput();
 264         if(giVT_InputDevHandle == -2)   VT_InitInput();
 265
 266         // Sanity check name
 267         if(Name[0] < '0' || Name[0] > '9' || Name[1] != '\0') {
 268                 LEAVE('n');
 269                 return NULL;
 270         }
 271         // Get index
 272         num = Name[0] - '0';
 273         if(num >= NUM_VTS) {
 274                 LEAVE('n');
 275                 return NULL;
 276         }
 277         // Return node
 278         LEAVE('p', &gVT_Terminals[num].Node);
 279         return &gVT_Terminals[num].Node;
 280 }
 281
 282 /**
 283  * \fn int VT_Root_IOCtl(tVFS_Node *Node, int Id, void *Data)
 284  * \brief Control the VTerm Driver
 285  */
 286 int VT_Root_IOCtl(tVFS_Node *Node, int Id, void *Data)
 287 {
 288          int    len;
 289         switch(Id)
 290         {
 291         case DRV_IOCTL_TYPE:    return DRV_TYPE_MISC;
 292         case DRV_IOCTL_IDENT:   memcpy(Data, "VT\0\0", 4);      return 0;
 293         case DRV_IOCTL_VERSION: return VERSION;
 294         case DRV_IOCTL_LOOKUP:  return 0;
 295
 296         case 4: // Get Video Driver
 297                 if(Data)        strcpy(Data, gsVT_OutputDevice);
 298                 return strlen(gsVT_OutputDevice);
 299
 300         case 5: // Set Video Driver
 301                 if(!Data)       return -EINVAL;
 302                 if(Threads_GetUID() != 0)       return -EACCES;
 303
 304                 len = strlen(Data);
 305
 306                 free(gsVT_OutputDevice);
 307
 308                 gsVT_OutputDevice = malloc(len+1);
 309                 strcpy(gsVT_OutputDevice, Data);
 310
 311                 VFS_Close(giVT_OutputDevHandle);
 312                 giVT_OutputDevHandle = -1;
 313
 314                 VT_InitOutput();
 315                 return 1;
 316         }
 317         return 0;
 318 }
 319
 320 /**
 321  * \fn Uint64 VT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 322  * \brief Read from a virtual terminal
 323  */
 324 Uint64 VT_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 325 {
 326          int    pos = 0;
 327         tVTerm  *term = &gVT_Terminals[ Node->Inode ];
 328
 329         // Check current mode
 330         switch(term->Mode)
 331         {
 332         case TERM_MODE_TEXT:
 333                 while(pos < Length)
 334                 {
 335                         while(term->InputRead == term->InputWrite)      Threads_Yield();
 336
 337                         ((char*)Buffer)[pos] = term->InputBuffer[term->InputRead];
 338                         pos ++;
 339                         term->InputRead ++;
 340                         term->InputRead %= MAX_INPUT_CHARS8;
 341                 }
 342                 break;
 343
 344         //case TERM_MODE_FB:
 345         default:
 346                 while(pos < Length)
 347                 {
 348                         while(term->InputRead == term->InputWrite)      Threads_Yield();
 349                         ((Uint32*)Buffer)[pos] = ((Uint32*)term->InputBuffer)[term->InputRead];
 350                         pos ++;
 351                         term->InputRead ++;
 352                         term->InputRead %= MAX_INPUT_CHARS32;
 353                 }
 354                 break;
 355         }
 356         return 0;
 357 }
 358
 359 /**
 360  * \fn Uint64 VT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 361  * \brief Write to a virtual terminal
 362  */
 363 Uint64 VT_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 364 {
 365         tVTerm  *term = &gVT_Terminals[ Node->Inode ];
 366          int    size;
 367
 368         // Write
 369         switch( term->Mode )
 370         {
 371         case TERM_MODE_TEXT:
 372                 VT_int_PutString(term, Buffer, Length);
 373                 break;
 374         case TERM_MODE_FB:
 375                 size = term->Width*term->Height*4;
 376                 if( Offset > size ) {
 377                         Log_Notice("VTerm", "VT_Write: Offset (0x%llx) > FBSize (0x%x)",
 378                                 Offset, size);
 379                         return 0;
 380                 }
 381
 382                 if( Offset + Length > size ) {
 383                         Log_Notice("VTerm", "VT_Write: Offset+Length (0x%llx) > FBSize (0x%x)",
 384                                 Offset+Length, size);
 385                         Length = size - Offset;
 386                 }
 387
 388                 memcpy( (void*)((Uint)term->Buffer + (Uint)Offset), Buffer, Length );
 389
 390                 if( Node->Inode == giVT_CurrentTerminal )
 391                 {
 392                         if( giVT_RealWidth > term->Width || giVT_RealHeight > term->Height )
 393                         {
 394                                  int    x, y, w, h;
 395                                 x = Offset/4;   y = x / term->Width;    x %= term->Width;
 396                                 w = Length/4+x; h = w / term->Width;    w %= term->Width;
 397                                 // Center
 398                                 x += (giVT_RealWidth - term->Width) / 2;
 399                                 y += (giVT_RealHeight - term->Height) / 2;
 400                                 while(h--)
 401                                 {
 402                                         VFS_WriteAt( giVT_OutputDevHandle,
 403                                                 (x + y * giVT_RealWidth)*4,
 404                                                 term->Width * 4,
 405                                                 Buffer
 406                                                 );
 407                                         Buffer = (void*)( (Uint)Buffer + term->Width*4 );
 408                                         y ++;
 409                                 }
 410                                 return 0;
 411                         }
 412                         else {
 413                                 return VFS_WriteAt( giVT_OutputDevHandle, Offset, Length, Buffer );
 414                         }
 415                 }
 416         // Just pass on (for now)
 417         case TERM_MODE_2DACCEL:
 418         //case TERM_MODE_3DACCEL:
 419                 if( Node->Inode == giVT_CurrentTerminal )
 420                 {
 421                         VFS_Write( giVT_OutputDevHandle, Length, Buffer );
 422                 }
 423                 break;
 424         }
 425
 426         return 0;
 427 }
 428
 429 /**
 430  * \fn int VT_Terminal_IOCtl(tVFS_Node *Node, int Id, void *Data)
 431  * \brief Call an IO Control on a virtual terminal
 432  */
 433 int VT_Terminal_IOCtl(tVFS_Node *Node, int Id, void *Data)
 434 {
 435          int    *iData = Data;
 436          int    ret;
 437         tVTerm  *term = Node->ImplPtr;
 438         ENTER("pNode iId pData", Node, Id, Data);
 439
 440         if(Id >= DRV_IOCTL_LOOKUP) {
 441                 // Only root can fiddle with graphics modes
 442                 // TODO: Remove this and replace with user ownership
 443                 if( Threads_GetUID() != 0 )     return -1;
 444         }
 445
 446         switch(Id)
 447         {
 448         // --- Core Defined
 449         case DRV_IOCTL_TYPE:
 450                 LEAVE('i', DRV_TYPE_TERMINAL);
 451                 return DRV_TYPE_TERMINAL;
 452         case DRV_IOCTL_IDENT:
 453                 memcpy(Data, "VT\0\0", 4);
 454                 LEAVE('i', 0);
 455                 return 0;
 456         case DRV_IOCTL_VERSION:
 457                 LEAVE('x', VERSION);
 458                 return VERSION;
 459         case DRV_IOCTL_LOOKUP:
 460                 LEAVE('i', 0);
 461                 return 0;
 462
 463         // Get/Set the mode (and apply any changes)
 464         case TERM_IOCTL_MODETYPE:
 465                 if(Data != NULL)
 466                 {
 467                         if( CheckMem(Data, sizeof(int)) == 0 ) {
 468                                 LEAVE('i', -1);
 469                                 return -1;
 470                         }
 471                         Log_Log("VTerm", "VTerm %i mode set to %i", (int)Node->Inode, *iData);
 472
 473                         // Update mode if needed
 474                         if( term->Mode != *iData
 475                          || term->NewWidth
 476                          || term->NewHeight)
 477                         {
 478                                 if( *iData == TERM_MODE_TEXT ) {
 479                                         term->NewHeight *= giVT_CharHeight;
 480                                         term->NewWidth *= giVT_CharWidth;
 481                                 }
 482                                 if(term->NewHeight == 0)        term->NewHeight = term->Height;
 483                                 if(term->NewWidth == 0) term->NewWidth = term->Width;
 484                                 VT_int_ChangeMode(term, *iData, term->NewWidth, term->NewHeight);
 485                                 term->NewWidth = 0;
 486                                 term->NewHeight = 0;
 487                         }
 488
 489                         // Update the screen dimensions
 490                         if(Node->Inode == giVT_CurrentTerminal)
 491                                 VT_SetTerminal( giVT_CurrentTerminal );
 492                 }
 493                 LEAVE('i', term->Mode);
 494                 return term->Mode;
 495
 496         // Get/set the terminal width
 497         case TERM_IOCTL_WIDTH:
 498                 if(Data != NULL) {
 499                         if( CheckMem(Data, sizeof(int)) == 0 ) {
 500                                 LEAVE('i', -1);
 501                                 return -1;
 502                         }
 503                         term->NewWidth = *iData;
 504                 }
 505                 if( term->NewWidth )
 506                         ret = term->NewWidth;
 507                 else if( term->Mode == TERM_MODE_TEXT )
 508                         ret = term->TextWidth;
 509                 else
 510                         ret = term->Width;
 511                 LEAVE('i', ret);
 512                 return ret;
 513
 514         // Get/set the terminal height
 515         case TERM_IOCTL_HEIGHT:
 516                 if(Data != NULL) {
 517                         if( CheckMem(Data, sizeof(int)) == 0 ) {
 518                                 LEAVE('i', -1);
 519                                 return -1;
 520                         }
 521                         term->NewHeight = *iData;
 522                 }
 523                 if( term->NewHeight )
 524                         ret = term->NewHeight;
 525                 else if( term->Mode == TERM_MODE_TEXT )
 526                         ret = term->TextHeight = *iData;
 527                 else
 528                         ret = term->Height;
 529                 LEAVE('i', ret);
 530                 return ret;
 531
 532         case TERM_IOCTL_FORCESHOW:
 533                 Log_Log("VTerm", "Thread %i forced VTerm %i to be shown",
 534                         Threads_GetTID(), (int)Node->Inode);
 535                 VT_SetTerminal( Node->Inode );
 536                 LEAVE('i', 1);
 537                 return 1;
 538         }
 539         LEAVE('i', -1);
 540         return -1;
 541 }
 542
 543 void VT_SetResolution(int Width, int Height)
 544 {
 545         tVideo_IOCtl_Mode       mode = {0};
 546          int    tmp;
 547          int    i;
 548
 549         // Create the video mode
 550         mode.width = Width;
 551         mode.height = Height;
 552         mode.bpp = 32;
 553         mode.flags = 0;
 554
 555         // Set video mode
 556         VFS_IOCtl( giVT_OutputDevHandle, VIDEO_IOCTL_FINDMODE, &mode );
 557         tmp = mode.id;
 558         if( Width != mode.width || Height != mode.height )
 559         {
 560                 Log_Warning("VTerm",
 561                         "Selected resolution (%ix%i is not supported) by the device, using (%ix%i)",
 562                         giVT_RealWidth, giVT_RealHeight,
 563                         mode.width, mode.height
 564                         );
 565         }
 566         VFS_IOCtl( giVT_OutputDevHandle, VIDEO_IOCTL_GETSETMODE, &tmp );
 567
 568         // Resize text terminals if needed
 569         if( giVT_RealWidth != mode.width || giVT_RealHeight != mode.height )
 570         {
 571                  int    newBufSize = (giVT_RealWidth/giVT_CharWidth)
 572                                         *(giVT_RealHeight/giVT_CharHeight)
 573                                         *(giVT_Scrollback+1);
 574                 //tVT_Char      *tmp;
 575                 // Resize the text terminals
 576                 giVT_RealWidth = mode.width;
 577                 giVT_RealHeight = mode.height;
 578                 for( i = 0; i < NUM_VTS; i ++ )
 579                 {
 580                         if( gVT_Terminals[i].Mode != TERM_MODE_TEXT )   continue;
 581
 582                         gVT_Terminals[i].Text = realloc(
 583                                 gVT_Terminals[i].Text,
 584                                 newBufSize*sizeof(tVT_Char)
 585                                 );
 586                 }
 587         }
 588 }
 589
 590 void VT_SetMode(int Mode)
 591 {
 592         VFS_IOCtl( giVT_OutputDevHandle, VIDEO_IOCTL_SETBUFFORMAT, &Mode );
 593 }
 594
 595 /**
 596  * \fn void VT_SetTerminal(int ID)
 597  * \brief Set the current terminal
 598  */
 599 void VT_SetTerminal(int ID)
 600 {
 601         // Update current terminal ID
 602         Log_Log("VTerm", "Changed terminal from %i to %i", giVT_CurrentTerminal, ID);
 603         giVT_CurrentTerminal = ID;
 604         gpVT_CurTerm = &gVT_Terminals[ID];
 605
 606         // Update cursor
 607         if( gpVT_CurTerm->Mode == TERM_MODE_TEXT && !(gpVT_CurTerm->Flags & VT_FLAG_HIDECSR) )
 608         {
 609                 tVideo_IOCtl_Pos        pos;
 610                 pos.x = gpVT_CurTerm->WritePos % gpVT_CurTerm->TextWidth;
 611                 pos.y = gpVT_CurTerm->WritePos / gpVT_CurTerm->TextWidth;
 612                 VFS_IOCtl(giVT_OutputDevHandle, VIDEO_IOCTL_SETCURSOR, &pos);
 613         }
 614
 615         if( gpVT_CurTerm->Mode == TERM_MODE_TEXT )
 616                 VT_SetMode( VIDEO_BUFFMT_TEXT );
 617         else
 618                 VT_SetMode( VIDEO_BUFFMT_FRAMEBUFFER );
 619
 620         // Update the screen
 621         VT_int_UpdateScreen( &gVT_Terminals[ ID ], 1 );
 622 }
 623
 624 /**
 625  * \fn void VT_KBCallBack(Uint32 Codepoint)
 626  * \brief Called on keyboard interrupt
 627  * \param Codepoint     Pseudo-UTF32 character
 628  *
 629  * Handles a key press and sends the key code to the user's buffer.
 630  * If the code creates a kernel-magic sequence, it is not passed to the
 631  * user and is handled in-kernel.
 632  */
 633 void VT_KBCallBack(Uint32 Codepoint)
 634 {
 635         tVTerm  *term = gpVT_CurTerm;
 636
 637         // How the hell did we get a codepoint of zero?
 638         if(Codepoint == 0)      return;
 639
 640         // Key Up
 641         if( Codepoint & 0x80000000 )
 642         {
 643                 Codepoint &= 0x7FFFFFFF;
 644                 switch(Codepoint)
 645                 {
 646                 #if !USE_CTRL_ALT
 647                 case KEY_RSHIFT:        gbVT_CtrlDown = 0;      break;
 648                 case KEY_LSHIFT:        gbVT_AltDown = 0;       break;
 649                 #else
 650                 case KEY_LALT:  gbVT_AltDown &= ~1;     break;
 651                 case KEY_RALT:  gbVT_AltDown &= ~2;     break;
 652                 case KEY_LCTRL: gbVT_CtrlDown &= ~1     break;
 653                 case KEY_RCTRL: gbVT_CtrlDown &= ~2;    break;
 654                 #endif
 655                 }
 656                 return;
 657         }
 658
 659         switch(Codepoint)
 660         {
 661         #if !USE_CTRL_ALT       // HACK: Use both shifts instead of Ctrl-Alt
 662         case KEY_RSHIFT:        gbVT_CtrlDown = 1;      break;
 663         case KEY_LSHIFT:        gbVT_AltDown = 1;       break;
 664         #else
 665         case KEY_LALT:  gbVT_AltDown |= 1;      break;
 666         case KEY_RALT:  gbVT_AltDown |= 2;      break;
 667         case KEY_LCTRL: gbVT_CtrlDown |= 1;     break;
 668         case KEY_RCTRL: gbVT_CtrlDown |= 2;     break;
 669         #endif
 670
 671         default:
 672                 if(!gbVT_AltDown || !gbVT_CtrlDown)
 673                         break;
 674                 switch(Codepoint)
 675                 {
 676                 case KEY_F1:    VT_SetTerminal(0);      return;
 677                 case KEY_F2:    VT_SetTerminal(1);      return;
 678                 case KEY_F3:    VT_SetTerminal(2);      return;
 679                 case KEY_F4:    VT_SetTerminal(3);      return;
 680                 case KEY_F5:    VT_SetTerminal(4);      return;
 681                 case KEY_F6:    VT_SetTerminal(5);      return;
 682                 case KEY_F7:    VT_SetTerminal(6);      return;
 683                 case KEY_F8:    VT_SetTerminal(7);      return;
 684                 case KEY_F9:    VT_SetTerminal(8);      return;
 685                 case KEY_F10:   VT_SetTerminal(9);      return;
 686                 case KEY_F11:   VT_SetTerminal(10);     return;
 687                 case KEY_F12:   VT_SetTerminal(11);     return;
 688                 // Scrolling
 689                 case KEY_PGUP:
 690                         if( gpVT_CurTerm->ViewPos > gpVT_CurTerm->Width )
 691                                 gpVT_CurTerm->ViewPos -= gpVT_CurTerm->Width;
 692                         else
 693                                 gpVT_CurTerm->ViewPos = 0;
 694                         return;
 695                 case KEY_PGDOWN:
 696                         if( gpVT_CurTerm->ViewPos < gpVT_CurTerm->Width*gpVT_CurTerm->Height*(giVT_Scrollback-1) )
 697                                 gpVT_CurTerm->ViewPos += gpVT_CurTerm->Width;
 698                         else
 699                                 gpVT_CurTerm->ViewPos = gpVT_CurTerm->Width*gpVT_CurTerm->Height*(giVT_Scrollback-1);
 700                         return;
 701                 }
 702         }
 703
 704         // Encode key
 705         if(term->Mode == TERM_MODE_TEXT)
 706         {
 707                 Uint8   buf[6] = {0};
 708                  int    len = 0;
 709
 710                 // Ignore Modifer Keys
 711                 if(Codepoint > KEY_MODIFIERS)   return;
 712
 713                 // Get UTF-8/ANSI Encoding
 714                 switch(Codepoint)
 715                 {
 716                 case KEY_LEFT:
 717                         buf[0] = '\x1B';        buf[1] = '[';   buf[2] = 'D';
 718                         len = 3;
 719                         break;
 720                 case KEY_RIGHT:
 721                         buf[0] = '\x1B';        buf[1] = '[';   buf[2] = 'C';
 722                         len = 3;
 723                         break;
 724                 case KEY_UP:
 725                         buf[0] = '\x1B';        buf[1] = '[';   buf[2] = 'A';
 726                         len = 3;
 727                         break;
 728                 case KEY_DOWN:
 729                         buf[0] = '\x1B';        buf[1] = '[';   buf[2] = 'B';
 730                         len = 3;
 731                         break;
 732
 733                 case KEY_PGUP:
 734                         buf[0] = '\x1B';        buf[1] = '[';   buf[2] = '5';   // Some overline also
 735                         //len = 4;      // Commented out until I'm sure
 736                         break;
 737                 case KEY_PGDOWN:
 738                         len = 0;
 739                         break;
 740
 741                 // Attempt to encode in UTF-8
 742                 default:
 743                         len = WriteUTF8( buf, Codepoint );
 744                         if(len == 0) {
 745                                 Warning("Codepoint (%x) is unrepresentable in UTF-8", Codepoint);
 746                         }
 747                         break;
 748                 }
 749
 750                 if(len == 0) {
 751                         // Unprintable / Don't Pass
 752                         return;
 753                 }
 754
 755                 // Write
 756                 if( MAX_INPUT_CHARS8 - term->InputWrite >= len )
 757                         memcpy( &term->InputBuffer[term->InputWrite], buf, len );
 758                 else {
 759                         memcpy( &term->InputBuffer[term->InputWrite], buf, MAX_INPUT_CHARS8 - term->InputWrite );
 760                         memcpy( &term->InputBuffer[0], buf, len - (MAX_INPUT_CHARS8 - term->InputWrite) );
 761                 }
 762                 // Roll the buffer over
 763                 term->InputWrite += len;
 764                 term->InputWrite %= MAX_INPUT_CHARS8;
 765                 if( (term->InputWrite - term->InputRead + MAX_INPUT_CHARS8)%MAX_INPUT_CHARS8 < len ) {
 766                         term->InputRead = term->InputWrite + 1;
 767                         term->InputRead %= MAX_INPUT_CHARS8;
 768                 }
 769
 770         }
 771         else
 772         {
 773                 // Encode the raw UTF-32 Key
 774                 ((Uint32*)term->InputBuffer)[ term->InputWrite ] = Codepoint;
 775                 term->InputWrite ++;
 776                 term->InputWrite %= MAX_INPUT_CHARS32;
 777                 if(term->InputRead == term->InputWrite) {
 778                         term->InputRead ++;
 779                         term->InputRead %= MAX_INPUT_CHARS32;
 780                 }
 781         }
 782 }
 783
 784 /**
 785  * \fn void VT_int_ClearLine(tVTerm *Term, int Num)
 786  * \brief Clears a line in a virtual terminal
 787  */
 788 void VT_int_ClearLine(tVTerm *Term, int Num)
 789 {
 790          int    i;
 791         tVT_Char        *cell = &Term->Text[ Num*Term->TextWidth ];
 792         if( Num < 0 || Num >= Term->TextHeight )        return ;
 793         //ENTER("pTerm iNum", Term, Num);
 794         for( i = Term->TextWidth; i--; )
 795         {
 796                 cell[ i ].Ch = 0;
 797                 cell[ i ].Colour = Term->CurColour;
 798         }
 799         //LEAVE('-');
 800 }
 801
 802 /**
 803  * \fn int VT_int_ParseEscape(tVTerm *Term, char *Buffer)
 804  * \brief Parses a VT100 Escape code
 805  */
 806 int VT_int_ParseEscape(tVTerm *Term, char *Buffer)
 807 {
 808         char    c;
 809          int    argc = 0, j = 1;
 810          int    tmp;
 811          int    args[6] = {0,0,0,0};
 812
 813         switch(Buffer[0])
 814         {
 815         //Large Code
 816         case '[':
 817                 // Get Arguments
 818                 c = Buffer[j++];
 819                 if( '0' <= c && c <= '9' )
 820                 {
 821                         do {
 822                                 if(c == ';')    c = Buffer[j++];
 823                                 while('0' <= c && c <= '9') {
 824                                         args[argc] *= 10;
 825                                         args[argc] += c-'0';
 826                                         c = Buffer[j++];
 827                                 }
 828                                 argc ++;
 829                         } while(c == ';');
 830                 }
 831
 832                 /*
 833                 // Get string (what does this do?)
 834                 if(c == '"') {
 835                         c = Buffer[j++];
 836                         while(c != '"')
 837                                 c = Buffer[j++];
 838                 }
 839                 */
 840
 841                 //Log_Debug("VTerm", "argc = %i", argc);
 842
 843                 // Get Command
 844                 if(     ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
 845                 {
 846                         switch(c)
 847                         {
 848                         // Left
 849                         case 'D':
 850                                 if(argc == 1)   tmp = args[0];
 851                                 else    tmp = 1;
 852
 853                                 if( Term->WritePos-(tmp-1) % Term->TextWidth == 0 )
 854                                         Term->WritePos -= Term->WritePos % Term->TextWidth;
 855                                 else
 856                                         Term->WritePos -= tmp;
 857                                 break;
 858
 859                         // Right
 860                         case 'C':
 861                                 if(argc == 1)   tmp = args[0];
 862                                 else    tmp = 1;
 863                                 if( (Term->WritePos + tmp) % Term->TextWidth == 0 ) {
 864                                         Term->WritePos -= Term->WritePos % Term->TextWidth;
 865                                         Term->WritePos += Term->TextWidth - 1;
 866                                 } else
 867                                         Term->WritePos += tmp;
 868                                 break;
 869
 870                         // Clear By Line
 871                         case 'J':
 872                                 // Clear Screen
 873                                 switch(args[0])
 874                                 {
 875                                 case 2:
 876                                         {
 877                                          int    i = Term->TextHeight * (giVT_Scrollback + 1);
 878                                         while( i-- )    VT_int_ClearLine(Term, i);
 879                                         Term->WritePos = 0;
 880                                         Term->ViewPos = 0;
 881                                         VT_int_UpdateScreen(Term, 1);
 882                                         }
 883                                         break;
 884                                 }
 885                                 break;
 886                         // Set cursor position
 887                         case 'h':
 888                                 Term->WritePos = args[0] + args[1]*Term->TextWidth;
 889                                 Log_Debug("VTerm", "args = {%i, %i}", args[0], args[1]);
 890                                 break;
 891                         // Set Font flags
 892                         case 'm':
 893                                 for( ; argc--; )
 894                                 {
 895                                         // Flags
 896                                         if( 0 <= args[argc] && args[argc] <= 8)
 897                                         {
 898                                                 switch(args[argc])
 899                                                 {
 900                                                 case 0: Term->CurColour = DEFAULT_COLOUR;       break;  // Reset
 901                                                 case 1: Term->CurColour |= 0x80000000;  break;  // Bright
 902                                                 case 2: Term->CurColour &= ~0x80000000; break;  // Dim
 903                                                 }
 904                                         }
 905                                         // Foreground Colour
 906                                         else if(30 <= args[argc] && args[argc] <= 37) {
 907                                                 Term->CurColour &= 0xF000FFFF;
 908                                                 Term->CurColour |= (Uint32)caVT100Colours[ args[argc]-30+(Term->CurColour>>28) ] << 16;
 909                                         }
 910                                         // Background Colour
 911                                         else if(40 <= args[argc] && args[argc] <= 47) {
 912                                                 Term->CurColour &= 0xFFFF8000;
 913                                                 Term->CurColour |= caVT100Colours[ args[argc]-40+((Term->CurColour>>12)&15) ];
 914                                         }
 915                                 }
 916                                 break;
 917                         default:
 918                                 Log_Warning("VTerm", "Unknown control sequence");
 919                                 break;
 920                         }
 921                 }
 922                 break;
 923
 924         default:        break;
 925         }
 926
 927         //Log_Debug("VTerm", "j = %i, Buffer = '%s'", j, Buffer);
 928         return j;
 929 }
 930
 931 /**
 932  * \fn void VT_int_PutString(tVTerm *Term, Uint8 *Buffer, Uint Count)
 933  * \brief Print a string to the Virtual Terminal
 934  */
 935 void VT_int_PutString(tVTerm *Term, Uint8 *Buffer, Uint Count)
 936 {
 937         Uint32  val;
 938          int    i;
 939
 940         // Iterate
 941         for( i = 0; i < Count; i++ )
 942         {
 943                 // Handle escape sequences
 944                 if( Buffer[i] == 0x1B )
 945                 {
 946                         i ++;
 947                         i += VT_int_ParseEscape(Term, (char*)&Buffer[i]) - 1;
 948                         continue;
 949                 }
 950
 951                 // Fast check for non UTF-8
 952                 if( Buffer[i] < 128 )   // Plain ASCII
 953                         VT_int_PutChar(Term, Buffer[i]);
 954                 else {  // UTF-8
 955                         i += ReadUTF8(&Buffer[i], &val) - 1;
 956                         VT_int_PutChar(Term, val);
 957                 }
 958         }
 959         // Update Screen
 960         VT_int_UpdateScreen( Term, 0 );
 961
 962         // Update cursor
 963         if( Term == gpVT_CurTerm && !(Term->Flags & VT_FLAG_HIDECSR) )
 964         {
 965                 tVideo_IOCtl_Pos        pos;
 966                 pos.x = Term->WritePos % Term->TextWidth;
 967                 pos.y = Term->WritePos / Term->TextWidth;
 968                 VFS_IOCtl(giVT_OutputDevHandle, VIDEO_IOCTL_SETCURSOR, &pos);
 969         }
 970 }
 971
 972 /**
 973  * \fn void VT_int_PutChar(tVTerm *Term, Uint32 Ch)
 974  * \brief Write a single character to a VTerm
 975  */
 976 void VT_int_PutChar(tVTerm *Term, Uint32 Ch)
 977 {
 978          int    i;
 979
 980         switch(Ch)
 981         {
 982         case '\0':      return; // Ignore NULL byte
 983         case '\n':
 984                 VT_int_UpdateScreen( Term, 0 ); // Update the line before newlining
 985                 Term->WritePos += Term->TextWidth;
 986         case '\r':
 987                 Term->WritePos -= Term->WritePos % Term->TextWidth;
 988                 break;
 989
 990         case '\t':
 991                 do {
 992                         Term->Text[ Term->WritePos ].Ch = '\0';
 993                         Term->Text[ Term->WritePos ].Colour = Term->CurColour;
 994                         Term->WritePos ++;
 995                 } while(Term->WritePos & 7);
 996                 break;
 997
 998         case '\b':
 999                 // Backspace is invalid at Offset 0
1000                 if(Term->WritePos == 0) break;
1001
1002                 Term->WritePos --;
1003                 // Singe Character
1004                 if(Term->Text[ Term->WritePos ].Ch != '\0') {
1005                         Term->Text[ Term->WritePos ].Ch = 0;
1006                         Term->Text[ Term->WritePos ].Colour = Term->CurColour;
1007                         break;
1008                 }
1009                 // Tab
1010                 i = 7;  // Limit it to 8
1011                 do {
1012                         Term->Text[ Term->WritePos ].Ch = 0;
1013                         Term->Text[ Term->WritePos ].Colour = Term->CurColour;
1014                         Term->WritePos --;
1015                 } while(Term->WritePos && i-- && Term->Text[ Term->WritePos ].Ch == '\0');
1016                 if(Term->Text[ Term->WritePos ].Ch != '\0')
1017                         Term->WritePos ++;
1018                 break;
1019
1020         default:
1021                 Term->Text[ Term->WritePos ].Ch = Ch;
1022                 Term->Text[ Term->WritePos ].Colour = Term->CurColour;
1023                 Term->WritePos ++;
1024                 break;
1025         }
1026
1027         // Move Screen
1028         // - Check if we need to scroll the entire scrollback buffer
1029         if(Term->WritePos >= Term->TextWidth*Term->TextHeight*(giVT_Scrollback+1))
1030         {
1031                  int    base, i;
1032
1033                 //Debug("Scrolling entire buffer");
1034
1035                 // Move back by one
1036                 Term->WritePos -= Term->TextWidth;
1037                 // Update the scren
1038                 VT_int_UpdateScreen( Term, 0 );
1039
1040                 // Update view position
1041                 base = Term->TextWidth*Term->TextHeight*(giVT_Scrollback);
1042                 if(Term->ViewPos < base)
1043                         Term->ViewPos += Term->Width;
1044                 if(Term->ViewPos > base)
1045                         Term->ViewPos = base;
1046
1047                 // Scroll terminal cache
1048                 base = Term->TextWidth*(Term->TextHeight*(giVT_Scrollback+1)-1);
1049                 memcpy(
1050                         Term->Text,
1051                         &Term->Text[Term->TextWidth],
1052                         base*sizeof(tVT_Char)
1053                         );
1054
1055                 // Clear last row
1056                 for( i = 0; i < Term->TextWidth; i ++ )
1057                 {
1058                         Term->Text[ base + i ].Ch = 0;
1059                         Term->Text[ base + i ].Colour = Term->CurColour;
1060                 }
1061
1062                 VT_int_ScrollFramebuffer( Term );
1063                 VT_int_UpdateScreen( Term, 0 );
1064         }
1065         // Ok, so we only need to scroll the screen
1066         else if(Term->WritePos >= Term->ViewPos + Term->TextWidth*Term->TextHeight)
1067         {
1068                 //Debug("Term->WritePos (%i) >= %i",
1069                 //      Term->WritePos,
1070                 //      Term->ViewPos + Term->Width*Term->Height
1071                 //      );
1072                 //Debug("Scrolling screen only");
1073
1074                 // Update the last line
1075                 Term->WritePos -= Term->TextWidth;
1076                 VT_int_UpdateScreen( Term, 0 );
1077                 Term->WritePos += Term->TextWidth;
1078
1079                 // Scroll
1080                 Term->ViewPos += Term->TextWidth;
1081                 //Debug("Term->ViewPos = %i", Term->ViewPos);
1082                 VT_int_ScrollFramebuffer( Term );
1083                 VT_int_UpdateScreen( Term, 0 );
1084         }
1085
1086         //LEAVE('-');
1087 }
1088
1089 /**
1090  * \fn void VT_int_ScrollFramebuffer( tVTerm *Term )
1091  * \note Scrolls the framebuffer by 1 text line
1092  */
1093 void VT_int_ScrollFramebuffer( tVTerm *Term )
1094 {
1095          int    tmp;
1096         struct {
1097                 Uint8   Op;
1098                 Uint16  DstX, DstY;
1099                 Uint16  SrcX, SrcY;
1100                 Uint16  W, H;
1101         } PACKED        buf;
1102
1103         // Only update if this is the current terminal
1104         if( Term != gpVT_CurTerm )      return;
1105
1106         // Switch to 2D Command Stream
1107         tmp = VIDEO_BUFFMT_2DSTREAM;
1108         VFS_IOCtl(giVT_OutputDevHandle, VIDEO_IOCTL_SETBUFFORMAT, &tmp);
1109
1110         // BLIT from 0,0 to 0,giVT_CharHeight
1111         buf.Op = VIDEO_2DOP_BLIT;
1112         buf.DstX = 0;   buf.DstY = 0;
1113         buf.SrcX = 0;   buf.SrcY = giVT_CharHeight;
1114         buf.W = Term->TextWidth * giVT_CharWidth;
1115         buf.H = (Term->TextHeight-1) * giVT_CharHeight;
1116         VFS_WriteAt(giVT_OutputDevHandle, 0, sizeof(buf), &buf);
1117
1118         // Restore old mode (this function is only called during text mode)
1119         tmp = VIDEO_BUFFMT_TEXT;
1120         VFS_IOCtl(giVT_OutputDevHandle, VIDEO_IOCTL_SETBUFFORMAT, &tmp);
1121 }
1122
1123 /**
1124  * \fn void VT_int_UpdateScreen( tVTerm *Term, int UpdateAll )
1125  * \brief Updates the video framebuffer
1126  */
1127 void VT_int_UpdateScreen( tVTerm *Term, int UpdateAll )
1128 {
1129         // Only update if this is the current terminal
1130         if( Term != gpVT_CurTerm )      return;
1131
1132         switch( Term->Mode )
1133         {
1134         case TERM_MODE_TEXT:
1135                 // Re copy the entire screen?
1136                 if(UpdateAll) {
1137                         VFS_WriteAt(
1138                                 giVT_OutputDevHandle,
1139                                 0,
1140                                 Term->TextWidth*Term->TextHeight*sizeof(tVT_Char),
1141                                 &Term->Text[Term->ViewPos]
1142                                 );
1143                 }
1144                 // Only copy the current line
1145                 else {
1146                          int    pos = Term->WritePos - Term->WritePos % Term->TextWidth;
1147                         VFS_WriteAt(
1148                                 giVT_OutputDevHandle,
1149                                 (pos - Term->ViewPos)*sizeof(tVT_Char),
1150                                 Term->TextWidth*sizeof(tVT_Char),
1151                                 &Term->Text[pos]
1152                                 );
1153                 }
1154                 break;
1155         case TERM_MODE_FB:
1156                 VFS_WriteAt(
1157                         giVT_OutputDevHandle,
1158                         0,
1159                         Term->Width*Term->Height*sizeof(Uint32),
1160                         Term->Buffer
1161                         );
1162                 break;
1163         }
1164 }
1165
1166 /**
1167  * \brief Update the screen mode
1168  * \param Term  Terminal to update
1169  * \param NewMode       New mode to set
1170  * \param NewWidth      New framebuffer width
1171  * \param NewHeight     New framebuffer height
1172  */
1173 void VT_int_ChangeMode(tVTerm *Term, int NewMode, int NewWidth, int NewHeight)
1174 {
1175          int    oldW = Term->Width;
1176          int    oldTW = oldW / giVT_CharWidth;
1177          int    oldH = Term->Height;
1178          int    oldTH = oldH / giVT_CharWidth;
1179         tVT_Char        *oldTBuf = Term->Text;
1180         Uint32  *oldFB = Term->Buffer;
1181          int    w, h, i;
1182
1183         // TODO: Increase RealWidth/RealHeight when this happens
1184         if(NewWidth > giVT_RealWidth)   NewWidth = giVT_RealWidth;
1185         if(NewHeight > giVT_RealHeight) NewHeight = giVT_RealHeight;
1186
1187         // Calculate new dimensions
1188         Term->TextWidth = NewWidth / giVT_CharWidth;
1189         Term->TextHeight = NewHeight / giVT_CharHeight;
1190         Term->Width = NewWidth;
1191         Term->Height = NewHeight;
1192         Term->Mode = NewMode;
1193
1194         // Allocate new buffers
1195         // - Text
1196         Term->Text = calloc(
1197                 Term->TextWidth * Term->TextHeight * (giVT_Scrollback+1),
1198                 sizeof(tVT_Char)
1199                 );
1200         if(oldTBuf) {
1201                 // Copy old buffer
1202                 w = oldTW;
1203                 if( w > Term->TextWidth )       w = Term->TextWidth;
1204                 h = oldTH;
1205                 if( h > Term->TextHeight )      h = Term->TextHeight;
1206                 h *= giVT_Scrollback + 1;
1207                 for( i = 0; i < h; i ++ )
1208                 {
1209                         memcpy(
1210                                 &Term->Text[i*Term->TextWidth],
1211                                 &oldTBuf[i*oldTW],
1212                                 w*sizeof(tVT_Char)
1213                                 );
1214
1215                 }
1216         }
1217
1218         // - Framebuffer
1219         Term->Buffer = calloc( Term->Width * Term->Height, sizeof(Uint32) );
1220         if(oldFB) {
1221                 // Copy old buffer
1222                 w = oldW;
1223                 if( w > Term->Width )   w = Term->Width;
1224                 h = oldH;
1225                 if( h > Term->Height )  h = Term->Height;
1226                 for( i = 0; i < h; i ++ )
1227                 {
1228                         memcpy(
1229                                 &Term->Buffer[i*Term->Width],
1230                                 &oldFB[i*oldW],
1231                                 w*sizeof(Uint32)
1232                                 );
1233                 }
1234         }
1235
1236
1237         // Debug
1238         switch(NewMode)
1239         {
1240         case TERM_MODE_TEXT:
1241                 Log_Log("VTerm", "Set VT %p to text mode (%ix%i)",
1242                         Term, Term->TextWidth, Term->TextHeight);
1243                 break;
1244         case TERM_MODE_FB:
1245                 Log_Log("VTerm", "Set VT %p to framebuffer mode (%ix%i)",
1246                         Term, Term->Width, Term->Height);
1247                 break;
1248         //case TERM_MODE_2DACCEL:
1249         //case TERM_MODE_3DACCEL:
1250         //      return;
1251         }
1252 }
1253
1254 // ---
1255 // Font Render
1256 // ---
1257 #define MONOSPACE_FONT  10816
1258
1259 #if MONOSPACE_FONT == 10808     // 8x8
1260 # include "vterm_font_8x8.h"
1261 #elif MONOSPACE_FONT == 10816   // 8x16
1262 # include "vterm_font_8x16.h"
1263 #endif
1264
1265 // === PROTOTYPES ===
1266 Uint8   *VT_Font_GetChar(Uint32 Codepoint);
1267
1268 // === GLOBALS ===
1269 int     giVT_CharWidth = FONT_WIDTH;
1270 int     giVT_CharHeight = FONT_HEIGHT;
1271
1272 // === CODE ===
1273 /**
1274  * \fn void VT_Font_Render(Uint32 Codepoint, void *Buffer, int Pitch, Uint32 BGC, Uint32 FGC)
1275  * \brief Render a font character
1276  */
1277 void VT_Font_Render(Uint32 Codepoint, void *Buffer, int Pitch, Uint32 BGC, Uint32 FGC)
1278 {
1279         Uint8   *font;
1280         Uint32  *buf = Buffer;
1281          int    x, y;
1282
1283         font = VT_Font_GetChar(Codepoint);
1284
1285         for(y = 0; y < FONT_HEIGHT; y ++)
1286         {
1287                 for(x = 0; x < FONT_WIDTH; x ++)
1288                 {
1289                         if(*font & (1 << (FONT_WIDTH-x-1)))
1290                                 buf[x] = FGC;
1291                         else
1292                                 buf[x] = BGC;
1293                 }
1294                 buf += Pitch;
1295                 font ++;
1296         }
1297 }
1298
1299 /**
1300  * \fn Uint32 VT_Colour12to24(Uint16 Col12)
1301  * \brief Converts a
1302  */
1303 Uint32 VT_Colour12to24(Uint16 Col12)
1304 {
1305         Uint32  ret;
1306          int    tmp;
1307         tmp = Col12 & 0xF;
1308         ret  = (tmp << 0) | (tmp << 4);
1309         tmp = (Col12 & 0xF0) >> 4;
1310         ret |= (tmp << 8) | (tmp << 12);
1311         tmp = (Col12 & 0xF00) >> 8;
1312         ret |= (tmp << 16) | (tmp << 20);
1313         return ret;
1314 }
1315
1316 /**
1317  * \fn Uint8 *VT_Font_GetChar(Uint32 Codepoint)
1318  * \brief Gets an index into the font array given a Unicode Codepoint
1319  * \note See http://en.wikipedia.org/wiki/CP437
1320  */
1321 Uint8 *VT_Font_GetChar(Uint32 Codepoint)
1322 {
1323          int    index = 0;
1324         if(Codepoint < 128)
1325                 return &VTermFont[Codepoint*FONT_HEIGHT];
1326         switch(Codepoint)
1327         {
1328         case 0xC7:      index = 128;    break;  // Ç
1329         case 0xFC:      index = 129;    break;  // ü
1330         case 0xE9:      index = 130;    break;  // é
1331         case 0xE2:      index = 131;    break;  // â
1332         case 0xE4:      index = 132;    break;  // ä
1333         case 0xE0:      index = 133;    break;  // à
1334         case 0xE5:      index = 134;    break;  // å
1335         case 0xE7:      index = 135;    break;  // ç
1336         case 0xEA:      index = 136;    break;  // ê
1337         case 0xEB:      index = 137;    break;  // ë
1338         case 0xE8:      index = 138;    break;  // è
1339         case 0xEF:      index = 139;    break;  // ï
1340         case 0xEE:      index = 140;    break;  // î
1341         case 0xEC:      index = 141;    break;  // ì
1342         case 0xC4:      index = 142;    break;  // Ä
1343         case 0xC5:      index = 143;    break;  // Å
1344         }
1345
1346         return &VTermFont[index*FONT_HEIGHT];
1347 }
1348
1349 EXPORTAS(&giVT_CharWidth, giVT_CharWidth);
1350 EXPORTAS(&giVT_CharHeight, giVT_CharHeight);
1351 EXPORT(VT_Font_Render);
1352 EXPORT(VT_Colour12to24);