42_KFS/src/terminal/put.c

#include "ctype.h"
#include "font.h"
#include "fonts/eating_pasta_regular_32.h"
#include "kprintf.h"
#include "shell.h"
#include "string.h"
#include "sys/io.h"
#include "terminal.h"
#include "vbe.h"

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

static struct screen screens[TERM_COUNT];
struct screen *screen = &screens[0];

static inline uint8_t vga_entry_color(vga_color fg, vga_color bg)
{
	return fg | bg << 4;
}

static inline uint16_t vga_entry(unsigned char uc, uint8_t color)
{
	return (uint16_t)uc | (uint16_t)color << 8;
}

void terminal_initialize(void)
{
	for (size_t y = 0; y < VGA_HEIGHT; y++) {
		for (size_t x = 0; x < VGA_WIDTH; x++) {
			const size_t index = y * VGA_WIDTH + x;
			TERM_BUF[index] = vga_entry(' ', VGA_COLOR_WHITE);
		}
	}
	for (int i = 0; i < TERM_COUNT; i++) {
		screens[i].row = 0;
		screens[i].column = 0;
		screens[i].default_color =
		    vga_entry_color(VGA_COLOR_WHITE, VGA_COLOR_BLACK);
		screens[i].color = screens[i].default_color;
		memcpy(screens[i].buffer, TERM_BUF, sizeof(screen->buffer));
	}
}

void terminal_set_screen(int pos)
{
	memcpy(screen->buffer, TERM_BUF, sizeof(screen->buffer));
	screen = &screens[pos];
	memcpy(TERM_BUF, screen->buffer, sizeof(screen->buffer));
	update_cursor();
	if (TERM_BUF[0] == vga_entry(' ', VGA_COLOR_WHITE))
		kprintf(PROMPT);
}

void terminal_set_bg_color(uint8_t bg_color)
{
	screen->color = bg_color << 4 | (screen->color & 0x0F);
}

void terminal_set_fg_color(uint8_t fg_color)
{
	screen->color = (screen->color & 0xF0) | fg_color;
}

void terminal_set_color(uint8_t color)
{
	screen->color = color;
}

void terminal_set_default_fg_color(uint8_t fg_color)
{
	screen->default_color = (screen->default_color & 0xF0) | fg_color;
}

void terminal_set_default_bg_color(uint8_t bg_color)
{
	screen->default_color = bg_color << 4 | (screen->default_color & 0x0F);
}

uint8_t terminal_get_default_color(void)
{
	return screen->default_color;
}

uint8_t terminal_get_char(int column, int row)
{
	return screen->buffer[row * VGA_WIDTH + column];
}

void terminal_putentryat(char c, uint32_t color, size_t x, size_t y)
{
	struct font node = eating_pasta_regular_32_font[(int)c];
	char *glyph = node.bitmap;
	for (size_t cy = 0; cy < node.height; cy++)
		for (size_t cx = 0; cx < node.width; cx++)
			if (glyph[cy * node.width + cx] == '#')
				put_pixel(color, x + cx, y + cy);
	/* const size_t index = y * VGA_WIDTH + x; */
	/* TERM_BUF[index] = vga_entry(c, color); */
}

static void terminal_scroll(void)
{
	screen->row--;
	for (size_t i = 0; i < VGA_WIDTH * (VGA_HEIGHT - 1); i++)
		TERM_BUF[i] = TERM_BUF[i + VGA_WIDTH];
	for (size_t i = 0; i < VGA_WIDTH; i++)
		terminal_putentryat(' ', VGA_COLOR_WHITE, i, VGA_HEIGHT - 1);
}

static void terminal_new_line(void)
{
	screen->column = 0;
	if (++screen->row == VGA_HEIGHT)
		terminal_scroll();
}

static uint8_t get_entry_color(uint16_t vga_entry)
{
	return vga_entry >> 8;
}

void terminal_change_default_color(uint8_t color)
{
	terminal_set_color(color);
	for (size_t y = 0; y < VGA_HEIGHT; y++) {
		for (size_t x = 0; x < VGA_WIDTH; x++) {
			const size_t index = y * VGA_WIDTH + x;
			uint8_t entry_color = get_entry_color(TERM_BUF[index]);
			TERM_BUF[index] = vga_entry(
			    TERM_BUF[index],
			    entry_color == screen->default_color ? color
								 : entry_color);
		}
	}
	memcpy(screen->buffer, TERM_BUF, sizeof(screen->buffer));
	screen->default_color = color;
	screen->color = color;
}

void terminal_change_default_fg_color(uint8_t fg_color)
{
	terminal_set_fg_color(fg_color);
	terminal_change_default_color(screen->color);
}

void terminal_clear(void)
{
	for (size_t y = 0; y < VGA_HEIGHT; y++) {
		for (size_t x = 0; x < VGA_WIDTH; x++) {
			const size_t index = y * VGA_WIDTH + x;
			TERM_BUF[index] = vga_entry(' ', screen->color);
		}
	}
	memcpy(screen->buffer, TERM_BUF, sizeof(screen->buffer));
	screen->column = 0;
	screen->row = 0;
}

int terminal_putchar(char c)
{
	terminal_putentryat(c, 0xCCFFE5, 10, 10);
	/* if (c == '\r') */
	/* 	screen->column = 0; */
	/* else if (c == '\n') */
	/* 	terminal_new_line(); */
	/* if (!isprint(c)) */
	/* 	return 1; */
	/* terminal_putentryat(c, screen->color, screen->column, screen->row);
	 */
	/* if (++screen->column == VGA_WIDTH) */
	/* 	terminal_new_line(); */
	/* return 1; */
}

int terminal_write(const char *data, size_t size)
{
	size_t i;
	for (i = 0; i < size; i++)
		terminal_putchar(data[i]);
	return (int)i;
}

int terminal_writestring(const char *data)
{
	size_t len = strlen(data);
	terminal_write(data, len);
	return len;
}

void update_cursor(void)
{
	uint16_t pos = screen->row * VGA_WIDTH + screen->column;

	outb(0x3D4, 0x0F);
	outb(0x3D5, pos & 0xFF);
	outb(0x3D4, 0x0E);
	outb(0x3D5, (pos >> 8) & 0xFF);
}

void move_cursor(int direction)
{
	switch (direction) {
	case LEFT:
		if (screen->column) {
			screen->column--;
		} else if (screen->row) {
			screen->column = VGA_WIDTH - 1;
			screen->row--;
		}
		break;
	case RIGHT:
		if (screen->column < VGA_WIDTH - 1) {
			screen->column++;
		} else if (screen->row < VGA_HEIGHT - 1) {
			screen->column = 0;
			screen->row++;
		} else {
			terminal_new_line();
		}
		break;
	case UP:
		break;
	case DOWN:
		break;
	default:
		break;
	}
	update_cursor();
}

void set_color_level(int level)
{
	int color_translation[] = {
	    VGA_COLOR_WHITE,        VGA_COLOR_RED,
	    VGA_COLOR_RED,          VGA_COLOR_MAGENTA,
	    VGA_COLOR_LIGHT_YELLOW, VGA_COLOR_LIGHT_YELLOW,
	    VGA_COLOR_LIGHT_BLUE,   VGA_COLOR_GREEN,
	    VGA_COLOR_LIGHT_GREY};

	if (level == 0) {
		terminal_set_color(screen->default_color);
		return;
	}
	terminal_set_fg_color(color_translation[level]);
}