void ui_destroy(ui_t *ui) { int i; list_t *lp; note_t *note = NULL; char *command; endwin(); display_destroy(ui->display); for (i = 0; i < 8; i++) { for (lp = ui->patterns[i]; lp; lp = list_next(lp)) { note = (note_t *)list_data(lp); free(note); } list_free(ui->patterns[i]); } for (lp = ui->history; lp; lp = list_next(lp)) { command = (char *)list_data(lp); free(command); } list_free(ui->history); free(ui); }
int main(int argc, char *argv[]) { struct display *display; struct calibrator *calibrator; display = display_create(argc, argv); if (display == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } calibrator = calibrator_create(display); if (!calibrator) return -1; display_run(display); calibrator_destroy(calibrator); display_destroy(display); return 0; }
int main(int argc, char *argv[]) { struct display *display; struct demoapp *app; parse_options(options, ARRAY_LENGTH(options), &argc, argv); if (option_help) { printf(help_text, argv[0]); return 0; } display = display_create(&argc, argv); if (display == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } if (!display_has_subcompositor(display)) { fprintf(stderr, "compositor does not support " "the subcompositor extension\n"); return -1; } app = demoapp_create(display); display_run(display); demoapp_destroy(app); display_destroy(display); return 0; }
int main(int argc, char *argv[]) { struct stacking stacking; memset(&stacking, 0, sizeof stacking); #ifdef HAVE_PANGO g_type_init(); #endif stacking.display = display_create(&argc, argv); if (stacking.display == NULL) { fprintf(stderr, "Failed to create display: %m\n"); return -1; } display_set_user_data(stacking.display, &stacking); stacking.root_window = new_window(&stacking, NULL); display_run(stacking.display); window_destroy(stacking.root_window); display_destroy(stacking.display); return 0; }
/** * \brief Connects to the display, creates the window and hands over * to the main loop. */ int main(int argc, char *argv[]) { struct display *d; struct eventdemo *e; parse_options(eventdemo_options, ARRAY_LENGTH(eventdemo_options), &argc, argv); /* Connect to the display and have the arguments parsed */ d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } /* Create new eventdemo window */ e = eventdemo_create(d); if (e == NULL) { fprintf(stderr, "failed to create eventdemo: %m\n"); return -1; } display_run(d); /* Release resources */ eventdemo_destroy(e); display_destroy(d); return 0; }
int main(int argc, char *argv[]) { struct display *display; struct demoapp *app; parse_options(options, ARRAY_LENGTH(options), &argc, argv); if (option_help) { printf(help_text, argv[0]); return 0; } display = display_create(&argc, argv); if (display == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } app = demoapp_create(display); display_run(display); demoapp_destroy(app); display_destroy(display); return 0; }
int main(int argc, char *argv[]) { struct display *d; struct cliptest *cliptest; if (argc > 1) { if (argc == 2 && !strcmp(argv[1], "-b")) return benchmark(); printf("Usage: %s [OPTIONS]\n -b run benchmark\n", argv[0]); return 1; } d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } cliptest = cliptest_create(d); display_run(d); cliptest_destroy(cliptest); display_destroy(d); return 0; }
void client_destroy(struct client *client) { window_destroy(client->w); display_destroy(client->d); close(client->sock_fd); free(client); }
/** * \brief Connects to the display, creates the window and hands over * to the main loop. */ int main(int argc, char *argv[]) { struct display *d; struct eventdemo *e; if (parse_options(eventdemo_options, ARRAY_LENGTH(eventdemo_options), &argc, argv) > 1) { unsigned k; printf("Usage: %s [OPTIONS]\n\n", argv[0]); for (k = 0; k < ARRAY_LENGTH(eventdemo_options); k++) { const struct weston_option* p = &eventdemo_options[k]; if (p->name) { printf(" --%s", p->name); if (p->type != WESTON_OPTION_BOOLEAN) printf("=VALUE"); putchar('\n'); } if (p->short_name) { printf(" -%c", p->short_name); if (p->type != WESTON_OPTION_BOOLEAN) printf("VALUE"); putchar('\n'); } } return 1; } if (!log_redraw && !log_resize && !log_focus && !log_key && !log_button && !log_axis && !log_motion) log_redraw = log_resize = log_focus = log_key = log_button = log_axis = log_motion = 1; /* Connect to the display and have the arguments parsed */ d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } /* Create new eventdemo window */ e = eventdemo_create(d); if (e == NULL) { fprintf(stderr, "failed to create eventdemo: %m\n"); return -1; } display_run(d); /* Release resources */ eventdemo_destroy(e); display_destroy(d); return 0; }
int main(int argc, char *argv[]) { struct timespec ts; struct smoke smoke; struct display *d; int size; d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } smoke.width = 200; smoke.height = 200; smoke.display = d; smoke.window = window_create(d); smoke.widget = window_add_widget(smoke.window, &smoke); window_set_title(smoke.window, "smoke"); window_set_buffer_type(smoke.window, WINDOW_BUFFER_TYPE_SHM); clock_gettime(CLOCK_MONOTONIC, &ts); srandom(ts.tv_nsec); smoke.current = 0; size = smoke.height * smoke.width; smoke.b[0].d = calloc(size, sizeof(float)); smoke.b[0].u = calloc(size, sizeof(float)); smoke.b[0].v = calloc(size, sizeof(float)); smoke.b[1].d = calloc(size, sizeof(float)); smoke.b[1].u = calloc(size, sizeof(float)); smoke.b[1].v = calloc(size, sizeof(float)); widget_set_motion_handler(smoke.widget, mouse_motion_handler); widget_set_touch_motion_handler(smoke.widget, touch_motion_handler); widget_set_resize_handler(smoke.widget, resize_handler); widget_set_redraw_handler(smoke.widget, redraw_handler); window_set_user_data(smoke.window, &smoke); widget_schedule_resize(smoke.widget, smoke.width, smoke.height); display_run(d); widget_destroy(smoke.widget); window_destroy(smoke.window); display_destroy(d); return 0; }
int main(int argc, char *argv[]) { struct display *d; struct gears *gears; d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } gears = gears_create(d); display_run(d); gears_destroy(gears); display_destroy(d); return 0; }
int main(int argc, char *argv[]) { struct display *display; struct clickdot *clickdot; display = display_create(&argc, argv); if (display == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } clickdot = clickdot_create(display); display_run(display); clickdot_destroy(clickdot); display_destroy(display); return 0; }
int main(int argc, char *argv[]) { struct display *display; struct resizor *resizor; display = display_create(&argc, argv); if (display == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } resizor = resizor_create(display); display_run(display); resizor_destroy(resizor); display_destroy(display); return 0; }
int main(int argc, char *argv[]) { struct flower flower; struct display *d; struct timeval tv; d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } gettimeofday(&tv, NULL); srandom(tv.tv_usec); flower.width = 200; flower.height = 200; flower.display = d; flower.window = window_create(d); flower.widget = window_add_widget(flower.window, &flower); window_set_title(flower.window, "Flower"); widget_set_resize_handler(flower.widget, resize_handler); widget_set_redraw_handler(flower.widget, redraw_handler); widget_set_button_handler(flower.widget, button_handler); widget_set_default_cursor(flower.widget, CURSOR_HAND1); widget_set_touch_down_handler(flower.widget, touch_down_handler); window_schedule_resize(flower.window, flower.width, flower.height); display_run(d); widget_destroy(flower.widget); window_destroy(flower.window); display_destroy(d); return 0; }
int main(int argc, char* argv[]) { int r = 0; char* elf_file = NULL; int gdb_port = 0; for (char** arg = &argv[1]; *arg != NULL; ++arg) { if (strcmp("-d", *arg) == 0) gdb_port = atoi(*(++arg)); else elf_file = *arg; } if (elf_file == NULL) { fprintf(stderr, "Give me a .elf file to load\n"); return 1; } elf_firmware_t f; elf_read_firmware(elf_file, &f); avr_t* avr = avr_make_mcu_by_name("atmega328p"); if (!avr) { fprintf(stderr, "Unsupported cpu atmega328p\n"); return 1; } avr_init(avr); if (gdb_port != 0) { avr->gdb_port = gdb_port; avr_gdb_init(avr); } avr->frequency = 16000000; avr_load_firmware(avr, &f); pcd8544_init(avr, &lcd); avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 2), lcd.irq + IRQ_PCD8544_DC); avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 1), lcd.irq + IRQ_PCD8544_CS); avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ('C'), 0), lcd.irq + IRQ_PCD8544_RST); avr_connect_irq(avr_io_getirq(avr, AVR_IOCTL_SPI_GETIRQ(0), SPI_IRQ_OUTPUT), lcd.irq + IRQ_PCD8544_SPI_IN); gb_keypad_init(avr, &keypad); for (int i = 0; i < keydefs_length; i++) { const keydef_t *k = keydefs + i; avr_connect_irq(keypad.irq + k->keypad_key, avr_io_getirq(avr, AVR_IOCTL_IOPORT_GETIRQ(k->port), k->pin)); // Start with the pin high avr_ioport_t* port = (avr_ioport_t*) avr->io[k->avr_port].w.param; key_io[i].pin_mask = (1<<k->pin); key_io[i].pull_value = &port->external.pull_value; port->external.pull_mask |= key_io[i].pin_mask; port->external.pull_value |= key_io[i].pin_mask; gb_keypad_press(&keypad, k->keypad_key, 1); } if (display_init()) { lcd_ram_mutex = SDL_CreateMutex(); SDL_Thread* avr_thread = SDL_CreateThread(avr_run_thread, "avr-thread", avr); main_loop(); SDL_LockMutex(lcd_ram_mutex); quit_flag = 1; SDL_UnlockMutex(lcd_ram_mutex); int avr_thread_return; SDL_WaitThread(avr_thread, &avr_thread_return); SDL_DestroyMutex(lcd_ram_mutex); } else { r = 1; fprintf(stderr, "%s\n", display_error_message()); } display_destroy(); return r; }
Display::~Display() { if (m_isOwner) display_destroy(m_display); }
int main(int ac, char** av) { t_vm* vm = vm_initialize(); t_process* process = (t_process*) malloc(sizeof(t_process)); int32 i; t_display* display; int32 update_display = 0; int32 was_pressed = 0; t_ring_buffer* ring_buffer; ring_buffer = ring_buffer_initialize(10, free); if (load_cores(vm, ac, av) <= 0) return -1; display = display_initialize(800, 600); vm_set_print_callback(vm, main_debug_print, ring_buffer); if (1) { while (vm->process_count && !display_should_exit(display)) { vm->cycle_current++; update_display = 1; int process_count = vm->process_count; for (i = 0; i < process_count; ++i) { t_process* process = vm->processes[i]; if (process->cycle_wait <= 0) { update_display = 0; vm_reset_process_io_op(process); if (process->current_opcode) vm_execute(vm, process); vm_get_opcode(vm, process); } else process->cycle_wait--; } if (vm->cycle_current > vm->cycle_to_die) { vm->cycle_current = 0; vm_kill_process_if_no_live(vm); } vm_clean_dead_process(vm); // update_display = 0; if (display_update_input(display) || update_display == 0) { display_print_ring_buffer(display, 0, 0, ring_buffer); display_step(vm, display); } } } else { int32 execute_one = 0; int32 current_keys_state[GLFW_KEY_LAST]; int32 previous_keys_state[GLFW_KEY_LAST]; memset(previous_keys_state, 0, GLFW_KEY_LAST * sizeof(int32)); memset(current_keys_state, 0, GLFW_KEY_LAST * sizeof(int32)); display_step(vm, display); while (vm->process_count && !display_should_exit(display)) { int32 executed = 0; int32 print_processes; int32 process_count = 0; current_keys_state[GLFW_KEY_S] = display_key_pressed(display, GLFW_KEY_S); current_keys_state[GLFW_KEY_P] = display_key_pressed(display, GLFW_KEY_P); if (!execute_one) execute_one = previous_keys_state[GLFW_KEY_S] && !current_keys_state[GLFW_KEY_S]; print_processes = previous_keys_state[GLFW_KEY_P] && !current_keys_state[GLFW_KEY_P]; memcpy(previous_keys_state, current_keys_state, sizeof(int32) * GLFW_KEY_LAST); if (execute_one) vm->cycle_current++; for (i = 0; i < vm->process_count; ++i) { t_process* process = vm->processes[i]; if (print_processes) vm_debug_print_process(vm, process); if (execute_one) { if (process->cycle_wait <= 0) { vm_reset_process_io_op(process); vm_execute(vm, process); vm_get_opcode(vm, process); executed++; if (vm->live_count >= NBR_LIVE) { vm->live_count = 0; vm->cycle_to_die -= vm->cycle_delta; } } process->cycle_wait--; } } if (executed) execute_one = 0; if (vm->cycle_current > vm->cycle_to_die) { vm->cycle_current = 0; vm_kill_process_if_no_live(vm); } vm_clean_dead_process(vm); executed += display_update_input(display); if (executed) display_step(vm, display); else glfwPollEvents(); } } ring_buffer_destroy(ring_buffer); display_destroy(display); vm_destroy(vm); }
int main(int argc, char *argv[]) { struct transformed transformed; struct display *d; int i; transformed.width = 500; transformed.height = 250; transformed.fullscreen = 0; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-w") == 0) { if (++i >= argc) usage(EXIT_FAILURE); transformed.width = atol(argv[i]); } else if (strcmp(argv[i], "-h") == 0) { if (++i >= argc) usage(EXIT_FAILURE); transformed.height = atol(argv[i]); } else if (strcmp(argv[i], "--help") == 0) usage(EXIT_SUCCESS); else usage(EXIT_FAILURE); } d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } transformed.display = d; transformed.window = window_create(d); transformed.widget = window_add_widget(transformed.window, &transformed); window_set_title(transformed.window, "Transformed"); widget_set_transparent(transformed.widget, 0); widget_set_default_cursor(transformed.widget, CURSOR_BLANK); widget_set_redraw_handler(transformed.widget, redraw_handler); widget_set_button_handler(transformed.widget, button_handler); widget_set_touch_down_handler(transformed.widget, touch_handler); window_set_key_handler(transformed.window, key_handler); window_set_fullscreen_handler(transformed.window, fullscreen_handler); window_set_output_handler(transformed.window, output_handler); window_set_user_data(transformed.window, &transformed); window_schedule_resize(transformed.window, transformed.width, transformed.height); display_run(d); widget_destroy(transformed.widget); window_destroy(transformed.window); display_destroy(d); return 0; }
int main(int argc, char *argv[]) { struct box box; struct display *d; struct timeval tv; int i; d = display_create(&argc, argv); if (d == NULL) { fprintf(stderr, "failed to create display: %m\n"); return -1; } box.mode = MODE_SRC_DST; for (i = 1; i < argc; i++) { if (strcmp("-s", argv[i]) == 0) box.mode = MODE_SRC_ONLY; else if (strcmp("-d", argv[i]) == 0) box.mode = MODE_DST_ONLY; else if (strcmp("-b", argv[i]) == 0) box.mode = MODE_SRC_DST; else if (strcmp("-n", argv[i]) == 0) box.mode = MODE_NO_VIEWPORT; else { usage(argv[0]); exit(1); } } gettimeofday(&tv, NULL); srandom(tv.tv_usec); box.width = BUFFER_WIDTH / BUFFER_SCALE; box.height = BUFFER_HEIGHT / BUFFER_SCALE; box.display = d; box.window = window_create(d); box.widget = window_add_widget(box.window, &box); window_set_title(box.window, "Scaler Test Box"); window_set_buffer_scale(box.window, BUFFER_SCALE); widget_set_resize_handler(box.widget, resize_handler); widget_set_redraw_handler(box.widget, redraw_handler); widget_set_button_handler(box.widget, button_handler); widget_set_default_cursor(box.widget, CURSOR_HAND1); widget_set_touch_down_handler(box.widget, touch_down_handler); window_schedule_resize(box.window, box.width, box.height); display_set_user_data(box.display, &box); display_set_global_handler(box.display, global_handler); display_run(d); widget_destroy(box.widget); window_destroy(box.window); display_destroy(d); return 0; }