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);
}
}
static void dungeon_generate_small_test(void)
{
struct dungeon *dungeon = dungeon_alloc();
dungeon_generate_small(dungeon);
struct box box = dungeon_box_for_level(dungeon, 1);
assert(box_equals(box, box_make(point_make(-7, 0, 1), size_make(16, 15, 1))));
struct tile *tile = dungeon_tile_at(dungeon, point_make(0, 0, 1));
assert(tile);
assert(tile_type_stairs_up == tile->type);
tile = dungeon_tile_at(dungeon, point_make(0, 1, 1));
assert(tile);
assert(tile_type_stairs_up == tile->type);
tile = dungeon_tile_at(dungeon, point_make(0, 2, 1));
assert(tile);
assert(tile_type_empty == tile->type);
tile = dungeon_tile_at(dungeon, point_make(-1, -8, 1));
assert(tile);
assert(tile_type_filled == tile->type);
dungeon_free(dungeon);
}
static void
check_area_for_secret_doors(struct generator *generator, struct area *area)
{
int z = area->box.origin.z;
for (int i = 0; i < area->box.size.width; ++i) {
int x = area->box.origin.x + i;
int south_y = area->box.origin.y;
struct point south_point = point_make(x, south_y, z);
check_wall_for_secret_door(generator, south_point, direction_south);
int north_y = south_y + area->box.size.length - 1;
struct point north_point = point_make(x, north_y, z);
check_wall_for_secret_door(generator, north_point, direction_north);
}
for (int j = 0; j < area->box.size.length; ++j) {
int west_x = area->box.origin.x;
int y = area->box.origin.y + j;
struct point west_point = point_make(west_x, y, z);
check_wall_for_secret_door(generator, west_point, direction_west);
int east_x = west_x + area->box.size.width - 1;
struct point east_point = point_make(east_x, y, z);
check_wall_for_secret_door(generator, east_point, direction_east);
}
}
void test_lines(Screen* screen) {
fill_screen(screen, color_make(2, 0, 0));
for (int i = 0; i < 128; i++) {
int p1x = rand() % (screen->window->size.width + 1);
int p1y = rand() % (screen->window->size.height + 1);
int p2x = rand() % (screen->window->size.width + 1);
int p2y = rand() % (screen->window->size.height + 1);
Coordinate p1 = point_make(p1x, p1y);
Coordinate p2 = point_make(p2x, p2y);
Line line = line_make(p1, p2);
draw_line(screen, line, color_make(i, 0, 0), 1);
}
}
int
exits_north(struct generator *generator,
struct box box,
struct exit *exits,
int exits_count)
{
assert(1 == box.size.height);
int count = 0;
struct point end = box_end_point(box);
for (int i = 0; i < box.size.width; ++i) {
struct point point = point_make(box.origin.x + i, end.y, box.origin.z);
struct tile *outside_tile = generator_tile_at(generator, point);
struct tile *inside_tile = generator_tile_at(generator, point_south(point));
if ( tile_is_escavated(outside_tile)
&& tile_is_escavated(inside_tile)
&& tile_has_south_exit(outside_tile))
{
int index = count;
++count;
if (exits && index < exits_count) {
exits[index].direction = direction_north;
exits[index].point = inside_tile->point;
exits[index].type = outside_tile->walls.south;
}
}
}
return count;
}
int
exits_east(struct generator *generator,
struct box box,
struct exit *exits,
int exits_count)
{
assert(1 == box.size.height);
int count = 0;
struct point end = box_end_point(box);
for (int j = 0; j < box.size.length; ++j) {
struct point point = point_make(end.x, box.origin.y + j, box.origin.z);
struct tile *outside_tile = generator_tile_at(generator, point);
struct tile *inside_tile = generator_tile_at(generator, point_west(point));
if ( tile_is_escavated(outside_tile)
&& tile_is_escavated(inside_tile)
&& tile_has_west_exit(outside_tile))
{
int index = count;
++count;
if (exits && index < exits_count) {
exits[index].direction = direction_east;
exits[index].point = inside_tile->point;
exits[index].type = outside_tile->walls.west;
}
}
}
return count;
}
struct point
area_center_point(struct area const *area)
{
int x = area->box.origin.x + ((area->box.size.width - 1) / 2);
int y = area->box.origin.y + ((area->box.size.length - 1) / 2);
int z = area->box.origin.z + ((area->box.size.height - 1) / 2);
return point_make(x, y, z);
}
static void
generator_add_digger_test(void)
{
struct dungeon *dungeon = dungeon_alloc();
struct dungeon_options *dungeon_options = dungeon_options_alloc_default();
struct generator *generator = generator_alloc(dungeon, global_rnd, dungeon_options, NULL, NULL);
assert(0 == generator->diggers_count);
struct digger *digger1 = generator_add_digger(generator,
point_make(1, 1, 1),
direction_north);
assert(1 == generator->diggers_count);
generator_delete_digger(generator, digger1);
assert(0 == generator->diggers_count);
digger1 = generator_add_digger(generator,
point_make(1, 1, 1),
direction_north);
assert(1 == generator->diggers_count);
struct digger *digger2 = generator_add_digger(generator,
point_make(2, 2, 2),
direction_north);
assert(2 == generator->diggers_count);
struct digger *digger3 = generator_add_digger(generator,
point_make(3, 3, 3),
direction_north);
assert(3 == generator->diggers_count);
generator_delete_digger(generator, digger2);
assert(2 == generator->diggers_count);
assert(digger1 == generator->diggers[0]);
assert(digger3 == generator->diggers[1]);
generator_delete_digger(generator, digger1);
assert(1 == generator->diggers_count);
assert(digger3 == generator->diggers[0]);
generator_free(generator);
dungeon_options_free(dungeon_options);
dungeon_free(dungeon);
}
void test_triangles(Screen* screen) {
fill_screen(screen, color_make(2, 0, 0));
Coordinate p1 = point_make(screen->window->size.width / 2, 0);
Coordinate p2 = point_make(0, screen->window->size.height - 10);
Coordinate p3 = point_make(screen->window->size.width, screen->window->size.height - 10);
for (int i = 1; i <= 12; i++) {
Triangle t = triangle_make(p1, p2, p3);
draw_triangle(screen, t, color_make(i, 0, 0), THICKNESS_FILLED);
p1.y += i * 2;
p2.x += i * 1.5;
p2.y -= i / 2;
p3.x -= i * 1.5;
p3.y -= i / 2;
}
}
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 test_circles(Screen* screen) {
fill_screen(screen, color_make(2, 0, 0));
Coordinate center = point_make(screen->window->size.width/2, screen->window->size.height/2);
int radius = screen->window->size.height/2;
for (int i = 0; i < 26; i++) {
Circle c = circle_make(center, radius);
draw_circle(screen, c, color_make(i, 0, 0), 1);
radius -= 4;
}
}
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 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;
}
}
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;
}
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);
}
//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 DrawRightLabel(gl_context_t* context, char const* label) {
point2d_t point = point_make(192, rect_top(context->screen_bounds) - 22);
char font_path[PATH_MAX];
bundle_resource_path(font_path, sizeof(font_path), "fonts/GillSans.ttc");
text_render(context, label, font_path, 20, point, rgba_make(1,1,1,0));
}
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);
}
