Kernel/drv/vterm.c

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