Diff for /qemu/console.c between versions 1.1.1.2 and 1.1.1.3

version 1.1.1.2, 2018/04/24 16:40:37 version 1.1.1.3, 2018/04/24 16:42:39
Line 27 Line 27
 #define DEFAULT_BACKSCROLL 512  #define DEFAULT_BACKSCROLL 512
 #define MAX_CONSOLES 12  #define MAX_CONSOLES 12
   
 #define RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))  #define QEMU_RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
 #define RGB(r, g, b) RGBA(r, g, b, 0xff)  #define QEMU_RGB(r, g, b) QEMU_RGBA(r, g, b, 0xff)
   
 typedef struct TextAttributes {  typedef struct TextAttributes {
     uint8_t fgcol:4;      uint8_t fgcol:4;
Line 53  enum TTYState { Line 53  enum TTYState {
     TTY_STATE_CSI,      TTY_STATE_CSI,
 };  };
   
   typedef struct QEMUFIFO {
       uint8_t *buf;
       int buf_size;
       int count, wptr, rptr;
   } QEMUFIFO;
   
   int qemu_fifo_write(QEMUFIFO *f, const uint8_t *buf, int len1)
   {
       int l, len;
   
       l = f->buf_size - f->count;
       if (len1 > l)
           len1 = l;
       len = len1;
       while (len > 0) {
           l = f->buf_size - f->wptr;
           if (l > len)
               l = len;
           memcpy(f->buf + f->wptr, buf, l);
           f->wptr += l;
           if (f->wptr >= f->buf_size)
               f->wptr = 0;
           buf += l;
           len -= l;
       }
       f->count += len1;
       return len1;
   }
   
   int qemu_fifo_read(QEMUFIFO *f, uint8_t *buf, int len1)
   {
       int l, len;
   
       if (len1 > f->count)
           len1 = f->count;
       len = len1;
       while (len > 0) {
           l = f->buf_size - f->rptr;
           if (l > len)
               l = len;
           memcpy(buf, f->buf + f->rptr, l);
           f->rptr += l;
           if (f->rptr >= f->buf_size)
               f->rptr = 0;
           buf += l;
           len -= l;
       }
       f->count -= len1;
       return len1;
   }
   
 /* ??? This is mis-named.  /* ??? This is mis-named.
    It is used for both text and graphical consoles.  */     It is used for both text and graphical consoles.  */
 struct TextConsole {  struct TextConsole {
Line 81  struct TextConsole { Line 132  struct TextConsole {
     int nb_esc_params;      int nb_esc_params;
   
     /* kbd read handler */      /* kbd read handler */
       IOCanRWHandler *fd_can_read; 
     IOReadHandler *fd_read;      IOReadHandler *fd_read;
     void *fd_opaque;      void *fd_opaque;
       /* fifo for key pressed */
       QEMUFIFO out_fifo;
       uint8_t out_fifo_buf[16];
       QEMUTimer *kbd_timer;
 };  };
   
 static TextConsole *active_console;  static TextConsole *active_console;
Line 274  enum color_names { Line 330  enum color_names {
   
 static const uint32_t color_table_rgb[2][8] = {  static const uint32_t color_table_rgb[2][8] = {
     {   /* dark */      {   /* dark */
         RGB(0x00, 0x00, 0x00),  /* black */          QEMU_RGB(0x00, 0x00, 0x00),  /* black */
         RGB(0xaa, 0x00, 0x00),  /* red */          QEMU_RGB(0xaa, 0x00, 0x00),  /* red */
         RGB(0x00, 0xaa, 0x00),  /* green */          QEMU_RGB(0x00, 0xaa, 0x00),  /* green */
         RGB(0xaa, 0xaa, 0x00),  /* yellow */          QEMU_RGB(0xaa, 0xaa, 0x00),  /* yellow */
         RGB(0x00, 0x00, 0xaa),  /* blue */          QEMU_RGB(0x00, 0x00, 0xaa),  /* blue */
         RGB(0xaa, 0x00, 0xaa),  /* magenta */          QEMU_RGB(0xaa, 0x00, 0xaa),  /* magenta */
         RGB(0x00, 0xaa, 0xaa),  /* cyan */          QEMU_RGB(0x00, 0xaa, 0xaa),  /* cyan */
         RGB(0xaa, 0xaa, 0xaa),  /* white */          QEMU_RGB(0xaa, 0xaa, 0xaa),  /* white */
     },      },
     {   /* bright */      {   /* bright */
         RGB(0x00, 0x00, 0x00),  /* black */          QEMU_RGB(0x00, 0x00, 0x00),  /* black */
         RGB(0xff, 0x00, 0x00),  /* red */          QEMU_RGB(0xff, 0x00, 0x00),  /* red */
         RGB(0x00, 0xff, 0x00),  /* green */          QEMU_RGB(0x00, 0xff, 0x00),  /* green */
         RGB(0xff, 0xff, 0x00),  /* yellow */          QEMU_RGB(0xff, 0xff, 0x00),  /* yellow */
         RGB(0x00, 0x00, 0xff),  /* blue */          QEMU_RGB(0x00, 0x00, 0xff),  /* blue */
         RGB(0xff, 0x00, 0xff),  /* magenta */          QEMU_RGB(0xff, 0x00, 0xff),  /* magenta */
         RGB(0x00, 0xff, 0xff),  /* cyan */          QEMU_RGB(0x00, 0xff, 0xff),  /* cyan */
         RGB(0xff, 0xff, 0xff),  /* white */          QEMU_RGB(0xff, 0xff, 0xff),  /* white */
     }      }
 };  };
   
Line 563  static void console_put_lf(TextConsole * Line 619  static void console_put_lf(TextConsole *
     TextCell *c;      TextCell *c;
     int x, y1;      int x, y1;
   
     s->x = 0;  
     s->y++;      s->y++;
     if (s->y >= s->height) {      if (s->y >= s->height) {
         s->y = s->height - 1;          s->y = s->height - 1;
Line 712  static void console_putchar(TextConsole  Line 767  static void console_putchar(TextConsole 
             console_put_lf(s);              console_put_lf(s);
             break;              break;
         case '\b':  /* backspace */          case '\b':  /* backspace */
             if(s->x > 0) s->x--;              if (s->x > 0) 
             y1 = (s->y_base + s->y) % s->total_height;                  s->x--;
             c = &s->cells[y1 * s->width + s->x];  
             c->ch = ' ';  
             c->t_attrib = s->t_attrib;  
             update_xy(s, s->x, s->y);  
             break;              break;
         case '\t':  /* tabspace */          case '\t':  /* tabspace */
             if (s->x + (8 - (s->x % 8)) > s->width) {              if (s->x + (8 - (s->x % 8)) > s->width) {
                   s->x = 0;
                 console_put_lf(s);                  console_put_lf(s);
             } else {              } else {
                 s->x = s->x + (8 - (s->x % 8));                  s->x = s->x + (8 - (s->x % 8));
Line 739  static void console_putchar(TextConsole  Line 791  static void console_putchar(TextConsole 
             c->t_attrib = s->t_attrib;              c->t_attrib = s->t_attrib;
             update_xy(s, s->x, s->y);              update_xy(s, s->x, s->y);
             s->x++;              s->x++;
             if (s->x >= s->width)              if (s->x >= s->width) {
                   s->x = 0;
                 console_put_lf(s);                  console_put_lf(s);
               }
             break;              break;
         }          }
         break;          break;
Line 835  static void console_chr_add_read_handler Line 889  static void console_chr_add_read_handler
                                          IOReadHandler *fd_read, void *opaque)                                           IOReadHandler *fd_read, void *opaque)
 {  {
     TextConsole *s = chr->opaque;      TextConsole *s = chr->opaque;
       s->fd_can_read = fd_can_read;
     s->fd_read = fd_read;      s->fd_read = fd_read;
     s->fd_opaque = opaque;      s->fd_opaque = opaque;
 }  }
Line 854  static void console_send_event(CharDrive Line 909  static void console_send_event(CharDrive
     }      }
 }  }
   
   static void kbd_send_chars(void *opaque)
   {
       TextConsole *s = opaque;
       int len;
       uint8_t buf[16];
       
       len = s->fd_can_read(s->fd_opaque);
       if (len > s->out_fifo.count)
           len = s->out_fifo.count;
       if (len > 0) {
           if (len > sizeof(buf))
               len = sizeof(buf);
           qemu_fifo_read(&s->out_fifo, buf, len);
           s->fd_read(s->fd_opaque, buf, len);
       }
       /* characters are pending: we send them a bit later (XXX:
          horrible, should change char device API) */
       if (s->out_fifo.count > 0) {
           qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1);
       }
   }
   
 /* called when an ascii key is pressed */  /* called when an ascii key is pressed */
 void kbd_put_keysym(int keysym)  void kbd_put_keysym(int keysym)
 {  {
Line 879  void kbd_put_keysym(int keysym) Line 956  void kbd_put_keysym(int keysym)
         console_scroll(10);          console_scroll(10);
         break;          break;
     default:      default:
         if (s->fd_read) {          /* convert the QEMU keysym to VT100 key string */
             /* convert the QEMU keysym to VT100 key string */          q = buf;
             q = buf;          if (keysym >= 0xe100 && keysym <= 0xe11f) {
             if (keysym >= 0xe100 && keysym <= 0xe11f) {              *q++ = '\033';
                 *q++ = '\033';              *q++ = '[';
                 *q++ = '[';              c = keysym - 0xe100;
                 c = keysym - 0xe100;              if (c >= 10)
                 if (c >= 10)                  *q++ = '0' + (c / 10);
                     *q++ = '0' + (c / 10);              *q++ = '0' + (c % 10);
                 *q++ = '0' + (c % 10);              *q++ = '~';
                 *q++ = '~';          } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
             } else if (keysym >= 0xe120 && keysym <= 0xe17f) {              *q++ = '\033';
                 *q++ = '\033';              *q++ = '[';
                 *q++ = '[';              *q++ = keysym & 0xff;
                 *q++ = keysym & 0xff;          } else {
             } else {  
                 *q++ = keysym;                  *q++ = keysym;
             }          }
             s->fd_read(s->fd_opaque, buf, q - buf);          if (s->fd_read) {
               qemu_fifo_write(&s->out_fifo, buf, q - buf);
               kbd_send_chars(s);
         }          }
         break;          break;
     }      }
Line 974  CharDriverState *text_console_init(Displ Line 1052  CharDriverState *text_console_init(Displ
     chr->chr_add_read_handler = console_chr_add_read_handler;      chr->chr_add_read_handler = console_chr_add_read_handler;
     chr->chr_send_event = console_send_event;      chr->chr_send_event = console_send_event;
   
       s->out_fifo.buf = s->out_fifo_buf;
       s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
       s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);
       
     if (!color_inited) {      if (!color_inited) {
         color_inited = 1;          color_inited = 1;
         for(j = 0; j < 2; j++) {          for(j = 0; j < 2; j++) {

Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.3


unix.superglobalmegacorp.com