Changeset 6d5e378 in mainline for uspace/srv/hid/output


Ignore:
Timestamp:
2012-08-16T19:27:44Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4f351432, 7d27f422
Parents:
c9d011e4
Message:

cherrypick GUI implementation (originally by Petr Koupy), with several major changes

  • for character-oriented devices a new output server and output protocol was created based on the original fb server
  • DDF visualizer drivers are pixel-oriented only
  • console and compositor can coexist in the same build
  • terminal widget is self-sufficient, no strange console nesting is needed
Location:
uspace/srv/hid/output
Files:
4 added
15 moved

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/output/Makefile

    rc9d011e4 r6d5e378  
    2929
    3030USPACE_PREFIX = ../../..
    31 LIBS = $(LIBFB_PREFIX)/libfb.a
    32 EXTRA_CFLAGS += -I$(LIBFB_PREFIX)
    33 BINARY = fb
     31BINARY = output
    3432
    3533SOURCES = \
    36         gfx/font-8x16.c \
    3734        ctl/serial.c \
    3835        port/ega.c \
    39         port/kfb.c \
    4036        port/kchar.c \
    4137        port/niagara.c \
    4238        port/ski.c \
    4339        proto/vt100.c \
    44         fb.c
     40        output.c
    4541
    4642include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/hid/output/ctl/serial.c

    rc9d011e4 r6d5e378  
    2828 */
    2929
    30 /** @file
     30/** @addtogroup console
     31 * @{
     32 */
     33/**
     34 * @file
    3135 */
    3236
    3337#include <sys/types.h>
    3438#include <errno.h>
    35 #include <malloc.h>
    36 #include <screenbuffer.h>
     39#include <io/chargrid.h>
     40#include "../output.h"
    3741#include "../proto/vt100.h"
    38 #include "../fb.h"
    3942#include "serial.h"
    4043
    41 /** Draw the character at the specified position in viewport.
     44#define SERIAL_COLS  80
     45#define SERIAL_ROWS  24
     46
     47/** Draw the character at the specified position.
    4248 *
    4349 * @param state VT100 protocol state.
    44  * @param vp    Viewport.
    45  * @param col   Screen position relative to viewport.
    46  * @param row   Screen position relative to viewport.
     50 * @param field Character field.
     51 * @param col   Horizontal screen position.
     52 * @param row   Vertical screen position.
    4753 *
    4854 */
    49 static void draw_vp_char(vt100_state_t *state, fbvp_t *vp, sysarg_t col,
    50     sysarg_t row)
     55static void draw_char(vt100_state_t *state, charfield_t *field,
     56    sysarg_t col, sysarg_t row)
    5157{
    52         sysarg_t x = vp->x + col;
    53         sysarg_t y = vp->y + row;
    54        
    55         charfield_t *field = screenbuffer_field_at(vp->backbuf, col, row);
    56        
    57         vt100_goto(state, x, y);
     58        vt100_goto(state, col, row);
    5859        vt100_set_attr(state, field->attrs);
    5960        vt100_putchar(state, field->ch);
    6061}
    6162
    62 static int serial_yield(fbdev_t *dev)
     63static int serial_yield(outdev_t *dev)
    6364{
    6465        vt100_state_t *state = (vt100_state_t *) dev->data;
     66       
    6567        return vt100_yield(state);
    6668}
    6769
    68 static int serial_claim(fbdev_t *dev)
     70static int serial_claim(outdev_t *dev)
    6971{
    7072        vt100_state_t *state = (vt100_state_t *) dev->data;
     73       
    7174        return vt100_claim(state);
    7275}
    7376
    74 static int serial_get_resolution(fbdev_t *dev, sysarg_t *width, sysarg_t *height)
    75 {
    76         vt100_state_t *state = (vt100_state_t *) dev->data;
    77         vt100_get_resolution(state, width, height);
    78         return EOK;
    79 }
    80 
    81 static void serial_font_metrics(fbdev_t *dev, sysarg_t width, sysarg_t height,
    82     sysarg_t *cols, sysarg_t *rows)
    83 {
    84         *cols = width;
    85         *rows = height;
    86 }
    87 
    88 static int serial_vp_create(fbdev_t *dev, fbvp_t *vp)
    89 {
    90         vp->attrs.type = CHAR_ATTR_STYLE;
    91         vp->attrs.val.style = STYLE_NORMAL;
    92         vp->data = NULL;
    93        
    94         return EOK;
    95 }
    96 
    97 static void serial_vp_destroy(fbdev_t *dev, fbvp_t *vp)
    98 {
    99         /* No-op */
    100 }
    101 
    102 static void serial_vp_clear(fbdev_t *dev, fbvp_t *vp)
     77static void serial_get_dimensions(outdev_t *dev, sysarg_t *cols,
     78    sysarg_t *rows)
    10379{
    10480        vt100_state_t *state = (vt100_state_t *) dev->data;
    10581       
    106         for (sysarg_t row = 0; row < vp->rows; row++) {
    107                 for (sysarg_t col = 0; col < vp->cols; col++) {
    108                         charfield_t *field =
    109                             screenbuffer_field_at(vp->backbuf, col, row);
    110                        
    111                         field->ch = 0;
    112                         field->attrs = vp->attrs;
    113                        
    114                         draw_vp_char(state, vp, col, row);
    115                 }
    116         }
     82        vt100_get_dimensions(state, cols, rows);
    11783}
    11884
    119 static console_caps_t serial_vp_get_caps(fbdev_t *dev, fbvp_t *vp)
     85static console_caps_t serial_get_caps(outdev_t *dev)
    12086{
    12187        return (CONSOLE_CAP_STYLE | CONSOLE_CAP_INDEXED);
    12288}
    12389
    124 static void serial_vp_cursor_update(fbdev_t *dev, fbvp_t *vp,
    125     sysarg_t prev_col, sysarg_t prev_row, sysarg_t col, sysarg_t row,
    126     bool visible)
     90static void serial_cursor_update(outdev_t *dev, sysarg_t prev_col,
     91    sysarg_t prev_row, sysarg_t col, sysarg_t row, bool visible)
    12792{
    12893        vt100_state_t *state = (vt100_state_t *) dev->data;
    12994       
    130         vt100_goto(state, vp->x + col, vp->y + row);
     95        vt100_goto(state, col, row);
    13196        vt100_cursor_visibility(state, visible);
    13297}
    13398
    134 static void serial_vp_char_update(fbdev_t *dev, fbvp_t *vp, sysarg_t col,
    135     sysarg_t row)
     99static void serial_char_update(outdev_t *dev, sysarg_t col, sysarg_t row)
    136100{
    137101        vt100_state_t *state = (vt100_state_t *) dev->data;
    138         draw_vp_char(state, vp, col, row);
     102        charfield_t *field =
     103            chargrid_charfield_at(dev->backbuf, col, row);
     104       
     105        draw_char(state, field, col, row);
    139106}
    140107
    141 static fbdev_ops_t serial_ops = {
     108static outdev_ops_t serial_ops = {
    142109        .yield = serial_yield,
    143110        .claim = serial_claim,
    144         .get_resolution = serial_get_resolution,
    145         .font_metrics = serial_font_metrics,
    146         .vp_create = serial_vp_create,
    147         .vp_destroy = serial_vp_destroy,
    148         .vp_clear = serial_vp_clear,
    149         .vp_get_caps = serial_vp_get_caps,
    150         .vp_cursor_update = serial_vp_cursor_update,
    151         .vp_char_update = serial_vp_char_update
     111        .get_dimensions = serial_get_dimensions,
     112        .get_caps = serial_get_caps,
     113        .cursor_update = serial_cursor_update,
     114        .char_update = serial_char_update
    152115};
    153116
    … …  
    156119{
    157120        vt100_state_t *state =
    158             vt100_state_create(80, 24, putchar_fn, control_puts_fn);
     121            vt100_state_create(SERIAL_COLS, SERIAL_ROWS, putchar_fn,
     122            control_puts_fn);
    159123        if (state == NULL)
    160124                return ENOMEM;
    161125       
    162         fbdev_t *dev = fbdev_register(&serial_ops, state);
    163         if (dev == NULL)
    164                 return EINVAL;
     126        outdev_t *dev = outdev_register(&serial_ops, state);
     127        if (dev == NULL) {
     128                vt100_state_destroy(state);
     129                return ENOMEM;
     130        }
    165131       
    166132        return EOK;

  • uspace/srv/hid/output/ctl/serial.h

    rc9d011e4 r6d5e378  
    3131 */
    3232
    33 #ifndef FB_CTL_SERIAL_H_
    34 #define FB_CTL_SERIAL_H_
     33#ifndef OUTPUT_CTL_SERIAL_H_
     34#define OUTPUT_CTL_SERIAL_H_
    3535
    3636#include "../proto/vt100.h"

  • uspace/srv/hid/output/port/ega.c

    rc9d011e4 r6d5e378  
    3333#include <errno.h>
    3434#include <sysinfo.h>
    35 #include <task.h>
     35#include <align.h>
     36#include <as.h>
    3637#include <ddi.h>
    3738#include <libarch/ddi.h>
    38 #include <as.h>
    39 #include <malloc.h>
    40 #include <align.h>
    41 #include <screenbuffer.h>
    42 #include "../fb.h"
     39#include <io/chargrid.h>
     40#include "../output.h"
    4341#include "ega.h"
    4442
    … …  
    4644#define EGA_IO_SIZE  2
    4745
    48 #define FB_POS(x, y)  (((y) * ega.width + (x)) << 1)
     46#define FB_POS(x, y)  (((y) * ega.cols + (x)) << 1)
    4947
    5048typedef struct {
    51         sysarg_t width;
    52         sysarg_t height;
     49        sysarg_t cols;
     50        sysarg_t rows;
     51       
     52        uint8_t style_normal;
     53        uint8_t style_inverted;
    5354       
    5455        size_t size;
    5556        uint8_t *addr;
    56        
    57         uint8_t style_normal;
    58         uint8_t style_inverted;
    59        
    60         uint8_t *backbuf;
    6157} ega_t;
    6258
    … …  
    10197}
    10298
    103 /** Draw the character at the specified position in viewport.
    104  *
    105  * @param vp     Viewport.
    106  * @param col    Screen position relative to viewport.
    107  * @param row    Screen position relative to viewport.
    108  *
    109  */
    110 static void draw_vp_char(fbvp_t *vp, sysarg_t col, sysarg_t row)
    111 {
    112         sysarg_t x = vp->x + col;
    113         sysarg_t y = vp->y + row;
    114        
    115         charfield_t *field = screenbuffer_field_at(vp->backbuf, col, row);
    116        
     99/** Draw the character at the specified position.
     100 *
     101 * @param field Character field.
     102 * @param col   Horizontal screen position.
     103 * @param row   Vertical screen position.
     104 *
     105 */
     106static void draw_char(charfield_t *field, sysarg_t col, sysarg_t row)
     107{
    117108        uint8_t glyph;
    118109       
    … …  
    124115        uint8_t attr = attrs_attr(field->attrs);
    125116       
    126         ega.addr[FB_POS(x, y)] = glyph;
    127         ega.addr[FB_POS(x, y) + 1] = attr;
    128 }
    129 
    130 static int ega_yield(fbdev_t *dev)
    131 {
    132         if (ega.backbuf == NULL) {
    133                 ega.backbuf = malloc(ega.size);
    134                 if (ega.backbuf == NULL)
    135                         return ENOMEM;
    136         }
    137        
    138         memcpy(ega.backbuf, ega.addr, ega.size);
     117        ega.addr[FB_POS(col, row)] = glyph;
     118        ega.addr[FB_POS(col, row) + 1] = attr;
     119}
     120
     121static int ega_yield(outdev_t *dev)
     122{
    139123        return EOK;
    140124}
    141125
    142 static int ega_claim(fbdev_t *dev)
    143 {
    144         if (ega.backbuf == NULL)
    145                 return ENOENT;
    146        
    147         memcpy(ega.addr, ega.backbuf, ega.size);
     126static int ega_claim(outdev_t *dev)
     127{
    148128        return EOK;
    149129}
    150130
    151 static int ega_get_resolution(fbdev_t *dev, sysarg_t *width, sysarg_t *height)
    152 {
    153         *width = ega.width;
    154         *height = ega.height;
    155         return EOK;
    156 }
    157 
    158 static void ega_font_metrics(fbdev_t *dev, sysarg_t width, sysarg_t height,
    159     sysarg_t *cols, sysarg_t *rows)
    160 {
    161         *cols = width;
    162         *rows = height;
    163 }
    164 
    165 static int ega_vp_create(fbdev_t *dev, fbvp_t *vp)
    166 {
    167         vp->attrs.type = CHAR_ATTR_STYLE;
    168         vp->attrs.val.style = STYLE_NORMAL;
    169         vp->data = NULL;
    170        
    171         return EOK;
    172 }
    173 
    174 static void ega_vp_destroy(fbdev_t *dev, fbvp_t *vp)
    175 {
    176         /* No-op */
    177 }
    178 
    179 static void ega_vp_clear(fbdev_t *dev, fbvp_t *vp)
    180 {
    181         for (sysarg_t row = 0; row < vp->rows; row++) {
    182                 for (sysarg_t col = 0; col < vp->cols; col++) {
    183                         charfield_t *field =
    184                             screenbuffer_field_at(vp->backbuf, col, row);
    185                        
    186                         field->ch = 0;
    187                         field->attrs = vp->attrs;
    188                        
    189                         draw_vp_char(vp, col, row);
    190                 }
    191         }
    192 }
    193 
    194 static console_caps_t ega_vp_get_caps(fbdev_t *dev, fbvp_t *vp)
     131static void ega_get_dimensions(outdev_t *dev, sysarg_t *cols, sysarg_t *rows)
     132{
     133        *cols = ega.cols;
     134        *rows = ega.rows;
     135}
     136
     137static console_caps_t ega_get_caps(outdev_t *dev)
    195138{
    196139        return (CONSOLE_CAP_STYLE | CONSOLE_CAP_INDEXED);
    197140}
    198141
    199 static void ega_vp_cursor_update(fbdev_t *dev, fbvp_t *vp, sysarg_t prev_col,
     142static void ega_cursor_update(outdev_t *dev, sysarg_t prev_col,
    200143    sysarg_t prev_row, sysarg_t col, sysarg_t row, bool visible)
    201144{
    202145        /* Cursor position */
    203         uint16_t cursor = row * ega.width + col;
     146        uint16_t cursor = row * ega.cols + col;
    204147       
    205148        pio_write_8(EGA_IO_BASE, 0x0e);
    … …  
    220163}
    221164
    222 static void ega_vp_char_update(fbdev_t *dev, fbvp_t *vp, sysarg_t col,
    223     sysarg_t row)
    224 {
    225         draw_vp_char(vp, col, row);
    226 }
    227 
    228 static fbdev_ops_t ega_ops = {
     165static void ega_char_update(outdev_t *dev, sysarg_t col, sysarg_t row)
     166{
     167        charfield_t *field =
     168            chargrid_charfield_at(dev->backbuf, col, row);
     169       
     170        draw_char(field, col, row);
     171}
     172
     173static outdev_ops_t ega_ops = {
    229174        .yield = ega_yield,
    230175        .claim = ega_claim,
    231         .get_resolution = ega_get_resolution,
    232         .font_metrics = ega_font_metrics,
    233         .vp_create = ega_vp_create,
    234         .vp_destroy = ega_vp_destroy,
    235         .vp_clear = ega_vp_clear,
    236         .vp_get_caps = ega_vp_get_caps,
    237         .vp_cursor_update = ega_vp_cursor_update,
    238         .vp_char_update = ega_vp_char_update
     176        .get_dimensions = ega_get_dimensions,
     177        .get_caps = ega_get_caps,
     178        .cursor_update = ega_cursor_update,
     179        .char_update = ega_char_update
    239180};
    240181
    … …  
    262203                return rc;
    263204       
    264         sysarg_t width;
    265         rc = sysinfo_get_value("fb.width", &width);
    266         if (rc != EOK)
    267                 return rc;
    268        
    269         sysarg_t height;
    270         rc = sysinfo_get_value("fb.height", &height);
    271         if (rc != EOK)
    272                 return rc;
    273        
    274         rc = iospace_enable(task_get_id(), (void *) EGA_IO_BASE, EGA_IO_SIZE);
    275         if (rc != EOK)
    276                 return rc;
    277        
    278         ega.width = width;
    279         ega.height = height;
    280        
    281         ega.size = (width * height) << 1;
     205        rc = sysinfo_get_value("fb.width", &ega.cols);
     206        if (rc != EOK)
     207                return rc;
     208       
     209        rc = sysinfo_get_value("fb.height", &ega.rows);
     210        if (rc != EOK)
     211                return rc;
     212       
     213        rc = iospace_enable(task_get_id(), (void *) EGA_IO_BASE,
     214            EGA_IO_SIZE);
     215        if (rc != EOK)
     216                return rc;
     217       
     218        ega.size = (ega.cols * ega.rows) << 1;
    282219       
    283220        rc = physmem_map((void *) paddr,
    … …  
    300237        }
    301238       
    302         ega.backbuf = NULL;
    303        
    304         fbdev_t *dev = fbdev_register(&ega_ops, (void *) &ega);
     239        outdev_t *dev = outdev_register(&ega_ops, (void *) &ega);
    305240        if (dev == NULL) {
    306241                as_area_destroy(ega.addr);
    … …  
    311246}
    312247
    313 /**
    314  * @}
    315  */
     248/** @}
     249 */

  • uspace/srv/hid/output/port/ega.h

    rc9d011e4 r6d5e378  
    3030 */
    3131
    32 #ifndef FB_PORT_EGA_H_
    33 #define FB_PORT_EGA_H_
     32#ifndef OUTPUT_PORT_EGA_H_
     33#define OUTPUT_PORT_EGA_H_
    3434
    3535extern int ega_init(void);

  • uspace/srv/hid/output/port/kchar.c

    rc9d011e4 r6d5e378  
    3333#include <sys/types.h>
    3434#include <errno.h>
     35#include <str.h>
    3536#include <sysinfo.h>
    3637#include <ddi.h>
     38#include <align.h>
    3739#include <as.h>
    38 #include <align.h>
    3940#include "../ctl/serial.h"
    4041#include "kchar.h"

  • uspace/srv/hid/output/port/kchar.h

    rc9d011e4 r6d5e378  
    3131 */
    3232
    33 #ifndef FB_PORT_KCHAR_H_
    34 #define FB_PORT_KCHAR_H_
     33#ifndef OUTPUT_PORT_KCHAR_H_
     34#define OUTPUT_PORT_KCHAR_H_
    3535
    3636extern int kchar_init(void);

  • uspace/srv/hid/output/port/niagara.c

    rc9d011e4 r6d5e378  
    3838#include <as.h>
    3939#include <align.h>
     40#include <str.h>
    4041#include "../ctl/serial.h"
    4142#include "niagara.h"

  • uspace/srv/hid/output/port/niagara.h

    rc9d011e4 r6d5e378  
    3030 */
    3131
    32 #ifndef FB_PORT_NIAGARA_H_
    33 #define FB_PORT_NIAGARA_H_
     32#ifndef OUTPUT_PORT_NIAGARA_H_
     33#define OUTPUT_PORT_NIAGARA_H_
    3434
    3535extern int niagara_init(void);
    … …  
    3737#endif
    3838
    39 /**
    40  * @}
     39/** @}
    4140 */

  • uspace/srv/hid/output/port/ski.h

    rc9d011e4 r6d5e378  
    2727 */
    2828
    29 /** @file
     29/** @addtogroup console
     30 * @{
     31 */
     32/**
     33 * @file
    3034 */
    3135
    32 #ifndef FB_PORT_SKI_H_
    33 #define FB_PORT_SKI_H_
     36#ifndef OUTPUT_PORT_SKI_H_
     37#define OUTPUT_PORT_SKI_H_
    3438
    3539extern int ski_init(void);

  • uspace/srv/hid/output/proto/vt100.c

    rc9d011e4 r6d5e378  
    3232#include <sys/types.h>
    3333#include <inttypes.h>
     34#include <errno.h>
    3435#include <stdio.h>
     36#include <unistd.h>
     37#include <malloc.h>
    3538#include <io/color.h>
    36 #include <malloc.h>
    37 #include <errno.h>
    3839#include "vt100.h"
    3940
    4041#define MAX_CONTROL  20
    41 
    42 #define BACKBUF_POS(state, x, y)  ((y) * ((state)->width) + (x))
    43 
    44 struct vt100_state {
    45         vt100_putchar_t putchar;
    46         vt100_control_puts_t control_puts;
    47        
    48         sysarg_t width;
    49         sysarg_t height;
    50        
    51         sysarg_t cur_col;
    52         sysarg_t cur_row;
    53        
    54         char_attrs_t cur_attrs;
    55        
    56         charfield_t backbuf[];
    57 };
    5842
    5943typedef enum {
    … …  
    154138}
    155139
    156 vt100_state_t *vt100_state_create(sysarg_t width, sysarg_t height,
     140vt100_state_t *vt100_state_create(sysarg_t cols, sysarg_t rows,
    157141    vt100_putchar_t putchar_fn, vt100_control_puts_t control_puts_fn)
    158142{
    159         size_t sz = width * height * sizeof(charfield_t);
    160        
    161143        vt100_state_t *state =
    162             malloc(sizeof(vt100_state_t) + sz);
     144            malloc(sizeof(vt100_state_t));
    163145        if (state == NULL)
    164146                return NULL;
    … …  
    167149        state->control_puts = control_puts_fn;
    168150       
    169         state->width = width;
    170         state->height = height;
     151        state->cols = cols;
     152        state->rows = rows;
    171153       
    172154        state->cur_col = (sysarg_t) -1;
    … …  
    175157        state->cur_attrs.type = CHAR_ATTR_STYLE;
    176158        state->cur_attrs.val.style = STYLE_NORMAL;
    177        
    178         memset(state->backbuf, 0, sz);
    179159       
    180160        /* Initialize graphic rendition attributes */
    … …  
    183163        vt100_sgr(state, SGR_BGCOLOR + CI_WHITE);
    184164        state->control_puts("\033[2J");
     165        state->control_puts("\033[?25l");
    185166       
    186167        return state;
    187168}
    188169
    189 void vt100_get_resolution(vt100_state_t *state, sysarg_t *width,
    190     sysarg_t *height)
    191 {
    192         *width = state->width;
    193         *height = state->height;
     170void vt100_state_destroy(vt100_state_t *state)
     171{
     172        free(state);
     173}
     174
     175void vt100_get_dimensions(vt100_state_t *state, sysarg_t *cols,
     176    sysarg_t *rows)
     177{
     178        *cols = state->cols;
     179        *rows = state->rows;
    194180}
    195181
    … …  
    201187int vt100_claim(vt100_state_t *state)
    202188{
    203         for (sysarg_t row = 0; row < state->height; row++) {
    204                 vt100_set_pos(state, 0, row);
    205                 for (sysarg_t col = 0; col < state->width; col++) {
    206                         charfield_t *field = state->backbuf +
    207                             BACKBUF_POS(state, col, row);
    208                         vt100_set_sgr(state, field->attrs);
    209                         state->putchar(field->ch);
    210                 }
    211         }
    212        
    213         vt100_set_pos(state, state->cur_col, state->cur_row);
    214         vt100_set_sgr(state, state->cur_attrs);
    215        
    216189        return EOK;
    217190}
    218191
    219 void vt100_putchar(vt100_state_t *state, wchar_t ch)
    220 {
    221         charfield_t *field = state->backbuf +
    222             BACKBUF_POS(state, state->cur_col, state->cur_row);
    223         field->ch = ch;
    224         field->attrs = state->cur_attrs;
    225        
    226         state->putchar(ch);
    227         state->cur_col++;
    228        
    229         if (state->cur_col >= state->width) {
    230                 state->cur_row += state->cur_col / state->width;
    231                 state->cur_col %= state->width;
    232         }
    233 }
    234 
    235 void vt100_set_attr(vt100_state_t *state, char_attrs_t attrs)
    236 {
    237         if (!attrs_same(state->cur_attrs, attrs)) {
    238                 vt100_set_sgr(state, attrs);
    239                 state->cur_attrs = attrs;
    240         }
    241 }
    242 
    243192void vt100_goto(vt100_state_t *state, sysarg_t col, sysarg_t row)
    244193{
    245         if ((col >= state->width) || (row >= state->height))
     194        if ((col >= state->cols) || (row >= state->rows))
    246195                return;
    247196       
    … …  
    253202}
    254203
     204void vt100_set_attr(vt100_state_t *state, char_attrs_t attrs)
     205{
     206        if (!attrs_same(state->cur_attrs, attrs)) {
     207                vt100_set_sgr(state, attrs);
     208                state->cur_attrs = attrs;
     209        }
     210}
     211
    255212void vt100_cursor_visibility(vt100_state_t *state, bool visible)
    256213{
    … …  
    261218}
    262219
     220void vt100_putchar(vt100_state_t *state, wchar_t ch)
     221{
     222        state->putchar(ch == 0 ? ' ' : ch);
     223        state->cur_col++;
     224       
     225        if (state->cur_col >= state->cols) {
     226                state->cur_row += state->cur_col / state->cols;
     227                state->cur_col %= state->cols;
     228        }
     229}
     230
    263231/** @}
    264232 */

  • uspace/srv/hid/output/proto/vt100.h

    rc9d011e4 r6d5e378  
    3030 */
    3131
    32 #ifndef FB_PROTO_VT100_H_
    33 #define FB_PROTO_VT100_H_
     32#ifndef OUTPUT_PROTO_VT100_H_
     33#define OUTPUT_PROTO_VT100_H_
    3434
    3535#include <sys/types.h>
    36 #include <screenbuffer.h>
     36#include <io/charfield.h>
    3737
    3838typedef void (* vt100_putchar_t)(wchar_t ch);
    3939typedef void (* vt100_control_puts_t)(const char *str);
    4040
    41 /** Forward declaration */
    42 struct vt100_state;
    43 typedef struct vt100_state vt100_state_t;
     41typedef struct {
     42        sysarg_t cols;
     43        sysarg_t rows;
     44       
     45        sysarg_t cur_col;
     46        sysarg_t cur_row;
     47        char_attrs_t cur_attrs;
     48       
     49        vt100_putchar_t putchar;
     50        vt100_control_puts_t control_puts;
     51} vt100_state_t;
    4452
    4553extern vt100_state_t *vt100_state_create(sysarg_t, sysarg_t, vt100_putchar_t,
    4654    vt100_control_puts_t);
    47 extern void vt100_get_resolution(vt100_state_t *, sysarg_t *, sysarg_t *);
     55extern void vt100_state_destroy(vt100_state_t *);
     56
    4857extern int vt100_yield(vt100_state_t *);
    4958extern int vt100_claim(vt100_state_t *);
     59extern void vt100_get_dimensions(vt100_state_t *, sysarg_t *, sysarg_t *);
    5060
     61extern void vt100_goto(vt100_state_t *, sysarg_t, sysarg_t);
     62extern void vt100_set_attr(vt100_state_t *, char_attrs_t);
     63extern void vt100_cursor_visibility(vt100_state_t *, bool);
    5164extern void vt100_putchar(vt100_state_t *, wchar_t);
    52 
    53 extern void vt100_set_attr(vt100_state_t *, char_attrs_t);
    54 extern void vt100_goto(vt100_state_t *, sysarg_t, sysarg_t);
    55 extern void vt100_cursor_visibility(vt100_state_t *, bool);
    5665
    5766#endif
Note: See TracChangeset for help on using the changeset viewer.