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