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