void test_xserv(Screen* vesa_screen) {
Window* window = create_window(rect_make(point_make(50, 50), size_make(400, 500)));
window->title = "Color test";
add_subwindow(vesa_screen->window, window);
Window* label_win = create_window(rect_make(point_make(350, 100), size_make(500, 200)));
label_win->title = "Text test";
Label* test_label = create_label(rect_make(point_make(0, 0), label_win->content_view->frame.size), "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque pulvinar dui bibendum nunc convallis, bibendum venenatis mauris ornare. Donec et libero lacus. Nulla tristique auctor pulvinar. Aenean enim elit, malesuada nec dignissim eget, varius ac nunc. Vestibulum varius lectus nisi, in dignissim orci volutpat in. Aliquam eget eros lorem. Quisque tempor est a rhoncus consequat. Quisque vestibulum finibus sapien. Etiam enim sem, vehicula ac lorem vitae, mattis mollis mauris. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Vivamus eleifend dui vel nulla suscipit pretium. Suspendisse vel nunc efficitur, lobortis dui convallis, tristique tellus. Ut ut viverra est. Etiam tempor justo risus. Cras laoreet eu sapien et lacinia. Nunc imperdiet blandit purus a semper.");
add_sublabel(label_win->content_view, test_label);
add_subwindow(vesa_screen->window, label_win);
//create evenly spaced subsections
for (int i = 0; i < 34; i++) {
double height = window->content_view->frame.size.height / 32;
View* view = create_view(rect_make(point_make(0, height * i), size_make(window->content_view->frame.size.width, height)));
add_subview(window->content_view, view);
}
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < window->content_view->subviews->size; j++) {
View* subview = array_m_lookup(window->content_view->subviews, j);
set_background_color(subview, color_make(rand() % 256, rand() % 256, rand() % 256));
}
sleep(50);
}
}
int main(int argc, char const **argv)
{
gl_context_t context;
memset(&context, 0, sizeof(context));
bool rc = egl_initialize(&context.egl_context);
if (!rc) {
log_error("Couldn't initialize open gl to get full screen.");
exit(1);
}
if (!gl_context_initialize(&context)) {
log_error("Application specific gl initialization failed.");
exit(1);
}
// Use fake screen bounds when developing in a TV
if (context.screen_bounds.size.width == 1920) {
log_debug("Artificially setting screen size to 240x320");
context.screen_bounds = rect_make(0, 0, 240, 320);
}
Draw(&context);
while(1) sleep(10);
return 0;
}
void collider_init(collider_t *self, vec2 pos, int width, int height, int tag, int collflag)
{
self->bounds = rect_make(pos.x, pos.y, width, height);
self->tag = tag;
self->collidesWith = collflag;
self->colliding = false;
self->enabled = true;
}
void test_text(Screen* screen) {
fill_screen(screen, color_make(2, 0, 0));
Font* font = setup_font();
char* str = "Lorem ipsum dolor sit amet consectetur apipiscing elit Donex purus arcu suscipit ed felis eu blandit blandit quam Donec finibus euismod lobortis Sed massa nunc malesuada ac ante eleifend dictum laoreet massa Aliquam nec dictum turpis pellentesque lacinia ligula Donec et tellus maximum dapibus justo auctor egestas sapien Integer venantis egesta malesdada Maecenas venenatis urna id posuere bibendum eros torto gravida ipsum sed tempor arcy andte ac odio Morbi elementum libero id velit bibendum auctor It sit amet ex eget urna venenatis laoreet Proin posuere urna nec ante tutum lobortis Cras nec elit tristique dolor congue eleifend";
Label* label = create_label(rect_make(point_make(0, 0), size_make(screen->window->size.width, screen->window->size.height)), str);
label->text_color = color_make(12, 0, 0);
//draw_label(screen, label);
}
static View* create_title_view(Window* window) {
if (!window) return NULL;
Rect title_view_frame = rect_make(point_make(0, 0), size_make(window->frame.size.width, WINDOW_TITLE_VIEW_HEIGHT));
View* title_view = create_view(title_view_frame);
title_view->background_color = window->border_color;
Button* close_button = create_button(rect_make(point_zero(), size_make(CHAR_WIDTH * 2, title_view->frame.size.height)), "X");
close_button->mousedown_handler = (event_handler)&close_button_clicked;
add_button(title_view, close_button);
Button* minimize_button = create_button(rect_make(point_make(rect_max_x(close_button->frame), 0), size_make(CHAR_WIDTH * 2, title_view->frame.size.height)), "-");
minimize_button->mousedown_handler = (event_handler)&minimize_button_clicked;
add_button(title_view, minimize_button);
//add title label to title view
int label_length = 20 * CHAR_WIDTH;
Rect label_frame = rect_make(point_make(rect_max_x(minimize_button->frame) + 15, title_view_frame.size.height / 2 - (CHAR_HEIGHT / 2)), size_make(label_length, CHAR_HEIGHT));
Label* title_label = create_label(label_frame, window->title);
title_label->text_color = color_black();
add_sublabel(title_view, title_label);
Bmp* dots = create_bmp(title_view_frame, create_layer(title_view_frame.size));
uint8_t* ref = dots->layer->raw;
for (int y = 0; y < dots->frame.size.height; y++) {
for (int x = 0; x < dots->frame.size.width; x++) {
if (!((x + y) % 2)) {
*ref++ = 50;
*ref++ = 50;
*ref++ = 50;
}
else {
*ref++ = 200;
*ref++ = 160;
*ref++ = 90;
}
}
}
add_bmp(title_view, dots);
return title_view;
}
void draw_view(View* view) {
if (!view) return;
//inform subviews that we're being redrawn
//dirtied = 1;
//fill view with its background color
draw_rect(view->layer, rect_make(point_zero(), view->frame.size), view->background_color, THICKNESS_FILLED);
//draw any bmps this view has
for (int i = 0; i < view->bmps->size; i++) {
Bmp* bmp = (Bmp*)array_m_lookup(view->bmps, i);
if (bmp) {
draw_bmp(view->layer, bmp);
}
}
//draw any labels this view has
for (int i = 0; i < view->labels->size; i++) {
Label* label = (Label*)array_m_lookup(view->labels, i);
draw_label(view->layer, label);
}
//draw buttons
for (int i = 0; i < view->buttons->size; i++) {
Button* button = (Button*)array_m_lookup(view->buttons, i);
if (button) {
draw_button(view->layer, button);
}
}
//draw each subview of this view
for (int i = 0; i < view->subviews->size; i++) {
View* subview = (View*)array_m_lookup(view->subviews, i);
draw_view(subview);
blit_layer(view->layer, subview->layer, rect_make(subview->frame.origin, subview->layer->size), rect_make(point_zero(), subview->layer->size));
}
view->needs_redraw = 0;
}
static View* create_content_view(Window* window, bool root) {
if (!window) return NULL;
int title_height = 20;
if (window->title_view) {
title_height = window->title_view->frame.size.height;
} if (root) title_height = 0;
Rect inner_frame = rect_make(point_make((window->border_width * 2), title_height), size_make(window->frame.size.width - (window->border_width * 4), window->frame.size.height - title_height - (window->border_width * 2)));
View* content_view = create_view(inner_frame);
content_view->background_color = color_make(255, 255, 255);
return content_view;
}
void draw_button(Screen* screen) {
fill_screen(screen, color_make(2, 0, 0));
Coordinate origin = point_make(screen->window->size.width * 0.25, screen->window->size.height * 0.25);
Size sz = size_make(screen->window->size.width * 0.25, screen->window->size.height * 0.25);
Rect r = rect_make(origin, sz);
draw_rect(screen, r, color_make(2, 0, 0), 1);
Coordinate in_origin = point_make(origin.x + 1, origin.y + 1);
Size in_size = size_make(sz.width - 2, sz.height - 2);
Rect in_rect = rect_make(in_origin, in_size);
draw_rect(screen, in_rect, color_make(12, 0, 0), 30);
Coordinate p1 = point_make(origin.x + sz.width * 0.1, origin.y + sz.height * 0.1);
Coordinate p2 = point_make(origin.x + sz.width * 0.1, origin.y + sz.height * 0.9);
Coordinate p3 = point_make(origin.x + sz.width * 0.4, origin.y + sz.height * 0.5);
Triangle tri = triangle_make(p1, p2, p3);
draw_triangle(screen, tri, color_make(15, 0, 0), 1);
Rect label_rect = rect_make(point_make(p3.x + 5, p3.y - (8 / 2)), size_make(in_rect.size.width, in_rect.size.height));
Label* play_label = create_label(label_rect, "Play");
play_label->text_color = color_make(1, 0, 0);
//draw_label(screen, play_label);
}
void test_rects(Screen* screen) {
fill_screen(screen, color_make(2, 0, 0));
Coordinate origin = point_make(0, 0);
Size sz = screen->window->size;
for (int i = 0; i < 20; i++) {
Rect rt = rect_make(origin, sz);
draw_rect(screen, rt, color_make(i, 0, 0), 1);
origin.x += 4;
origin.y += 4;
sz.width -= 8;
sz.height -= 8;
}
}
inline b32
rect_collides(Rect a, Rect b, Rect *out)
{
i32 x0 = maximum(a.min_x, b.min_x);
i32 y0 = maximum(a.min_y, b.min_y);
i32 x1 = minimum(a.max_x, b.max_x);
i32 y1 = minimum(a.max_y, b.max_y);
if ((x0 < x1) && (y0 < y1)) {
if (out) {
Rect r = rect_make(x0, y0, x1, y1);
*out = r;
}
return true;
} else {
if (out) {
Rect r = {0};
*out = r;
}
return false;
}
}
Screen* switch_to_vga() {
kernel_begin_critical();
int width = 320;
int height = 200;
Screen* screen = (Screen*)kmalloc(sizeof(Screen));
screen->window = create_window(rect_make(point_make(0, 0), size_make(width, height)));
screen->depth = VGA_DEPTH;
screen->vmem = kmalloc(width * height * sizeof(uint8_t));
screen->physbase = VRAM_START;
screen->font = setup_font();
regs16_t regs;
regs.ax = 0x0013;
int32(0x10, ®s);
//start refresh loop
setup_vga_screen_refresh(screen, 33);
kernel_end_critical();
return screen;
}
//sets up VESA for mode
Screen* switch_to_vesa() {
kernel_begin_critical();
vesa_info info;
vbe_mode_info mode_info;
regs16_t regs;
//get VESA information
//buffer stores info before being copied into structure
uint32_t buffer = (uint32_t)kmalloc(sizeof(vesa_info)) & 0xFFFFF;
memcpy(buffer, "VBE2", 4);
memset(®s, 0, sizeof(regs));
regs.ax = 0x4F00; //00 gets VESA information
regs.di = buffer & 0xF;
regs.es = (buffer >> 4) & 0xFFFF;
int32(0x10, ®s);
//copy info from buffer into struct
memcpy(&info, buffer, sizeof(vesa_info));
//get VESA mode information
//buffer to store mode info before copying into structure
uint32_t mode_buffer = (uint32_t)kmalloc(sizeof(vbe_mode_info)) & 0xFFFFF;
memset(®s, 0, sizeof(regs));
uint32_t vesa_mode = 0x118; //1024x768x24
regs.ax = 0x4F01; //01 gets VBE mode information
regs.di = mode_buffer & 0xF;
regs.es = (mode_buffer >> 4) & 0xFFFF;
regs.cx = vesa_mode; //mode to get info for
int32(0x10, ®s);
//copy mode info from buffer into struct
memcpy(&mode_info, mode_buffer, sizeof(vbe_mode_info));
regs.ax = 0x4F02; //02 sets graphics mode
//sets up mode with linear frame buffer instead of bank switching
//or 0x4000 turns on linear frame buffer
regs.bx = (vesa_mode | 0x4000);
int32(0x10, ®s);
Screen* screen = (Screen*)kmalloc(sizeof(Screen));
screen->vmem = kmalloc(mode_info.x_res * mode_info.y_res * (mode_info.bpp / 8));
screen->depth = mode_info.bpp;
//linear frame buffer (LFB) address
screen->physbase = (uint8_t*)mode_info.physbase;
screen->font = setup_font();
screen->window = create_window(rect_make(point_make(0, 0), size_make(mode_info.x_res, mode_info.y_res)));
set_frame(screen->window->title_view, rect_make(point_make(0, 0), size_make(0, 0)));
set_frame(screen->window->content_view, screen->window->frame);
set_border_width(screen->window, 0);
desktop_setup(screen);
//start refresh loop
//screen->finished_drawing = 0;
setup_vesa_screen_refresh(screen, 83);
//refresh once now so we don't wait for the first tick
vesa_screen_refresh(screen);
kernel_end_critical();
return screen;
}
static void DrawBeerLabel(gl_context_t* context, image_t* img) {
rect2d_t r = rect_make(0, 0, 0, 0);
r.size = image_size(img);
image_draw(img, context, r);
}
void calculator_xserv(Point origin) {
Size button_size = size_make(60, 60);
int result_view_height = 50;
int button_spacing = 0;
//width is button_size * 4 because 3 rows of # buttons + 1 row of operators
Window* calc_win = create_window(rect_make(origin, size_make(button_size.width * 4, WINDOW_TITLE_VIEW_HEIGHT + result_view_height + button_spacing + (button_size.height * 4))));
calc_win->title = "Calculator";
//number display
View* label_view = create_view(rect_make(point_zero(), size_make(calc_win->frame.size.width, result_view_height)));
result_label = create_label(rect_make(point_make(10, 10), label_view->frame.size), "0");
label_view->background_color = color_white();
add_sublabel(label_view, result_label);
add_subview(calc_win->content_view, label_view);
View* button_view = create_view(rect_make(point_make(0, rect_max_y(label_view->frame)), size_make(calc_win->frame.size.width, calc_win->frame.size.height - label_view->frame.size.height)));
button_view->background_color = color_make(200, 200, 255);
add_subview(calc_win->content_view, button_view);
//number buttons 1-9
for (int col = 0; col < 3; col++) {
for (int row = 2; row >= 0; row--) {
int val = ((3 - col) * 3) + row - 2;
char title[32];
itoa(val, (char*)&title);
Button* b = create_button(rect_make(point_make((row * button_size.width) + button_spacing, (col * button_size.height) + button_spacing), button_size), title);
b->mousedown_handler = (event_handler)&calc_num_click;
add_button(button_view, b);
}
}
//3 * button spacing to account for above buttons
Button* zero = create_button(rect_make(point_make(button_spacing, 3 * button_size.height + button_spacing), size_make(button_size.width * 2, button_size.height)), "0");
zero->mousedown_handler = (event_handler)&calc_num_click;
add_button(button_view, zero);
Button* equals = create_button(rect_make(point_make(rect_max_x(zero->frame), 3 * button_size.height + button_spacing), size_make(button_size.width, button_size.height)), "=");
equals->mousedown_handler = (event_handler)&calc_op_click;
add_button(button_view, equals);
//operator buttons
for (int i = 0; i < 4; i++){
char* title;
switch (i) {
case 0:
title = "/";
break;
case 1:
title = "X";
break;
case 2:
title = "-";
break;
case 3:
default:
title = "+";
break;
}
Button* b = create_button(rect_make(point_make((3 * button_size.width) + button_spacing, button_size.height * i + button_spacing), button_size), title);
b->mousedown_handler = (event_handler)&calc_op_click;
add_button(button_view, b);
}
present_window(calc_win);
}
bool draw_window(Window* window) {
if (window->user_backed) {
return true;
}
//blit_layer(window->layer, window->content_view->layer, rect_make(window->content_view->frame.origin, window->layer->size), rect_make(point_zero(), window->content_view->frame.size));
//return;
//if window is invisible, don't bother drawing
if (!window->layer->alpha) return false;
//if window has a redraw handler, call it
if (window->redraw_handler) {
//draw_rect(window->content_view->layer, rect_make(point_zero(), window->content_view->frame.size), window->content_view->background_color, THICKNESS_FILLED);
event_handler redraw = window->redraw_handler;
redraw(window, NULL);
blit_layer(window->layer, window->content_view->layer, rect_make(window->content_view->frame.origin, window->layer->size), rect_make(point_zero(), window->content_view->frame.size));
window->last_draw_timestamp = time();
return true;
}
//if window doesn't need to be redrawn, no work to do
if (window->layer->alpha == 1.0 && !window->needs_redraw) {
return false;
}
//dirtied = 1;
//paint window
draw_rect(window->layer, rect_make(point_zero(), window->frame.size), window->border_color, window->border_width);
//only draw a title bar if title_view exists
if (window->title_view) {
//update title label of window
Label* title_label = (Label*)array_m_lookup(window->title_view->labels, 0);
title_label->text = window->title;
draw_view(window->title_view);
blit_layer(window->layer, window->title_view->layer, rect_make(point_zero(), window->layer->size), window->title_view->frame);
draw_rect(window->layer, window->title_view->frame, color_gray(), 2);
}
//only draw the content view if content_view exists
if (window->content_view) {
draw_view(window->content_view);
//if there's a redraw callback, call it
if (window->redraw_handler) {
event_handler redraw = window->redraw_handler;
redraw(window, NULL);
}
blit_layer(window->layer, window->content_view->layer, rect_make(window->content_view->frame.origin, window->layer->size), rect_make(point_zero(), window->content_view->frame.size));
//draw dividing border between window border and other content
if (window->border_width) {
//inner border
draw_rect(window->content_view->layer, rect_make(point_zero(), window->content_view->frame.size), color_gray(), window->border_width);
}
}
//draw window border
draw_rect(window->layer, rect_make(point_zero(), window->frame.size), color_black(), 1);
window->needs_redraw = 0;
window->last_draw_timestamp = time();
return true;
}
Rect rect_zero() {
return rect_make(point_zero(), size_zero());
}
extern inline Rect
rect_make_size(i32 x, i32 y, i32 w, i32 h)
{
Rect v = rect_make(x, y, x + w, y + h);
return v;
}
