static void window_free_pwindow_void(void**state){
OS_t * new_OS = OS_new("Jupiter");
window_t* pwindow1 = OS_window_new(new_OS, "Callisto", "i am test");
assert_int_equal(window_free(window_free(pwindow1)), NULL);
window_t* pwindow2 = OS_window_new(new_OS, "Themisto", "i am test");
assert_int_equal(window_free(pwindow2), NULL);
OS_free(new_OS);
}
static void window_send_letter_window_letter(void**state){
OS_t * new_OS = OS_create("Jupiter");
window_t* pwindow1 = window_createNew(new_OS, "Callisto", "i am test");
window_t* pwindow2 = window_createNew(new_OS, "Themisto", "i am test");
assert_string_equal(window_send_letter(new_OS, pwindow1, pwindow2), "i am test");
window_free(pwindow1);
window_free(pwindow2);
OS_free(new_OS);
}
static void window_get_amount_of_recivedletters_window_amountOfrecivedLetters(void** state){
OS_t * new_OS = OS_new("Jupiter");
window_t* pwindow1 = OS_window_new(new_OS, "Callisto", "i am test");
window_t* pwindow2 = OS_window_new(new_OS, "Themisto", "i am test");
window_send_letter(new_OS, pwindow1, pwindow2);
assert_int_equal(window_get_amount_of_recivedletters(pwindow2), 1);
window_free(pwindow1);
window_free(pwindow2);
OS_free(new_OS);
}
static void window_send_letter_window_letter(void**state){
OS_t * new_OS = OS_new("Jupiter");
OS_t * new_OS2 = OS_new("Saturn");
window_t* pwindow1 = OS_window_new(new_OS, "Callisto", "i am test");
window_t* pwindow2 = OS_window_new(new_OS, "Themisto", "i am test");
window_t* pwindow3 = OS_window_new(new_OS2, "Deniz", "i am lucky one");
assert_string_equal(window_send_letter(new_OS, pwindow1, pwindow2), "Your letter succesfuly sent!");
assert_string_equal(window_send_letter(new_OS2, pwindow1, pwindow3), "You can`t send letters to windows of other operstion system!");
window_free(pwindow1);
window_free(pwindow2);
window_free(pwindow3);
OS_free(new_OS);
OS_free(new_OS2);
}
Win *window_new_file(Vis *vis, File *file) {
Win *win = calloc(1, sizeof(Win));
if (!win)
return NULL;
win->vis = vis;
win->file = file;
win->jumplist = ringbuf_alloc(31);
win->view = view_new(file->text, vis->lua);
win->ui = vis->ui->window_new(vis->ui, win->view, file, UI_OPTION_STATUSBAR);
if (!win->jumplist || !win->view || !win->ui) {
window_free(win);
return NULL;
}
file->refcount++;
view_tabwidth_set(win->view, vis->tabwidth);
if (text_size(file->text) > LARGE_FILE) {
enum UiOption opt = view_options_get(win->view);
opt |= UI_OPTION_LARGE_FILE;
opt &= ~UI_OPTION_LINE_NUMBERS_ABSOLUTE;
view_options_set(win->view, opt);
}
if (vis->windows)
vis->windows->prev = win;
win->next = vis->windows;
vis->windows = win;
vis->win = win;
vis->ui->window_focus(win->ui);
for (size_t i = 0; i < LENGTH(win->modes); i++)
win->modes[i].parent = &vis_modes[i];
if (vis->event && vis->event->win_open)
vis->event->win_open(vis, win);
return win;
}
Win *window_new_file(Vis *vis, File *file) {
Win *win = calloc(1, sizeof(Win));
if (!win)
return NULL;
win->vis = vis;
win->file = file;
win->jumplist = ringbuf_alloc(31);
win->view = view_new(file->text, vis->lua);
win->ui = vis->ui->window_new(vis->ui, win->view, file, UI_OPTION_STATUSBAR);
if (!win->jumplist || !win->view || !win->ui) {
window_free(win);
return NULL;
}
file->refcount++;
view_tabwidth_set(win->view, vis->tabwidth);
if (vis->windows)
vis->windows->prev = win;
win->next = vis->windows;
vis->windows = win;
vis->win = win;
vis->ui->window_focus(win->ui);
for (size_t i = 0; i < LENGTH(win->modes); i++)
win->modes[i].parent = &vis_modes[i];
if (!file->internal && vis->event && vis->event->win_open)
vis->event->win_open(vis, win);
return win;
}
static Win *window_new_file(Editor *ed, File *file) {
Win *win = calloc(1, sizeof(Win));
if (!win)
return NULL;
win->editor = ed;
win->file = file;
win->events = (ViewEvent) {
.data = win,
.selection = window_selection_changed,
};
win->jumplist = ringbuf_alloc(31);
win->view = view_new(file->text, &win->events);
win->ui = ed->ui->window_new(ed->ui, win->view, file->text);
if (!win->jumplist || !win->view || !win->ui) {
window_free(win);
return NULL;
}
view_tabwidth_set(win->view, ed->tabwidth);
if (ed->windows)
ed->windows->prev = win;
win->next = ed->windows;
ed->windows = win;
ed->win = win;
ed->ui->window_focus(win->ui);
return win;
}
void decompress(int in, int out)
{
match_t m;
window_t w;
window_init(&w, BUFSIZE);
while (read(in, &m, sizeof m) == sizeof m) {
if (match_distance(m) == 0) {
int n = match_length(m);
char tab[64];
if (!read_tab(in, tab, n)) {
printf("illegal state\n");
}
window_append_tab(&w, tab, n);
}
else {
window_append_match(&w, m);
}
if (window_should_flush(&w)) {
write(out, w.start, w.block_size);
window_flush(&w);
}
}
if (0 < w.cursor-w.start) write(out, w.start, w.cursor-w.start);
window_free(&w);
}
static void window_getName_window_name(void** state){
OS_t * new_OS = OS_new("Jupiter");
window_t* pwindow = OS_window_new(new_OS, "Callisto", "i am test");
assert_string_equal(window_getName(pwindow), "Callisto");
window_free(pwindow);
OS_free(new_OS);
}
static void window_createNew_name_window(void** state){
OS_t * new_OS = OS_new("Jupiter");
window_t* pwindow = OS_window_new(new_OS, "Callisto", "i am test");
assert_int_equal(window_get_amount_of_recivedletters(pwindow), 0);
window_free(pwindow);
OS_free(new_OS);
}
static void exec_viewtiles(const char* args, context_t* ctx, debug_t* dbg)
{
(void)args;
(void)ctx;
if (!dbg->show_tiles) {
dbg->window = window_create(
"Tiles",
(DBG_TILES_PER_ROW) * (TILE_WIDTH + 1),
CEIL(MAX_TILES, DBG_TILES_PER_ROW) * (TILE_HEIGHT + 1)
);
if (dbg->window == NULL) {
printf("Failed to create window\n");
return;
}
} else {
window_free(dbg->window);
dbg->window = NULL;
}
dbg->show_tiles = !dbg->show_tiles;
printf("Toggling tile view.\n");
}
static void OS_get_window_from_listOFwindow_void_window(void **state){
OS_t * new_OS = OS_create("Jupiter");
window_t * pwindow = window_createNew(new_OS, "TESTwindow", "test");
assert_ptr_equal(OS_get_window_from_listOFwindow(new_OS), pwindow);
window_free(pwindow);
OS_free(new_OS);
}
Win *window_new_file(Vis *vis, File *file, enum UiOption options) {
Win *win = calloc(1, sizeof(Win));
if (!win)
return NULL;
win->vis = vis;
win->file = file;
win->jumplist = ringbuf_alloc(31);
win->event.data = win;
win->event.draw = window_draw;
win->horizon = 1 << 15;
win->view = view_new(file->text, &win->event);
win->ui = vis->ui->window_new(vis->ui, win->view, file, options);
if (!win->jumplist || !win->view || !win->ui) {
window_free(win);
return NULL;
}
file->refcount++;
view_tabwidth_set(win->view, vis->tabwidth);
if (vis->windows)
vis->windows->prev = win;
win->next = vis->windows;
vis->windows = win;
vis->win = win;
vis->ui->window_focus(win->ui);
for (size_t i = 0; i < LENGTH(win->modes); i++)
win->modes[i].parent = &vis_modes[i];
if (!file->internal && vis->event && vis->event->win_open)
vis->event->win_open(vis, win);
return win;
}
static void OS_inc_amountOFworking_window__amountOFworking_window__returns_inc_amountOFworking_window(void **state){
OS_t * new_OS = OS_new("Jupiter");
window_t * pwindow = OS_window_new(new_OS, "TESTwindow", "test");
window_start(new_OS, pwindow);
assert_int_equal(OS_get_amountOFworking_window(new_OS), 1);
window_free(pwindow);
OS_free(new_OS);
}
static void OS_set_new_window_in_listOFwindow_new_window_listOFwindow(void **state){
OS_t * new_OS = OS_create("Jupiter");
window_t * pwindow1 = window_createNew(new_OS, "TESTwindow", "test");
window_t * pwindow2 = OS_get_window_from_listOFwindow(new_OS);
assert_ptr_equal(pwindow1, pwindow2);
window_free(pwindow1);
OS_free(new_OS);
}
static void window_start_window_void(void** state){
OS_t * new_OS = OS_new("Jupiter");
window_t* pwindow = OS_window_new(new_OS, "Callisto", "i am test");
window_start(new_OS, pwindow);
assert_int_equal(OS_get_amountOFworking_window(new_OS), 1);
window_free(pwindow);
OS_free(new_OS);
}
static void window_getStatus_window_status(void** state){
OS_t * new_OS = OS_new("Jupiter");
window_t* pwindow = OS_window_new(new_OS, "Callisto", "i am test");
window_start(new_OS, pwindow);
assert_int_equal(window_getStatus(pwindow), working);
window_end(new_OS, pwindow);
assert_int_equal(window_getStatus(pwindow), non_working);
window_free(pwindow);
OS_free(new_OS);
}
void main(int argc, char *argv[]){
if (strcmp(argv[1],"tests")==0)
{
module_runTests();
}
else if (strcmp(argv[1], "modules") == 0){
OS_t* Linux = OS_new("Linux");//1.0
OS_t* Windows = OS_new("Windows");//2.0
OS_window_new(Linux, "Internet","HELLO");//1.2
puts("listOfWindows(Linux)");
OS_print_listOfWindows(Linux);
OS_deleteWindow(Linux, 2);
puts("listOfWindows(Linux) after deleting window(2)");
OS_print_listOfWindows(Linux);
OS_window_new(Windows, "Camomiles","LOVE");//2.2
OS_window_new(Windows, "Roses","SAD");//2.3
puts("listOfWindows(Windows)");
OS_print_listOfWindows(Windows);
window_start(Windows, 2);
window_start(Windows, 3);
puts("listOFworking_windows(Windows)");
OS_print_listOFworking_windows(Windows);
window_end(Windows,2);
puts("listOFworking_windows(Windows)");
OS_print_listOFworking_windows(Windows);
window_send_letter(Windows, 2, 3);
window_send_letter(Windows, 2, 3);
window_send_letter(Windows, 3, 2);
puts("listOFrecivedLetters(Roses)");
window_print_listOfrecievedLetters(Windows,3);
puts("listOFrecived_windows(Camomailes)");
window_print_listOfrecievedLetters(Windows,2);
window_free(Windows,2);
window_free(Windows,3);
OS_free(Linux);
OS_free(Windows);
getchar();
}
}
void tab_free(tab *t)
{
if(t->win){
window_free(t->win);
t->win = NULL;
}
if(t == tabs_first())
tabs_set_first(t->next);
free(t);
}
/*----------------------------------------------------------------------------*/
static void
purge_windows(list_t windows)
{
window_t *e;
window_t *next;
for(e = list_head(windows); e != NULL;) {
next = e->next;
window_free(e);
e = next;
}
}
void app_free() {
picframe_cleanup();
for (int i = 0; i < NUM_WINDOWS; i++) {
window_free(window[i]);
}
SDL_FreeSurface(leftArrow->surface);
SDL_FreeSurface(leftArrow->surface_selected);
SDL_FreeSurface(rightArrow->surface);
SDL_FreeSurface(rightArrow->surface_selected);
}
/* free all allocated resources */
void cleanup()
{
/* free sticks */
stick_free(g_player);
g_player = NULL;
stick_free(g_opponent);
g_opponent = NULL;
ball_free(g_ball);
g_ball = NULL;
/* destroy window */
window_free(g_window);
g_window = NULL;
/* quit SDL subsystems */
SDLNet_Quit();
SDL_Quit();
}
void editor_window_close(Win *win) {
Editor *ed = win->editor;
file_free(ed, win->file);
if (win->prev)
win->prev->next = win->next;
if (win->next)
win->next->prev = win->prev;
if (ed->windows == win)
ed->windows = win->next;
if (ed->win == win)
ed->win = win->next ? win->next : win->prev;
window_free(win);
if (ed->win)
ed->ui->window_focus(ed->win->ui);
editor_draw(ed);
}
void free_graphic(void) {
window* window_handle = global_get(global_get_singleton(), GLOBAL_WINDOW);
hl_render* hl_render_handle = global_get(global_get_singleton(), GLOBAL_HL_RENDER);
camera* camera_handle = global_get(global_get_singleton(), GLOBAL_CAMERA);
input* input_handle = global_get(global_get_singleton(), GLOBAL_INPUT);
shader* shader_texture_handle = global_get(global_get_singleton(), GLOBAL_SHADER_TEXTURE);
text* text_handle = global_get(global_get_singleton(), GLOBAL_TEXT);
debug_draw* debug_draw_handle = global_get(global_get_singleton(), GLOBAL_DEBUG_DRAW);
window_free(&window_handle);
hl_render_free(&hl_render_handle);
camera_free(&camera_handle);
input_free(&input_handle);
shader_free(&shader_texture_handle);
text_free(&text_handle);
debug_draw_free(&debug_draw_handle);
}
void editor_free(Editor *ed) {
if (!ed)
return;
while (ed->windows)
editor_window_close(ed->windows);
file_free(ed, ed->prompt->file);
window_free(ed->prompt);
text_regex_free(ed->search_pattern);
for (int i = 0; i < REG_LAST; i++)
register_release(&ed->registers[i]);
for (int i = 0; i < MACRO_LAST; i++)
macro_release(&ed->macros[i]);
editor_syntax_unload(ed);
ed->ui->free(ed->ui);
map_free(ed->cmds);
map_free(ed->options);
buffer_release(&ed->buffer_repeat);
free(ed);
}
void compress(int in, int out)
{
match_t m;
window_t w;
char *p;
char *end;
char buf[BUFSIZE];
int length;
char tab[64];
int n = 0;
window_init(&w, BUFSIZE);
while ((length = read(in, buf, BUFSIZE)) > 0) {
p = buf;
end = buf+length;
while (p < end) {
m = window_match(&w, p, end);
if (match_length(m) <= 1) {
if (n >= match_length_max) {
write_tab(out, tab, match_length_max);
n = 0;
}
tab[n++] = *p;
window_append(&w, *p);
p++;
}
else {
if (n) {
write_tab(out, tab, n);
n = 0;
}
write(out, &m, sizeof m);
window_append_match(&w, m);
p += match_length(m);
}
window_flush(&w);
}
}
if (n) write_tab(out, tab, n);
window_free(&w);
}
void vis_window_close(Win *win) {
Vis *vis = win->vis;
if (vis->event && vis->event->win_close)
vis->event->win_close(vis, win);
file_free(vis, win->file);
if (win->prev)
win->prev->next = win->next;
if (win->next)
win->next->prev = win->prev;
if (vis->windows == win)
vis->windows = win->next;
if (vis->win == win)
vis->win = win->next ? win->next : win->prev;
if (win == vis->message_window)
vis->message_window = NULL;
window_free(win);
if (vis->win)
vis->ui->window_focus(vis->win->ui);
vis_draw(vis);
}
int main(int argc, char *argv[]) {
struct game* game = game_new();
window_create(SIZE_BLOC * MAP_WIDTH,
SIZE_BLOC * MAP_HEIGHT + BANNER_HEIGHT + LINE_HEIGHT);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// to obtain the DEFAULT_GAME_FPS, we have to reach a loop duration of (1000 / DEFAULT_GAME_FPS) ms
int ideal_speed = 1000 / DEFAULT_GAME_FPS;
int timer, execution_speed;
// game loop
// fixed time rate implementation
int done = menu_display(game);
while (!done) {
timer = SDL_GetTicks();
done = game_update(game);
game_display(game);
if ( player_get_dead(game_get_player(game))) { // Reset the game if the player is dead
game_free(game);
game=game_new();
}
if(game_get_win(game) == 1)
done=1;
execution_speed = SDL_GetTicks() - timer;
if (execution_speed < ideal_speed)
SDL_Delay(ideal_speed - execution_speed); // we are ahead of ideal time. let's wait.
}
window_free();
game_free(game);
SDL_Quit();
return EXIT_SUCCESS;
}
struct window *window_close(struct window *window) {
assert(window->split_type == WINDOW_LEAF);
struct window *parent = window->parent;
struct window *sibling = window_sibling(window);
bool was_left_child = window == window->parent->split.first;
enum window_split_type old_parent_type = parent->split_type;
struct window *grandparent = parent->parent;
size_t w = parent->w;
size_t h = parent->h;
memcpy(parent, sibling, sizeof(*sibling));
parent->parent = grandparent;
parent->w = w;
parent->h = h;
if (parent->split_type != WINDOW_LEAF) {
parent->split.first->parent = parent;
parent->split.second->parent = parent;
}
if (was_left_child && old_parent_type == parent->split_type) {
if (parent->split_type == WINDOW_SPLIT_HORIZONTAL) {
parent->split.point = window_h(parent) - parent->split.point;
} else if (parent->split_type == WINDOW_SPLIT_VERTICAL) {
parent->split.point = window_w(parent) - parent->split.point;
}
}
window_free(window);
// free, not window_free, because that would free parent's fields.
free(sibling);
return window_first_leaf(parent);
}
int main(void)
{
bool ret = true;
plist *cells = NULL;
window *win = NULL;
/* initialize random number generator */
srand(time(NULL));
/* initialize opengl window */
win = window_init("brownian tree", WINDOW_W, WINDOW_H, 32);
if (win == NULL) {
fprintf(stderr, "FATAL: %s\n", strerror(errno));
ret = false;
goto cleanup;
} else {
win->refresh = update_screen;
}
/* initialize opengl stuff */
glPointSize(POINTSIZE);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glfwSetWindowSizeCallback(win->enable2d);
win->enable2d(WINDOW_W, WINDOW_H);
/* initialize cells list */
cells = plist_init(particle_init());
for (int i = 0; i < FREE_CELLS_NUMBER; i++) {
particle *pt = particle_init();
if (pt == NULL) {
fprintf(stderr, "FATAL: %s\n", strerror(errno));
ret = false;
goto cleanup;
}
pt->x = (GLfloat) randint((WINDOW_W - 1));
pt->y = (GLfloat) randint((WINDOW_H - 1));
if (!plist_push(cells, pt)) {
fprintf(stderr, "FATAL: %s\n", strerror(errno));
ret = false;
goto cleanup;
}
}
/* initialize 2D grid */
for (int y = 0; y < WINDOW_H; y++) {
for (int x = 0; x < WINDOW_W; x++) {
grid[y][x] = CELL_EMPTY;
}
}
/* initialize random freezed cells */
for (int i = 0; i < FREEZED_CELLS_NUMBER; i++) {
int y = randint(WINDOW_H - 1);
int x = (i * (WINDOW_W / FREEZED_CELLS_NUMBER))
+ (FREEZED_CELLS_NUMBER / 2);
grid[y][x] = CELL_FREEZED;
}
/* main loop */
do {
win->clear();
win->refresh(win, &cells);
move_cells(&cells);
} while (
glfwGetKey(GLFW_KEY_ESC) != GLFW_PRESS
&& glfwGetWindowParam(GLFW_OPENED)
);
goto cleanup;
cleanup:
/* free resources */
if (cells != NULL)
plist_free(cells);
if (win != NULL) {
window_quit();
window_free(win);
}
/* exit error */
if (!ret)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
