2021-03-02 08:05:14 +03:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <lib/gterm.h>
|
2021-04-11 03:30:48 +03:00
|
|
|
#include <lib/term.h>
|
2021-03-02 08:05:14 +03:00
|
|
|
#include <lib/blib.h>
|
|
|
|
#include <lib/libc.h>
|
|
|
|
#include <lib/config.h>
|
|
|
|
#include <lib/print.h>
|
|
|
|
#include <lib/uri.h>
|
2021-03-02 08:21:05 +03:00
|
|
|
#include <lib/fb.h>
|
2021-03-02 08:05:14 +03:00
|
|
|
#include <mm/pmm.h>
|
|
|
|
|
2021-08-18 15:06:55 +03:00
|
|
|
// Maximum allowed font size in bytes. 16kB should be enough as 9x32 is the
|
|
|
|
// largest font I've seen, and that would take 9*32 * 256 * 1/8 byte =
|
|
|
|
// 9216 bytes.
|
|
|
|
#define VGA_FONT_MAX 16384
|
2021-08-18 15:49:25 +03:00
|
|
|
#define VGA_FONT_GLYPHS 256
|
|
|
|
|
2021-08-20 20:25:42 +03:00
|
|
|
#define DEFAULT_FONT_WIDTH 8
|
|
|
|
#define DEFAULT_FONT_HEIGHT 16
|
|
|
|
|
|
|
|
static size_t vga_font_width;
|
|
|
|
static size_t vga_font_height;
|
2021-08-18 15:49:25 +03:00
|
|
|
static size_t glyph_width = 8;
|
|
|
|
static size_t glyph_height = 16;
|
|
|
|
|
|
|
|
static size_t vga_font_scale_x = 1;
|
|
|
|
static size_t vga_font_scale_y = 1;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-14 16:36:53 +03:00
|
|
|
static size_t offset_x, offset_y;
|
|
|
|
|
2021-04-07 03:10:28 +03:00
|
|
|
struct fb_info fbinfo;
|
2021-10-01 08:08:02 +03:00
|
|
|
static volatile uint32_t *gterm_framebuffer;
|
2021-03-02 08:05:14 +03:00
|
|
|
static uint16_t gterm_pitch;
|
|
|
|
static uint16_t gterm_width;
|
|
|
|
static uint16_t gterm_height;
|
|
|
|
static uint16_t gterm_bpp;
|
|
|
|
|
|
|
|
extern symbol _binary_font_bin_start;
|
|
|
|
|
2021-07-11 09:30:54 +03:00
|
|
|
static uint8_t *vga_font_bits = NULL;
|
2021-10-21 03:37:05 +03:00
|
|
|
static size_t vga_font_bool_size = 0;
|
2021-07-11 09:30:54 +03:00
|
|
|
static bool *vga_font_bool = NULL;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-08-01 00:51:48 +03:00
|
|
|
static uint32_t ansi_colours[8];
|
|
|
|
static uint32_t ansi_bright_colours[8];
|
|
|
|
static uint32_t default_fg, default_bg;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
|
|
|
static struct image *background;
|
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
static size_t bg_canvas_size = 0;
|
2021-04-09 00:05:27 +03:00
|
|
|
static uint32_t *bg_canvas = NULL;
|
|
|
|
|
2021-08-16 21:00:37 +03:00
|
|
|
static size_t rows;
|
|
|
|
static size_t cols;
|
2021-10-12 17:38:24 +03:00
|
|
|
static size_t margin;
|
2021-08-16 21:00:37 +03:00
|
|
|
static size_t margin_gradient;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
static size_t grid_size = 0;
|
|
|
|
static size_t queue_size = 0;
|
|
|
|
static size_t map_size = 0;
|
2021-09-26 19:16:55 +03:00
|
|
|
|
|
|
|
struct gterm_char {
|
|
|
|
uint32_t c;
|
|
|
|
uint32_t fg;
|
|
|
|
uint32_t bg;
|
|
|
|
};
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-08-16 21:00:37 +03:00
|
|
|
static struct gterm_char *grid = NULL;
|
2021-09-26 19:16:55 +03:00
|
|
|
|
|
|
|
struct queue_item {
|
|
|
|
size_t x, y;
|
|
|
|
struct gterm_char c;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct queue_item *queue = NULL;
|
|
|
|
static size_t queue_i = 0;
|
|
|
|
|
|
|
|
static struct queue_item **map = NULL;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-08-16 21:00:37 +03:00
|
|
|
static struct context {
|
|
|
|
uint32_t text_fg;
|
|
|
|
#define text_fg context.text_fg
|
|
|
|
uint32_t text_bg;
|
|
|
|
#define text_bg context.text_bg
|
|
|
|
bool cursor_status;
|
|
|
|
#define cursor_status context.cursor_status
|
|
|
|
size_t cursor_x;
|
|
|
|
#define cursor_x context.cursor_x
|
|
|
|
size_t cursor_y;
|
|
|
|
#define cursor_y context.cursor_y
|
2022-01-19 01:46:25 +03:00
|
|
|
bool scroll_enabled;
|
|
|
|
#define scroll_enabled context.scroll_enabled
|
|
|
|
|
|
|
|
uint32_t saved_state_text_fg;
|
|
|
|
#define saved_state_text_fg context.saved_state_text_fg
|
|
|
|
uint32_t saved_state_text_bg;
|
|
|
|
#define saved_state_text_bg context.saved_state_text_bg
|
|
|
|
size_t saved_state_cursor_x;
|
|
|
|
#define saved_state_cursor_x context.saved_state_cursor_x
|
|
|
|
size_t saved_state_cursor_y;
|
|
|
|
#define saved_state_cursor_y context.saved_state_cursor_y
|
2021-08-16 21:00:37 +03:00
|
|
|
} context;
|
2021-08-16 19:02:28 +03:00
|
|
|
|
2021-09-28 00:43:25 +03:00
|
|
|
static size_t old_cursor_x = 0;
|
|
|
|
static size_t old_cursor_y = 0;
|
2021-09-26 19:16:55 +03:00
|
|
|
|
2022-01-19 01:46:25 +03:00
|
|
|
void gterm_save_state(void) {
|
|
|
|
saved_state_text_fg = text_fg;
|
|
|
|
saved_state_text_bg = text_bg;
|
|
|
|
saved_state_cursor_x = cursor_x;
|
|
|
|
saved_state_cursor_y = cursor_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_restore_state(void) {
|
|
|
|
text_fg = saved_state_text_fg;
|
|
|
|
text_bg = saved_state_text_bg;
|
|
|
|
cursor_x = saved_state_cursor_x;
|
|
|
|
cursor_y = saved_state_cursor_y;
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_swap_palette(void) {
|
|
|
|
uint32_t tmp = text_bg;
|
|
|
|
text_bg = text_fg;
|
2022-01-19 01:46:25 +03:00
|
|
|
text_fg = tmp;
|
2021-08-16 19:02:28 +03:00
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-08-26 02:23:27 +03:00
|
|
|
#define A(rgb) (uint8_t)(rgb >> 24)
|
|
|
|
#define R(rgb) (uint8_t)(rgb >> 16)
|
|
|
|
#define G(rgb) (uint8_t)(rgb >> 8)
|
|
|
|
#define B(rgb) (uint8_t)(rgb)
|
|
|
|
#define ARGB(a, r, g, b) (a << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF)
|
2021-03-02 08:05:14 +03:00
|
|
|
|
|
|
|
static inline uint32_t colour_blend(uint32_t fg, uint32_t bg) {
|
|
|
|
unsigned alpha = 255 - A(fg);
|
|
|
|
unsigned inv_alpha = A(fg) + 1;
|
|
|
|
|
|
|
|
uint8_t r = (uint8_t)((alpha * R(fg) + inv_alpha * R(bg)) / 256);
|
|
|
|
uint8_t g = (uint8_t)((alpha * G(fg) + inv_alpha * G(bg)) / 256);
|
|
|
|
uint8_t b = (uint8_t)((alpha * B(fg) + inv_alpha * B(bg)) / 256);
|
|
|
|
|
|
|
|
return ARGB(0, r, g, b);
|
|
|
|
}
|
|
|
|
|
2021-09-26 21:59:38 +03:00
|
|
|
static inline void gterm_plot_px(size_t x, size_t y, uint32_t hex) {
|
2021-08-24 02:08:08 +03:00
|
|
|
if (x >= gterm_width || y >= gterm_height) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-03-02 08:05:14 +03:00
|
|
|
size_t fb_i = x + (gterm_pitch / sizeof(uint32_t)) * y;
|
|
|
|
|
|
|
|
gterm_framebuffer[fb_i] = hex;
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
static uint32_t blend_gradient_from_box(size_t x, size_t y, uint32_t bg_px, uint32_t hex) {
|
|
|
|
size_t distance, x_distance, y_distance;
|
2021-10-12 17:38:24 +03:00
|
|
|
size_t gradient_stop_x = gterm_width - margin;
|
|
|
|
size_t gradient_stop_y = gterm_height - margin;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-12 17:38:24 +03:00
|
|
|
if (x < margin)
|
|
|
|
x_distance = margin - x;
|
2021-03-02 08:05:14 +03:00
|
|
|
else
|
2021-10-12 17:38:24 +03:00
|
|
|
x_distance = x - gradient_stop_x;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-12 17:38:24 +03:00
|
|
|
if (y < margin)
|
|
|
|
y_distance = margin - y;
|
2021-03-02 08:05:14 +03:00
|
|
|
else
|
2021-10-12 17:38:24 +03:00
|
|
|
y_distance = y - gradient_stop_y;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-12 17:38:24 +03:00
|
|
|
if (x >= margin && x < gradient_stop_x) {
|
2021-03-02 08:05:14 +03:00
|
|
|
distance = y_distance;
|
2021-10-12 17:38:24 +03:00
|
|
|
} else if (y >= margin && y < gradient_stop_y) {
|
2021-03-02 08:05:14 +03:00
|
|
|
distance = x_distance;
|
|
|
|
} else {
|
|
|
|
distance = sqrt((uint64_t)x_distance * (uint64_t)x_distance
|
|
|
|
+ (uint64_t)y_distance * (uint64_t)y_distance);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (distance > margin_gradient)
|
|
|
|
return bg_px;
|
|
|
|
|
|
|
|
uint8_t gradient_step = (0xff - A(hex)) / margin_gradient;
|
|
|
|
uint8_t new_alpha = A(hex) + gradient_step * distance;
|
|
|
|
|
|
|
|
return colour_blend((hex & 0xffffff) | (new_alpha << 24), bg_px);
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
typedef size_t fixedp6; // the last 6 bits are the fixed point part
|
|
|
|
static size_t fixedp6_to_int(fixedp6 value) { return value / 64; }
|
|
|
|
static fixedp6 int_to_fixedp6(size_t value) { return value * 64; }
|
2021-07-11 08:28:09 +03:00
|
|
|
|
|
|
|
// Draw rect at coordinates, copying from the image to the fb and canvas, applying fn on every pixel
|
2021-08-16 19:02:28 +03:00
|
|
|
__attribute__((always_inline)) static inline void genloop(size_t xstart, size_t xend, size_t ystart, size_t yend, uint32_t (*blend)(size_t x, size_t y, uint32_t orig)) {
|
2021-07-11 08:28:09 +03:00
|
|
|
uint8_t *img = background->img;
|
2021-08-16 19:02:28 +03:00
|
|
|
const size_t img_width = background->img_width, img_height = background->img_height, img_pitch = background->pitch, colsize = background->bpp / 8;
|
2021-07-11 08:28:09 +03:00
|
|
|
|
|
|
|
switch (background->type) {
|
|
|
|
case IMAGE_TILED:
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t y = ystart; y < yend; y++) {
|
|
|
|
size_t image_y = y % img_height, image_x = xstart % img_width;
|
2021-07-11 08:28:09 +03:00
|
|
|
const size_t off = img_pitch * (img_height - 1 - image_y);
|
2021-08-16 19:02:28 +03:00
|
|
|
size_t canvas_off = gterm_width * y, fb_off = gterm_pitch / 4 * y;
|
|
|
|
for (size_t x = xstart; x < xend; x++) {
|
2021-07-11 08:28:09 +03:00
|
|
|
uint32_t img_pixel = *(uint32_t*)(img + image_x * colsize + off);
|
|
|
|
uint32_t i = blend(x, y, img_pixel);
|
|
|
|
bg_canvas[canvas_off + x] = i; gterm_framebuffer[fb_off + x] = i;
|
|
|
|
if (image_x++ == img_width) image_x = 0; // image_x = x % img_width, but modulo is too expensive
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IMAGE_CENTERED:
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t y = ystart; y < yend; y++) {
|
|
|
|
size_t image_y = y - background->y_displacement;
|
2021-07-11 08:28:09 +03:00
|
|
|
const size_t off = img_pitch * (img_height - 1 - image_y);
|
2021-08-16 19:02:28 +03:00
|
|
|
size_t canvas_off = gterm_width * y, fb_off = gterm_pitch / 4 * y;
|
|
|
|
if (image_y >= background->y_size) { /* external part */
|
|
|
|
for (size_t x = xstart; x < xend; x++) {
|
2021-07-11 08:28:09 +03:00
|
|
|
uint32_t i = blend(x, y, background->back_colour);
|
|
|
|
bg_canvas[canvas_off + x] = i; gterm_framebuffer[fb_off + x] = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else { /* internal part */
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t x = xstart; x < xend; x++) {
|
|
|
|
size_t image_x = (x - background->x_displacement);
|
|
|
|
bool x_external = image_x >= background->x_size;
|
2021-07-11 08:28:09 +03:00
|
|
|
uint32_t img_pixel = *(uint32_t*)(img + image_x * colsize + off);
|
|
|
|
uint32_t i = blend(x, y, x_external ? background->back_colour : img_pixel);
|
|
|
|
bg_canvas[canvas_off + x] = i; gterm_framebuffer[fb_off + x] = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
// For every pixel, ratio = img_width / gterm_width, img_x = x * ratio, x = (xstart + i)
|
|
|
|
// hence x = xstart * ratio + i * ratio
|
|
|
|
// so you can set x = xstart * ratio, and increment by ratio at each iteration
|
|
|
|
case IMAGE_STRETCHED:
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t y = ystart; y < yend; y++) {
|
|
|
|
size_t img_y = (y * img_height) / gterm_height; // calculate Y with full precision
|
|
|
|
size_t off = img_pitch * (img_height - 1 - img_y);
|
|
|
|
size_t canvas_off = gterm_width * y, fb_off = gterm_pitch / 4 * y;
|
2021-07-11 08:28:09 +03:00
|
|
|
|
|
|
|
size_t ratio = int_to_fixedp6(img_width) / gterm_width;
|
|
|
|
fixedp6 img_x = ratio * xstart;
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t x = xstart; x < xend; x++) {
|
2021-07-11 08:28:09 +03:00
|
|
|
uint32_t img_pixel = *(uint32_t*)(img + fixedp6_to_int(img_x) * colsize + off);
|
|
|
|
uint32_t i = blend(x, y, img_pixel);
|
|
|
|
bg_canvas[canvas_off + x] = i; gterm_framebuffer[fb_off + x] = i;
|
|
|
|
img_x += ratio;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-09-26 19:16:55 +03:00
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
static uint32_t blend_external(size_t x, size_t y, uint32_t orig) { (void)x; (void)y; return orig; }
|
|
|
|
static uint32_t blend_internal(size_t x, size_t y, uint32_t orig) { (void)x; (void)y; return colour_blend(default_bg, orig); }
|
|
|
|
static uint32_t blend_margin(size_t x, size_t y, uint32_t orig) { return blend_gradient_from_box(x, y, orig, default_bg); }
|
2021-07-11 08:28:09 +03:00
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
static void loop_external(size_t xstart, size_t xend, size_t ystart, size_t yend) { genloop(xstart, xend, ystart, yend, blend_external); }
|
|
|
|
static void loop_margin(size_t xstart, size_t xend, size_t ystart, size_t yend) { genloop(xstart, xend, ystart, yend, blend_margin); }
|
|
|
|
static void loop_internal(size_t xstart, size_t xend, size_t ystart, size_t yend) { genloop(xstart, xend, ystart, yend, blend_internal); }
|
2021-07-11 08:28:09 +03:00
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
static void gterm_generate_canvas(void) {
|
2021-03-02 08:05:14 +03:00
|
|
|
if (background) {
|
2022-03-07 13:46:25 +03:00
|
|
|
int64_t margin_no_gradient = (int64_t)margin - margin_gradient;
|
|
|
|
|
|
|
|
if (margin_no_gradient < 0) {
|
|
|
|
margin_no_gradient = 0;
|
|
|
|
}
|
|
|
|
|
2021-10-12 17:38:24 +03:00
|
|
|
size_t scan_stop_x = gterm_width - margin_no_gradient;
|
|
|
|
size_t scan_stop_y = gterm_height - margin_no_gradient;
|
|
|
|
|
|
|
|
loop_external(0, gterm_width, 0, margin_no_gradient);
|
|
|
|
loop_external(0, gterm_width, scan_stop_y, gterm_height);
|
|
|
|
loop_external(0, margin_no_gradient, margin_no_gradient, scan_stop_y);
|
|
|
|
loop_external(scan_stop_x, gterm_width, margin_no_gradient, scan_stop_y);
|
2021-07-11 08:28:09 +03:00
|
|
|
|
2021-10-12 17:38:24 +03:00
|
|
|
size_t gradient_stop_x = gterm_width - margin;
|
|
|
|
size_t gradient_stop_y = gterm_height - margin;
|
2021-07-11 08:28:09 +03:00
|
|
|
|
|
|
|
if (margin_gradient) {
|
2021-10-12 17:38:24 +03:00
|
|
|
loop_margin(margin_no_gradient, scan_stop_x, margin_no_gradient, margin);
|
|
|
|
loop_margin(margin_no_gradient, scan_stop_x, gradient_stop_y, scan_stop_y);
|
|
|
|
loop_margin(margin_no_gradient, margin, margin, gradient_stop_y);
|
|
|
|
loop_margin(gradient_stop_x, scan_stop_x, margin, gradient_stop_y);
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
2021-07-11 08:28:09 +03:00
|
|
|
|
2021-10-12 17:38:24 +03:00
|
|
|
loop_internal(margin, gradient_stop_x, margin, gradient_stop_y);
|
2021-03-02 08:05:14 +03:00
|
|
|
} else {
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t y = 0; y < gterm_height; y++) {
|
|
|
|
for (size_t x = 0; x < gterm_width; x++) {
|
2021-08-01 00:51:48 +03:00
|
|
|
bg_canvas[y * gterm_width + x] = default_bg;
|
|
|
|
gterm_plot_px(x, y, default_bg);
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-26 21:59:38 +03:00
|
|
|
static void plot_char(struct gterm_char *c, size_t x, size_t y) {
|
|
|
|
if (x >= cols || y >= rows) {
|
2021-08-24 02:08:08 +03:00
|
|
|
return;
|
|
|
|
}
|
2021-09-26 21:59:38 +03:00
|
|
|
|
2021-10-12 21:52:10 +03:00
|
|
|
x = offset_x + x * glyph_width;
|
|
|
|
y = offset_y + y * glyph_height;
|
2021-09-26 21:59:38 +03:00
|
|
|
|
2021-08-18 15:07:44 +03:00
|
|
|
bool *glyph = &vga_font_bool[c->c * vga_font_height * vga_font_width];
|
2021-08-18 15:49:25 +03:00
|
|
|
// naming: fx,fy for font coordinates, gx,gy for glyph coordinates
|
|
|
|
for (size_t gy = 0; gy < glyph_height; gy++) {
|
|
|
|
uint8_t fy = gy / vga_font_scale_y;
|
2021-10-01 08:08:02 +03:00
|
|
|
volatile uint32_t *fb_line = gterm_framebuffer + x + (y + gy) * (gterm_pitch / 4);
|
2021-08-18 15:49:25 +03:00
|
|
|
uint32_t *canvas_line = bg_canvas + x + (y + gy) * gterm_width;
|
|
|
|
for (size_t fx = 0; fx < vga_font_width; fx++) {
|
|
|
|
bool draw = glyph[fy * vga_font_width + fx];
|
|
|
|
for (size_t i = 0; i < vga_font_scale_x; i++) {
|
|
|
|
size_t gx = vga_font_scale_x * fx + i;
|
|
|
|
uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;
|
2021-09-28 00:43:25 +03:00
|
|
|
uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;
|
|
|
|
fb_line[gx] = draw ? fg : bg;
|
2021-08-18 15:49:25 +03:00
|
|
|
}
|
2021-07-11 05:50:15 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-14 16:36:53 +03:00
|
|
|
static void plot_char_fast(struct gterm_char *old, struct gterm_char *c, size_t x, size_t y) {
|
|
|
|
if (x >= cols || y >= rows) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
x = offset_x + x * glyph_width;
|
|
|
|
y = offset_y + y * glyph_height;
|
|
|
|
|
|
|
|
bool *new_glyph = &vga_font_bool[c->c * vga_font_height * vga_font_width];
|
|
|
|
bool *old_glyph = &vga_font_bool[old->c * vga_font_height * vga_font_width];
|
|
|
|
for (size_t gy = 0; gy < glyph_height; gy++) {
|
|
|
|
uint8_t fy = gy / vga_font_scale_y;
|
|
|
|
volatile uint32_t *fb_line = gterm_framebuffer + x + (y + gy) * (gterm_pitch / 4);
|
|
|
|
uint32_t *canvas_line = bg_canvas + x + (y + gy) * gterm_width;
|
|
|
|
for (size_t fx = 0; fx < vga_font_width; fx++) {
|
|
|
|
bool old_draw = old_glyph[fy * vga_font_width + fx];
|
|
|
|
bool new_draw = new_glyph[fy * vga_font_width + fx];
|
|
|
|
if (old_draw == new_draw)
|
|
|
|
continue;
|
|
|
|
for (size_t i = 0; i < vga_font_scale_x; i++) {
|
|
|
|
size_t gx = vga_font_scale_x * fx + i;
|
|
|
|
uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;
|
|
|
|
uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;
|
|
|
|
fb_line[gx] = new_draw ? fg : bg;
|
2021-08-18 15:49:25 +03:00
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
static inline bool compare_char(struct gterm_char *a, struct gterm_char *b) {
|
|
|
|
return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
|
|
|
|
}
|
|
|
|
|
2021-09-26 21:59:38 +03:00
|
|
|
static void push_to_queue(struct gterm_char *c, size_t x, size_t y) {
|
2021-08-24 02:08:08 +03:00
|
|
|
if (x >= cols || y >= rows) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
size_t i = y * cols + x;
|
2021-07-11 05:50:15 +03:00
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
struct queue_item *q = map[i];
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
if (q == NULL) {
|
|
|
|
if (compare_char(&grid[i], c)) {
|
|
|
|
return;
|
2021-09-14 21:02:09 +03:00
|
|
|
}
|
2021-09-26 19:16:55 +03:00
|
|
|
q = &queue[queue_i++];
|
|
|
|
q->x = x;
|
|
|
|
q->y = y;
|
|
|
|
map[i] = q;
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
q->c = *c;
|
2021-04-09 01:22:20 +03:00
|
|
|
}
|
|
|
|
|
2021-07-08 17:33:24 +03:00
|
|
|
bool gterm_scroll_disable(void) {
|
|
|
|
bool ret = scroll_enabled;
|
|
|
|
scroll_enabled = false;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_scroll_enable(void) {
|
|
|
|
scroll_enabled = true;
|
|
|
|
}
|
|
|
|
|
2022-01-19 01:46:25 +03:00
|
|
|
void gterm_revscroll(void) {
|
|
|
|
for (size_t i = (term_context.scroll_bottom_margin - 1) * cols - 1; ; i--) {
|
|
|
|
struct gterm_char *c;
|
|
|
|
struct queue_item *q = map[i];
|
|
|
|
if (q != NULL) {
|
|
|
|
c = &q->c;
|
|
|
|
} else {
|
|
|
|
c = &grid[i];
|
|
|
|
}
|
|
|
|
push_to_queue(c, (i + cols) % cols, (i + cols) / cols);
|
|
|
|
if (i == term_context.scroll_top_margin * cols) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clear the first line of the screen.
|
|
|
|
struct gterm_char empty;
|
|
|
|
empty.c = ' ';
|
|
|
|
empty.fg = text_fg;
|
|
|
|
empty.bg = text_bg;
|
|
|
|
for (size_t i = term_context.scroll_top_margin * cols;
|
|
|
|
i < (term_context.scroll_top_margin + 1) * cols; i++) {
|
|
|
|
push_to_queue(&empty, i % cols, i / cols);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_scroll(void) {
|
|
|
|
for (size_t i = (term_context.scroll_top_margin + 1) * cols;
|
|
|
|
i < term_context.scroll_bottom_margin * cols; i++) {
|
2021-09-26 19:16:55 +03:00
|
|
|
struct gterm_char *c;
|
|
|
|
struct queue_item *q = map[i];
|
|
|
|
if (q != NULL) {
|
|
|
|
c = &q->c;
|
|
|
|
} else {
|
|
|
|
c = &grid[i];
|
|
|
|
}
|
2021-09-26 21:59:38 +03:00
|
|
|
push_to_queue(c, (i - cols) % cols, (i - cols) / cols);
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Clear the last line of the screen.
|
|
|
|
struct gterm_char empty;
|
|
|
|
empty.c = ' ';
|
2021-08-01 00:51:48 +03:00
|
|
|
empty.fg = text_fg;
|
|
|
|
empty.bg = text_bg;
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t i = (term_context.scroll_bottom_margin - 1) * cols;
|
|
|
|
i < term_context.scroll_bottom_margin * cols; i++) {
|
2021-09-26 21:59:38 +03:00
|
|
|
push_to_queue(&empty, i % cols, i / cols);
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_clear(bool move) {
|
|
|
|
struct gterm_char empty;
|
|
|
|
empty.c = ' ';
|
2021-08-01 00:51:48 +03:00
|
|
|
empty.fg = text_fg;
|
|
|
|
empty.bg = text_bg;
|
2021-08-16 19:02:28 +03:00
|
|
|
for (size_t i = 0; i < rows * cols; i++) {
|
2021-09-26 21:59:38 +03:00
|
|
|
push_to_queue(&empty, i % cols, i / cols);
|
2021-07-11 05:50:15 +03:00
|
|
|
}
|
2021-07-08 17:33:24 +03:00
|
|
|
|
2021-03-02 08:05:14 +03:00
|
|
|
if (move) {
|
|
|
|
cursor_x = 0;
|
|
|
|
cursor_y = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_enable_cursor(void) {
|
|
|
|
cursor_status = true;
|
|
|
|
}
|
|
|
|
|
2021-06-08 01:06:33 +03:00
|
|
|
bool gterm_disable_cursor(void) {
|
|
|
|
bool ret = cursor_status;
|
2021-03-02 08:05:14 +03:00
|
|
|
cursor_status = false;
|
2021-06-08 01:06:33 +03:00
|
|
|
return ret;
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_set_cursor_pos(size_t x, size_t y) {
|
|
|
|
if (x >= cols) {
|
2021-09-11 09:43:39 +03:00
|
|
|
if ((int)x < 0) {
|
|
|
|
x = 0;
|
|
|
|
} else {
|
|
|
|
x = cols - 1;
|
|
|
|
}
|
2021-07-20 15:13:56 +03:00
|
|
|
}
|
2021-08-16 19:02:28 +03:00
|
|
|
if (y >= rows) {
|
2021-09-11 09:43:39 +03:00
|
|
|
if ((int)y < 0) {
|
|
|
|
y = 0;
|
|
|
|
} else {
|
|
|
|
y = rows - 1;
|
|
|
|
}
|
2021-07-20 15:13:56 +03:00
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
cursor_x = x;
|
|
|
|
cursor_y = y;
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_get_cursor_pos(size_t *x, size_t *y) {
|
2021-03-02 08:05:14 +03:00
|
|
|
*x = cursor_x;
|
|
|
|
*y = cursor_y;
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_move_character(size_t new_x, size_t new_y, size_t old_x, size_t old_y) {
|
|
|
|
if (old_x >= cols || old_y >= rows
|
|
|
|
|| new_x >= cols || new_y >= rows) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
size_t i = old_x + old_y * cols;
|
|
|
|
|
|
|
|
struct gterm_char *c;
|
|
|
|
struct queue_item *q = map[i];
|
|
|
|
if (q != NULL) {
|
|
|
|
c = &q->c;
|
|
|
|
} else {
|
|
|
|
c = &grid[i];
|
2021-07-31 21:52:46 +03:00
|
|
|
}
|
2021-09-26 19:16:55 +03:00
|
|
|
|
2021-09-26 21:59:38 +03:00
|
|
|
push_to_queue(c, new_x, new_y);
|
2021-07-31 21:52:46 +03:00
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_set_text_fg(size_t fg) {
|
2021-08-01 00:51:48 +03:00
|
|
|
text_fg = ansi_colours[fg];
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_set_text_bg(size_t bg) {
|
2021-08-01 00:51:48 +03:00
|
|
|
text_bg = ansi_colours[bg];
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_set_text_fg_bright(size_t fg) {
|
2021-08-01 00:51:48 +03:00
|
|
|
text_fg = ansi_bright_colours[fg];
|
|
|
|
}
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
void gterm_set_text_bg_bright(size_t bg) {
|
2021-08-01 00:51:48 +03:00
|
|
|
text_bg = ansi_bright_colours[bg];
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_set_text_fg_default(void) {
|
|
|
|
text_fg = default_fg;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_set_text_bg_default(void) {
|
|
|
|
text_bg = 0xffffffff;
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
2021-09-28 03:05:47 +03:00
|
|
|
static void draw_cursor(void) {
|
|
|
|
size_t i = cursor_x + cursor_y * cols;
|
|
|
|
struct gterm_char c;
|
|
|
|
struct queue_item *q = map[i];
|
|
|
|
if (q != NULL) {
|
|
|
|
c = q->c;
|
|
|
|
} else {
|
|
|
|
c = grid[i];
|
|
|
|
}
|
|
|
|
uint32_t tmp = c.fg;
|
|
|
|
c.fg = c.bg;
|
|
|
|
c.bg = tmp;
|
|
|
|
plot_char(&c, cursor_x, cursor_y);
|
|
|
|
if (q != NULL) {
|
|
|
|
grid[i] = q->c;
|
|
|
|
map[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-02 08:05:14 +03:00
|
|
|
void gterm_double_buffer_flush(void) {
|
2021-09-26 19:16:55 +03:00
|
|
|
if (cursor_status) {
|
2021-09-28 03:05:47 +03:00
|
|
|
draw_cursor();
|
2021-09-26 19:16:55 +03:00
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-14 16:36:53 +03:00
|
|
|
for (size_t i = 0; i < queue_i; i++) {
|
|
|
|
struct queue_item *q = &queue[i];
|
|
|
|
size_t offset = q->y * cols + q->x;
|
|
|
|
if (map[offset] == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
struct gterm_char *old = &grid[offset];
|
|
|
|
if (q->c.bg == old->bg && q->c.fg == old->fg) {
|
|
|
|
plot_char_fast(old, &q->c, q->x, q->y);
|
|
|
|
} else {
|
|
|
|
plot_char(&q->c, q->x, q->y);
|
|
|
|
}
|
|
|
|
grid[offset] = q->c;
|
|
|
|
map[offset] = NULL;
|
2021-09-26 19:16:55 +03:00
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-10-14 16:36:53 +03:00
|
|
|
if ((old_cursor_x != cursor_x || old_cursor_y != cursor_y) || cursor_status == false) {
|
2021-09-26 21:59:38 +03:00
|
|
|
plot_char(&grid[old_cursor_x + old_cursor_y * cols], old_cursor_x, old_cursor_y);
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
2021-06-08 01:06:33 +03:00
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
old_cursor_x = cursor_x;
|
|
|
|
old_cursor_y = cursor_y;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-09-26 19:16:55 +03:00
|
|
|
queue_i = 0;
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_putchar(uint8_t c) {
|
2021-08-16 19:02:28 +03:00
|
|
|
struct gterm_char ch;
|
|
|
|
ch.c = c;
|
|
|
|
ch.fg = text_fg;
|
|
|
|
ch.bg = text_bg;
|
2021-09-26 21:59:38 +03:00
|
|
|
push_to_queue(&ch, cursor_x++, cursor_y);
|
2021-09-28 00:43:25 +03:00
|
|
|
if (cursor_x == cols && (cursor_y < term_context.scroll_bottom_margin - 1 || scroll_enabled)) {
|
2021-08-16 19:02:28 +03:00
|
|
|
cursor_x = 0;
|
|
|
|
cursor_y++;
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
2021-09-28 00:43:25 +03:00
|
|
|
if (cursor_y == term_context.scroll_bottom_margin) {
|
2021-08-16 19:02:28 +03:00
|
|
|
cursor_y--;
|
|
|
|
gterm_scroll();
|
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
|
2022-03-02 20:51:32 +03:00
|
|
|
static bool last_serial = false;
|
|
|
|
|
2021-08-16 19:02:28 +03:00
|
|
|
bool gterm_init(size_t *_rows, size_t *_cols, size_t width, size_t height) {
|
2021-04-11 03:30:48 +03:00
|
|
|
if (current_video_mode >= 0
|
2022-03-07 23:11:17 +03:00
|
|
|
#if bios == 1
|
|
|
|
&& current_video_mode != 0x03
|
|
|
|
#endif
|
2021-04-11 03:30:48 +03:00
|
|
|
&& fbinfo.default_res == true
|
|
|
|
&& width == 0
|
|
|
|
&& height == 0
|
|
|
|
&& fbinfo.framebuffer_bpp == 32
|
2022-03-02 20:51:32 +03:00
|
|
|
&& !early_term
|
|
|
|
&& serial == last_serial) {
|
2021-04-11 03:30:48 +03:00
|
|
|
*_rows = rows;
|
|
|
|
*_cols = cols;
|
|
|
|
gterm_clear(true);
|
|
|
|
return true;
|
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-04-11 03:30:48 +03:00
|
|
|
if (current_video_mode >= 0
|
2022-03-07 23:11:17 +03:00
|
|
|
#if bios == 1
|
|
|
|
&& current_video_mode != 0x03
|
|
|
|
#endif
|
2021-04-11 03:30:48 +03:00
|
|
|
&& fbinfo.framebuffer_width == width
|
|
|
|
&& fbinfo.framebuffer_height == height
|
|
|
|
&& fbinfo.framebuffer_bpp == 32
|
2022-03-02 20:51:32 +03:00
|
|
|
&& !early_term
|
|
|
|
&& serial == last_serial) {
|
2021-04-11 03:30:48 +03:00
|
|
|
*_rows = rows;
|
|
|
|
*_cols = cols;
|
|
|
|
gterm_clear(true);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
early_term = false;
|
2021-03-02 08:05:14 +03:00
|
|
|
|
|
|
|
// We force bpp to 32
|
2021-04-11 03:30:48 +03:00
|
|
|
if (!fb_init(&fbinfo, width, height, 32))
|
|
|
|
return false;
|
|
|
|
|
2022-03-02 20:51:32 +03:00
|
|
|
last_serial = serial;
|
|
|
|
|
2021-08-16 21:00:37 +03:00
|
|
|
cursor_status = true;
|
2022-01-19 01:46:25 +03:00
|
|
|
scroll_enabled = true;
|
2021-08-16 21:00:37 +03:00
|
|
|
|
2021-04-11 03:30:48 +03:00
|
|
|
// default scheme
|
2021-10-12 17:38:24 +03:00
|
|
|
margin = 64;
|
2021-07-07 05:50:32 +03:00
|
|
|
margin_gradient = 4;
|
2021-04-11 03:30:48 +03:00
|
|
|
|
2021-08-01 00:51:48 +03:00
|
|
|
default_bg = 0x00000000; // background (black)
|
|
|
|
default_fg = 0x00aaaaaa; // foreground (grey)
|
|
|
|
|
2021-04-11 03:30:48 +03:00
|
|
|
ansi_colours[0] = 0x00000000; // black
|
|
|
|
ansi_colours[1] = 0x00aa0000; // red
|
|
|
|
ansi_colours[2] = 0x0000aa00; // green
|
|
|
|
ansi_colours[3] = 0x00aa5500; // brown
|
|
|
|
ansi_colours[4] = 0x000000aa; // blue
|
|
|
|
ansi_colours[5] = 0x00aa00aa; // magenta
|
|
|
|
ansi_colours[6] = 0x0000aaaa; // cyan
|
|
|
|
ansi_colours[7] = 0x00aaaaaa; // grey
|
|
|
|
|
|
|
|
char *colours = config_get_value(NULL, 0, "THEME_COLOURS");
|
|
|
|
if (colours == NULL)
|
|
|
|
colours = config_get_value(NULL, 0, "THEME_COLORS");
|
|
|
|
if (colours != NULL) {
|
|
|
|
const char *first = colours;
|
2021-08-16 19:02:28 +03:00
|
|
|
size_t i;
|
2021-04-11 03:30:48 +03:00
|
|
|
for (i = 0; i < 10; i++) {
|
|
|
|
const char *last;
|
|
|
|
uint32_t col = strtoui(first, &last, 16);
|
|
|
|
if (first == last)
|
|
|
|
break;
|
2021-08-01 00:51:48 +03:00
|
|
|
if (i < 8) {
|
2021-09-28 00:43:25 +03:00
|
|
|
ansi_colours[i] = col & 0xffffff;
|
2021-08-01 00:51:48 +03:00
|
|
|
} else if (i == 8) {
|
|
|
|
default_bg = col;
|
|
|
|
} else if (i == 9) {
|
2021-09-28 00:43:25 +03:00
|
|
|
default_fg = col & 0xffffff;
|
2021-08-01 00:51:48 +03:00
|
|
|
}
|
2021-04-11 03:30:48 +03:00
|
|
|
if (*last == 0)
|
|
|
|
break;
|
|
|
|
first = last + 1;
|
|
|
|
}
|
2021-08-01 00:51:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
ansi_bright_colours[0] = 0x00555555; // black
|
|
|
|
ansi_bright_colours[1] = 0x00ff5555; // red
|
|
|
|
ansi_bright_colours[2] = 0x0055ff55; // green
|
|
|
|
ansi_bright_colours[3] = 0x00ffff55; // brown
|
|
|
|
ansi_bright_colours[4] = 0x005555ff; // blue
|
|
|
|
ansi_bright_colours[5] = 0x00ff55ff; // magenta
|
|
|
|
ansi_bright_colours[6] = 0x0055ffff; // cyan
|
|
|
|
ansi_bright_colours[7] = 0x00ffffff; // grey
|
|
|
|
|
|
|
|
char *bright_colours = config_get_value(NULL, 0, "THEME_BRIGHT_COLOURS");
|
|
|
|
if (bright_colours == NULL)
|
|
|
|
bright_colours = config_get_value(NULL, 0, "THEME_BRIGHT_COLORS");
|
|
|
|
if (bright_colours != NULL) {
|
|
|
|
const char *first = bright_colours;
|
2021-08-16 19:02:28 +03:00
|
|
|
size_t i;
|
2021-08-01 00:51:48 +03:00
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
const char *last;
|
|
|
|
uint32_t col = strtoui(first, &last, 16);
|
|
|
|
if (first == last)
|
|
|
|
break;
|
2021-09-28 00:43:25 +03:00
|
|
|
ansi_bright_colours[i] = col & 0xffffff;
|
2021-08-01 00:51:48 +03:00
|
|
|
if (*last == 0)
|
|
|
|
break;
|
|
|
|
first = last + 1;
|
2021-04-11 03:30:48 +03:00
|
|
|
}
|
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
|
2021-04-11 03:30:48 +03:00
|
|
|
char *theme_background = config_get_value(NULL, 0, "THEME_BACKGROUND");
|
|
|
|
if (theme_background != NULL) {
|
2021-08-01 00:51:48 +03:00
|
|
|
default_bg = strtoui(theme_background, NULL, 16);
|
2021-04-11 03:30:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
char *theme_foreground = config_get_value(NULL, 0, "THEME_FOREGROUND");
|
|
|
|
if (theme_foreground != NULL) {
|
2021-09-28 00:43:25 +03:00
|
|
|
default_fg = strtoui(theme_foreground, NULL, 16) & 0xffffff;
|
2021-04-11 03:30:48 +03:00
|
|
|
}
|
|
|
|
|
2021-08-01 00:51:48 +03:00
|
|
|
text_fg = default_fg;
|
|
|
|
text_bg = 0xffffffff;
|
|
|
|
|
2022-03-07 23:11:17 +03:00
|
|
|
background = NULL;
|
|
|
|
char *background_path = config_get_value(NULL, 0, "BACKGROUND_PATH");
|
|
|
|
if (background_path != NULL) {
|
|
|
|
struct file_handle *bg_file;
|
|
|
|
if ((bg_file = uri_open(background_path)) != NULL) {
|
|
|
|
background = image_open(bg_file);
|
|
|
|
fclose(bg_file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (background == NULL) {
|
|
|
|
margin = 0;
|
|
|
|
margin_gradient = 0;
|
|
|
|
}
|
|
|
|
|
2021-04-11 03:30:48 +03:00
|
|
|
char *theme_margin = config_get_value(NULL, 0, "THEME_MARGIN");
|
|
|
|
if (theme_margin != NULL) {
|
|
|
|
margin = strtoui(theme_margin, NULL, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *theme_margin_gradient = config_get_value(NULL, 0, "THEME_MARGIN_GRADIENT");
|
|
|
|
if (theme_margin_gradient != NULL) {
|
|
|
|
margin_gradient = strtoui(theme_margin_gradient, NULL, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (background != NULL) {
|
|
|
|
char *background_layout = config_get_value(NULL, 0, "BACKGROUND_STYLE");
|
|
|
|
if (background_layout != NULL && strcmp(background_layout, "centered") == 0) {
|
|
|
|
char *background_colour = config_get_value(NULL, 0, "BACKDROP_COLOUR");
|
|
|
|
if (background_colour == NULL)
|
|
|
|
background_colour = config_get_value(NULL, 0, "BACKDROP_COLOR");
|
|
|
|
if (background_colour == NULL)
|
|
|
|
background_colour = "0";
|
|
|
|
uint32_t bg_col = strtoui(background_colour, NULL, 16);
|
|
|
|
image_make_centered(background, fbinfo.framebuffer_width, fbinfo.framebuffer_height, bg_col);
|
2021-07-07 03:46:40 +03:00
|
|
|
} else if (background_layout != NULL && strcmp(background_layout, "stretched") == 0) {
|
|
|
|
image_make_stretched(background, fbinfo.framebuffer_width, fbinfo.framebuffer_height);
|
2021-04-11 03:30:48 +03:00
|
|
|
}
|
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
|
|
|
|
// Ensure this is xRGB8888, we only support that for the menu
|
|
|
|
if (fbinfo.red_mask_size != 8
|
|
|
|
|| fbinfo.red_mask_shift != 16
|
|
|
|
|| fbinfo.green_mask_size != 8
|
|
|
|
|| fbinfo.green_mask_shift != 8
|
|
|
|
|| fbinfo.blue_mask_size != 8
|
|
|
|
|| fbinfo.blue_mask_shift != 0)
|
|
|
|
return false;
|
|
|
|
|
2021-03-02 12:23:43 +03:00
|
|
|
gterm_framebuffer = (void *)(uintptr_t)fbinfo.framebuffer_addr;
|
2021-03-02 08:05:14 +03:00
|
|
|
gterm_width = fbinfo.framebuffer_width;
|
|
|
|
gterm_height = fbinfo.framebuffer_height;
|
|
|
|
gterm_bpp = fbinfo.framebuffer_bpp;
|
|
|
|
gterm_pitch = fbinfo.framebuffer_pitch;
|
|
|
|
|
2021-08-20 20:25:42 +03:00
|
|
|
vga_font_width = DEFAULT_FONT_WIDTH, vga_font_height = DEFAULT_FONT_HEIGHT;
|
2021-08-20 23:18:15 +03:00
|
|
|
size_t font_bytes = (vga_font_width * vga_font_height * VGA_FONT_GLYPHS) / 8;
|
2021-08-20 20:25:42 +03:00
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
vga_font_bits = ext_mem_alloc(VGA_FONT_MAX);
|
2021-08-20 23:18:15 +03:00
|
|
|
|
|
|
|
memcpy(vga_font_bits, (void *)_binary_font_bin_start, VGA_FONT_MAX);
|
|
|
|
|
|
|
|
size_t tmp_font_width, tmp_font_height;
|
2021-08-20 20:25:42 +03:00
|
|
|
|
2021-08-18 15:06:55 +03:00
|
|
|
char *menu_font_size = config_get_value(NULL, 0, "MENU_FONT_SIZE");
|
2021-08-20 23:18:15 +03:00
|
|
|
if (menu_font_size == NULL)
|
2021-08-18 22:02:03 +03:00
|
|
|
menu_font_size = config_get_value(NULL, 0, "TERMINAL_FONT_SIZE");
|
|
|
|
if (menu_font_size != NULL) {
|
2021-08-20 23:18:15 +03:00
|
|
|
parse_resolution(&tmp_font_width, &tmp_font_height, NULL, menu_font_size);
|
2021-03-10 07:08:37 +03:00
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
size_t tmp_font_bytes = (tmp_font_width * tmp_font_height * VGA_FONT_GLYPHS) / 8;
|
2021-03-04 12:13:02 +03:00
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
if (tmp_font_bytes > VGA_FONT_MAX) {
|
|
|
|
print("Font would be too large (%u bytes, %u bytes allowed). Not loading.\n", tmp_font_bytes, VGA_FONT_MAX);
|
|
|
|
goto no_load_font;
|
|
|
|
}
|
2021-08-18 15:06:55 +03:00
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
font_bytes = tmp_font_bytes;
|
2021-08-18 15:06:55 +03:00
|
|
|
}
|
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
char *menu_font = config_get_value(NULL, 0, "MENU_FONT");
|
|
|
|
if (menu_font == NULL)
|
|
|
|
menu_font = config_get_value(NULL, 0, "TERMINAL_FONT");
|
2021-03-02 08:05:14 +03:00
|
|
|
if (menu_font != NULL) {
|
2021-10-21 02:27:05 +03:00
|
|
|
struct file_handle *f;
|
|
|
|
if ((f = uri_open(menu_font)) == NULL) {
|
2021-03-02 08:05:14 +03:00
|
|
|
print("menu: Could not open font file.\n");
|
|
|
|
} else {
|
2021-10-21 02:27:05 +03:00
|
|
|
fread(f, vga_font_bits, 0, font_bytes);
|
|
|
|
if (menu_font_size != NULL) {
|
|
|
|
vga_font_width = tmp_font_width;
|
|
|
|
vga_font_height = tmp_font_height;
|
2021-08-20 20:25:42 +03:00
|
|
|
}
|
2021-10-21 02:27:05 +03:00
|
|
|
fclose(f);
|
2021-07-11 09:30:54 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
no_load_font:;
|
2021-08-20 20:25:42 +03:00
|
|
|
size_t font_spacing = 1;
|
|
|
|
char *font_spacing_str = config_get_value(NULL, 0, "MENU_FONT_SPACING");
|
2021-08-20 23:18:15 +03:00
|
|
|
if (font_spacing_str == NULL)
|
2021-08-20 20:25:42 +03:00
|
|
|
font_spacing_str = config_get_value(NULL, 0, "TERMINAL_FONT_SPACING");
|
|
|
|
if (font_spacing_str != NULL) {
|
|
|
|
font_spacing = strtoui(font_spacing_str, NULL, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
vga_font_width += font_spacing;
|
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
vga_font_bool_size = VGA_FONT_GLYPHS * vga_font_height * vga_font_width * sizeof(bool);
|
|
|
|
vga_font_bool = ext_mem_alloc(vga_font_bool_size);
|
2021-08-20 23:18:15 +03:00
|
|
|
|
|
|
|
for (size_t i = 0; i < VGA_FONT_GLYPHS; i++) {
|
|
|
|
uint8_t *glyph = &vga_font_bits[i * vga_font_height];
|
|
|
|
|
|
|
|
for (size_t y = 0; y < vga_font_height; y++) {
|
|
|
|
// NOTE: the characters in VGA fonts are always one byte wide.
|
|
|
|
// 9 dot wide fonts have 8 dots and one empty column, except
|
|
|
|
// characters 0xC0-0xDF replicate column 9.
|
|
|
|
for (size_t x = 0; x < 8; x++) {
|
|
|
|
size_t offset = i * vga_font_height * vga_font_width + y * vga_font_width + x;
|
|
|
|
|
|
|
|
if ((glyph[y] & (0x80 >> x))) {
|
|
|
|
vga_font_bool[offset] = true;
|
|
|
|
} else {
|
|
|
|
vga_font_bool[offset] = false;
|
2021-07-11 09:30:54 +03:00
|
|
|
}
|
2021-08-20 23:18:15 +03:00
|
|
|
}
|
|
|
|
// fill columns above 8 like VGA Line Graphics Mode does
|
|
|
|
for (size_t x = 8; x < vga_font_width; x++) {
|
|
|
|
size_t offset = i * vga_font_height * vga_font_width + y * vga_font_width + x;
|
|
|
|
|
|
|
|
if (i >= 0xC0 && i <= 0xDF) {
|
|
|
|
vga_font_bool[offset] = (glyph[y] & 1);
|
|
|
|
} else {
|
|
|
|
vga_font_bool[offset] = false;
|
2021-08-18 16:03:02 +03:00
|
|
|
}
|
2021-07-11 09:30:54 +03:00
|
|
|
}
|
2021-03-02 08:05:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
vga_font_scale_x = 1;
|
|
|
|
vga_font_scale_y = 1;
|
|
|
|
|
2021-08-18 15:49:25 +03:00
|
|
|
char *menu_font_scale = config_get_value(NULL, 0, "MENU_FONT_SCALE");
|
2021-08-18 22:02:03 +03:00
|
|
|
if (menu_font_scale == NULL) {
|
|
|
|
menu_font_scale = config_get_value(NULL, 0, "TERMINAL_FONT_SCALE");
|
|
|
|
}
|
2021-08-18 15:49:25 +03:00
|
|
|
if (menu_font_scale != NULL) {
|
|
|
|
parse_resolution(&vga_font_scale_x, &vga_font_scale_y, NULL, menu_font_scale);
|
|
|
|
if (vga_font_scale_x > 8 || vga_font_scale_y > 8) {
|
|
|
|
vga_font_scale_x = 1;
|
|
|
|
vga_font_scale_y = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-20 23:18:15 +03:00
|
|
|
glyph_width = vga_font_width * vga_font_scale_x;
|
|
|
|
glyph_height = vga_font_height * vga_font_scale_y;
|
|
|
|
|
2021-08-18 15:49:25 +03:00
|
|
|
*_cols = cols = (gterm_width - margin * 2) / glyph_width;
|
|
|
|
*_rows = rows = (gterm_height - margin * 2) / glyph_height;
|
2021-04-11 02:33:58 +03:00
|
|
|
|
2021-10-14 16:36:53 +03:00
|
|
|
offset_x = margin + ((gterm_width - margin * 2) % glyph_width) / 2;
|
|
|
|
offset_y = margin + ((gterm_height - margin * 2) % glyph_height) / 2;
|
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
grid_size = rows * cols * sizeof(struct gterm_char);
|
|
|
|
grid = ext_mem_alloc(grid_size);
|
2021-04-11 02:33:58 +03:00
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
queue_size = rows * cols * sizeof(struct queue_item);
|
|
|
|
queue = ext_mem_alloc(queue_size);
|
2021-09-26 19:16:55 +03:00
|
|
|
queue_i = 0;
|
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
map_size = rows * cols * sizeof(struct queue_item *);
|
|
|
|
map = ext_mem_alloc(map_size);
|
2021-04-11 02:33:58 +03:00
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
bg_canvas_size = gterm_width * gterm_height * sizeof(uint32_t);
|
|
|
|
bg_canvas = ext_mem_alloc(bg_canvas_size);
|
2021-04-09 00:05:27 +03:00
|
|
|
|
|
|
|
gterm_generate_canvas();
|
2021-03-02 08:05:14 +03:00
|
|
|
gterm_clear(true);
|
2021-09-28 03:05:47 +03:00
|
|
|
gterm_double_buffer_flush();
|
2021-03-02 08:05:14 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2021-08-16 21:00:37 +03:00
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
void gterm_deinit(void) {
|
|
|
|
if (background != NULL) {
|
|
|
|
image_close(background);
|
|
|
|
}
|
|
|
|
pmm_free(vga_font_bits, VGA_FONT_MAX);
|
|
|
|
pmm_free(vga_font_bool, vga_font_bool_size);
|
|
|
|
pmm_free(grid, grid_size);
|
|
|
|
pmm_free(queue, queue_size);
|
|
|
|
pmm_free(map, map_size);
|
|
|
|
pmm_free(bg_canvas, bg_canvas_size);
|
|
|
|
}
|
|
|
|
|
2021-08-16 21:00:37 +03:00
|
|
|
uint64_t gterm_context_size(void) {
|
|
|
|
uint64_t ret = 0;
|
|
|
|
|
|
|
|
ret += sizeof(struct context);
|
2021-10-21 03:37:05 +03:00
|
|
|
ret += grid_size;
|
2021-08-16 21:00:37 +03:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_context_save(uint64_t ptr) {
|
|
|
|
memcpy32to64(ptr, (uint64_t)(uintptr_t)&context, sizeof(struct context));
|
|
|
|
ptr += sizeof(struct context);
|
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
memcpy32to64(ptr, (uint64_t)(uintptr_t)grid, grid_size);
|
2021-08-16 21:00:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_context_restore(uint64_t ptr) {
|
|
|
|
memcpy32to64((uint64_t)(uintptr_t)&context, ptr, sizeof(struct context));
|
|
|
|
ptr += sizeof(struct context);
|
|
|
|
|
2021-10-21 03:37:05 +03:00
|
|
|
memcpy32to64((uint64_t)(uintptr_t)grid, ptr, grid_size);
|
2021-08-16 21:00:37 +03:00
|
|
|
|
2021-08-16 21:56:39 +03:00
|
|
|
for (size_t i = 0; i < (size_t)rows * cols; i++) {
|
|
|
|
size_t x = i % cols;
|
|
|
|
size_t y = i / cols;
|
|
|
|
|
2021-09-26 21:59:38 +03:00
|
|
|
plot_char(&grid[i], x, y);
|
2021-08-16 21:56:39 +03:00
|
|
|
}
|
2021-09-28 03:05:47 +03:00
|
|
|
|
|
|
|
if (cursor_status) {
|
|
|
|
draw_cursor();
|
|
|
|
}
|
2021-08-16 21:56:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void gterm_full_refresh(void) {
|
|
|
|
gterm_generate_canvas();
|
2021-08-16 21:00:37 +03:00
|
|
|
|
|
|
|
for (size_t i = 0; i < (size_t)rows * cols; i++) {
|
|
|
|
size_t x = i % cols;
|
|
|
|
size_t y = i / cols;
|
|
|
|
|
2021-09-26 21:59:38 +03:00
|
|
|
plot_char(&grid[i], x, y);
|
2021-08-16 21:00:37 +03:00
|
|
|
}
|
2021-09-28 03:05:47 +03:00
|
|
|
|
|
|
|
if (cursor_status) {
|
|
|
|
draw_cursor();
|
|
|
|
}
|
2021-08-16 21:00:37 +03:00
|
|
|
}
|