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