Esempio n. 1
0
bool tty_open(struct TTY_t *tty)
{
    if(tty == NULL)
        return false;
    tty_move_cursor(tty, 0, 0);
    tty->enable = 1;
    tty->echo = 1;
    return true;
}
Esempio n. 2
0
void tty_clear()
{
    /* Resets the whole screen */
    wmemset(tty.buf, ' ' | (0x07) << 8, SCR_SIZE * sizeof(u16));

    /* Resets the cursor */
    tty.x = tty.y = 0;
    tty_move_cursor();
}
Esempio n. 3
0
void tty_clear(struct TTY_t *tty)
{
    int8_t x, y;
    for(y = 0; y < TTY_HEIGHT; ++y) {
        for(x = 0; x < TTY_WIDTH; ++x)
            _V(x, y) = 0x0700;
    }
    tty_move_cursor(tty, 0, 0);
}
Esempio n. 4
0
File: vga.c Progetto: oridb/PhotonOS
void flush_video()
{
	clear_video();
	char c = current_tty->buffer.text[0];
	int vga_row = 0;
	int vga_column = 0;
	uint8_t color;
	
	for (int i = 0; i < STDIO_SIZE && c != 0; i++) {
		c = current_tty->buffer.text[i];
		color = make_color(current_tty->buffer.fg[i], current_tty->bg);

		switch (c) {
			case '\n':
				++vga_row;
				vga_column = -1;
				break;

			case '\t':
				for (int i = 0; i < current_tty->tabstop; ++i) {
					tty_putentryat(' ', color, vga_column, vga_row);
					vga_column++;
					if (vga_column == 80) {
						vga_row++;
						vga_column = 0;
					}
				}
				break;

			case '\b':
				--vga_column;
				tty_putentryat(' ', color, vga_column, vga_row);
				--vga_column;
				break;

			case '\a':
				// no sound support yet
				break;

			default:
				tty_putentryat(c, color, vga_column, vga_row);
				break;
		}
		vga_column++;
		if (vga_column == 80) {
			vga_row++;
			vga_column = 0;
		}
		if (tty_scroll(vga_row)) {
			vga_row = 24;
			vga_column = 0;
		}
	}
	tty_move_cursor(vga_row, vga_column);
}
Esempio n. 5
0
size_t tty_read(struct TTY_t *tty, char *buf, size_t len)
{
    size_t i = 0;
    bool shift, caps, is_alpha, cont=true;
    uint16_t scan_code, key;
    if(!(tty->enable))
        return 0;
    while(i < len && cont) {
        scan_code = pop_kbbuf(&KBBUF);
        if(scan_code) {
            key = KEYMAP[scan_code & 0xFF];
            if((key & 0xFF) < 0xE0) {
                shift = scan_code & (STATUS_SHIFT << 8);
                caps = scan_code & (STATUS_CAPS << 8);
                is_alpha = (key & 0xFF) >= 'a' && (key & 0xFF) <= 'z';

                if((is_alpha && (shift ^ caps)) || (!is_alpha && shift && SHIFTMAP[key & 0xFF]))
                    buf[i] = SHIFTMAP[key & 0xFF];
                else
                    buf[i] = key & 0xFF;

                if(tty->echo)
                    tty_write(tty, buf + i, 1);
                ++i;
            } else switch(key) {
                case ENTER:
                    tty_write(tty, "\n", 1);
                    cont = false;
                    break;
                case BACKSPACE:
                    if(tty->cur_x && i) {
                        buf[--i] = '\0';
                        if(tty->echo) {
                            tty_move_cursor(tty, tty->cur_x - 1, tty->cur_y);
                            _V(tty->cur_x, tty->cur_y) = 0x0700;
                        }
                    }
                    break;
            }
        } else {
            wait_event(KEYBOARD);
        }
    }
    buf[i] = '\0';
    return i;
}
Esempio n. 6
0
void putchar(char c)
{
    /* Prints a char */
    switch (c)
    {
        case '\n':
            putchar('\r');
            ++tty.y;
            break;

        case '\r':
            tty.x = 0;
            break;

        case '\t':
            tty.x += 4;
            tty.x &= 0xfc; /* Remove the last 2 bits making it aligned by 4 */
            break;

        default:
            if (isprint(c))
            {
                tty.buf[tty.y * SCR_WIDTH + tty.x] = c | (tty.attr << 8);
                ++tty.x;
            }
            break;
    }

    if (tty.x >= SCR_WIDTH)
    {
        tty.x = 0;
        ++tty.y;
    }

    if (tty.y >= SCR_HEIGHT)
    {
        tty.y = SCR_HEIGHT-1;
        tty_scroll();
    }

    tty_move_cursor();
}
Esempio n. 7
0
size_t tty_write_with_color(struct TTY_t *tty, const char *buf, size_t len, uint8_t color)
{
    cli();
    const char *current = buf;
    if(!(tty->enable))
        return 0;
    while(len--) {
        if(*current != '\n')
            _V(tty->cur_x, tty->cur_y) = (color << 8) | *current;
        if(*current == '\n' || tty->cur_x == TTY_WIDTH) {
            if(tty->cur_y + 1 == TTY_HEIGHT)
                scoll_up(tty, 1);
            else
                ++tty->cur_y;
            tty->cur_x = 0;
        } else {
            ++tty->cur_x;
        }
        ++current;
    }
    tty_move_cursor(tty, tty->cur_x, tty->cur_y);
    sti();
    return current - buf;
}