int
main(int argc, char *argv[])
{
struct editor editor;
editor.display = display_create(argc, argv);
if (editor.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
wl_display_add_global_listener(display_get_display(editor.display),
global_handler, &editor);
editor.window = window_create(editor.display);
editor.widget = frame_create(editor.window, &editor);
editor.entry = text_entry_create(&editor, "Entry");
editor.editor = text_entry_create(&editor, "Editor");
window_set_title(editor.window, "Text Editor");
widget_set_redraw_handler(editor.widget, redraw_handler);
widget_set_resize_handler(editor.widget, resize_handler);
widget_set_button_handler(editor.widget, button_handler);
window_schedule_resize(editor.window, 500, 400);
display_run(editor.display);
text_entry_destroy(editor.entry);
text_entry_destroy(editor.editor);
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;
}
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;
}
/**
* \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 *d;
int i;
int view_counter = 0;
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
parse_options(view_options, ARRAY_LENGTH(view_options), &argc, argv);
d = display_create(&argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
for (i = 1; i < argc; i++)
view_create (d, i, argv[i], option_fullscreen, &view_counter);
if (view_counter > 0)
display_run(d);
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;
}
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 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);
return 0;
}
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;
}
/**
* \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;
d = display_create(&argc, &argv, NULL, NULL);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
gears_create(d);
display_run(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 *d;
struct wscreensaver screensaver = { 0 };
init_frand();
if (parse_options(wscreensaver_options,
ARRAY_LENGTH(wscreensaver_options), &argc, argv) > 1) {
printf("Usage: %s [OPTIONS]\n --demo for demo mode\n",
argv[0]);
exit(1);
}
d = display_create(&argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return EXIT_FAILURE;
}
if (!demo_mode) {
/* iterates already known globals immediately */
display_set_user_data(d, &screensaver);
display_set_global_handler(d, global_handler);
if (!screensaver.interface) {
fprintf(stderr,
"Server did not offer screensaver interface,"
" exiting.\n");
return EXIT_FAILURE;
}
}
if (init_wscreensaver(&screensaver, d) < 0) {
fprintf(stderr, "wscreensaver init failed.\n");
return EXIT_FAILURE;
}
display_run(d);
free((void *)progname);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
cairo_surface_t *s;
struct flower flower;
struct display *d;
struct timeval tv;
d = display_create(&argc, &argv, NULL, NULL);
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.width, flower.height);
window_set_title(flower.window, "flower");
window_set_decoration(flower.window, 0);
window_draw(flower.window);
s = window_get_surface(flower.window);
if (s == NULL || cairo_surface_status (s) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "failed to create cairo egl surface\n");
return -1;
}
draw_stuff(s, flower.width, flower.height);
cairo_surface_flush(s);
cairo_surface_destroy(s);
window_flush(flower.window);
window_set_motion_handler(flower.window, motion_handler);
window_set_button_handler(flower.window, button_handler);
window_set_user_data(flower.window, &flower);
display_run(d);
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 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 *d;
int i;
int image_counter = 0;
d = display_create(&argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
for (i = 1; i < argc; i++)
image_create(d, argv[i], &image_counter);
if (image_counter > 0)
display_run(d);
return 0;
}
int
main(int argc, char *argv[])
{
struct editor editor;
memset(&editor, 0, sizeof editor);
editor.display = display_create(argc, argv);
if (editor.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
display_set_user_data(editor.display, &editor);
display_set_global_handler(editor.display, global_handler);
editor.window = window_create(editor.display);
editor.widget = frame_create(editor.window, &editor);
editor.entry = text_entry_create(&editor, "Entry");
editor.editor = text_entry_create(&editor, "Editor");
window_set_title(editor.window, "Text Editor");
window_set_key_handler(editor.window, key_handler);
window_set_user_data(editor.window, &editor);
widget_set_redraw_handler(editor.widget, redraw_handler);
widget_set_resize_handler(editor.widget, resize_handler);
widget_set_button_handler(editor.widget, editor_button_handler);
window_schedule_resize(editor.window, 500, 400);
display_run(editor.display);
text_entry_destroy(editor.entry);
text_entry_destroy(editor.editor);
return 0;
}
int
main(int argc, char *argv[])
{
struct display *d;
int i;
d = display_create(&argc, &argv, option_entries);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
for (i = 1; i < argc; i++) {
struct image *image;
image = image_create (d, i, argv[i]);
}
display_run(d);
return 0;
}
int
main(int argc, char *argv[])
{
struct virtual_keyboard virtual_keyboard;
virtual_keyboard.display = display_create(argc, argv);
if (virtual_keyboard.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
virtual_keyboard.context = NULL;
virtual_keyboard.preedit_string = NULL;
display_set_user_data(virtual_keyboard.display, &virtual_keyboard);
display_set_global_handler(virtual_keyboard.display, global_handler);
display_set_output_configure_handler(virtual_keyboard.display, handle_output_configure);
display_run(virtual_keyboard.display);
return 0;
}
int main(int argc, char *argv[])
{
struct display *d;
struct wscreensaver screensaver = { 0 };
init_frand();
argc = parse_options(wscreensaver_options,
ARRAY_LENGTH(wscreensaver_options), argc, argv);
d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return EXIT_FAILURE;
}
if (!demo_mode) {
/* iterates already known globals immediately */
wl_display_add_global_listener(display_get_display(d),
global_handler, &screensaver);
if (!screensaver.interface) {
fprintf(stderr,
"Server did not offer screensaver interface,"
" exiting.\n");
return EXIT_FAILURE;
}
}
if (init_wscreensaver(&screensaver, d) < 0) {
fprintf(stderr, "wscreensaver init failed.\n");
return EXIT_FAILURE;
}
display_run(d);
free((void *)progname);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
struct virtual_keyboard virtual_keyboard;
struct output *output;
memset(&virtual_keyboard, 0, sizeof virtual_keyboard);
virtual_keyboard.display = display_create(&argc, argv);
if (virtual_keyboard.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
display_set_user_data(virtual_keyboard.display, &virtual_keyboard);
display_set_global_handler(virtual_keyboard.display, global_handler);
output = display_get_output(virtual_keyboard.display);
keyboard_create(output, &virtual_keyboard);
display_run(virtual_keyboard.display);
return 0;
}
int
main(int argc, char *argv[])
{
struct display *d;
int i;
g_type_init();
argc = parse_options(view_options,
ARRAY_LENGTH(view_options), argc, argv);
d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
for (i = 1; i < argc; i++)
view_create (d, i, argv[i], option_fullscreen);
display_run(d);
return 0;
}
int main(int argc, char *argv[])
{
struct transformed transformed;
struct display *d;
int i;
transformed.width = 500;
transformed.height = 250;
transformed.fullscreen = 0;
transformed.fullscreen_method =
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-d") == 0) {
transformed.fullscreen_method =
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER;
} else 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");
window_set_fullscreen_method(transformed.window,
transformed.fullscreen_method);
widget_set_transparent(transformed.widget, 0);
widget_set_default_cursor(transformed.widget, CURSOR_BLANK);
widget_set_resize_handler(transformed.widget, resize_handler);
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);
return 0;
}
void mainloop()
{
GE_Event events[EVENT_BUFFER_SIZE];
int num_evt;
GE_Event* event;
LARGE_INTEGER t0, t1, freq;
int time_to_sleep;
int ptl;
unsigned int running_macros;
QueryPerformanceFrequency(&freq);
while (!done)
{
QueryPerformanceCounter(&t0);
/*
* These two functions generate events.
*/
calibration_test();
running_macros = macro_process();
/*
* Non-generated events are ignored if the --keygen argument is used.
*/
if(!emuclient_params.keygen)
{
GE_PumpEvents();
}
/*
* This part of the loop processes all events.
*/
num_evt = GE_PeepEvents(events, sizeof(events) / sizeof(events[0]));
if (num_evt == EVENT_BUFFER_SIZE)
{
printf("buffer too small!!!\n");
}
for (event = events; event < events + num_evt; ++event)
{
process_event(event);
}
/*
* The --keygen argument is used
* and there are no more event or macro to process => exit.
*/
if(emuclient_params.keygen && !running_macros && !num_evt)
{
done = 1;
continue;//no need to send anything...
}
cfg_process_motion();
cfg_config_activation();
if(connector_send() < 0)
{
done = 1;
}
/*
* There is no setlinebuf(stdout) in windows.
*/
if(emuclient_params.status)
{
fflush(stdout);
}
if(emuclient_params.curses)
{
display_run(get_controller(0)->axis);
}
QueryPerformanceCounter(&t1);
time_to_sleep = emuclient_params.refresh_period - (t1.QuadPart - t0.QuadPart) * 1000000 / freq.QuadPart;
ptl = emuclient_params.refresh_period - time_to_sleep;
proc_time += ptl;
proc_time_total += ptl;
if(ptl > proc_time_worst && proc_time_total > 50000)
{
proc_time_worst = ptl;
}
if (time_to_sleep > 0)
{
usleep(time_to_sleep);
}
else
{
if(!emuclient_params.curses)
{
printf(_("processing time higher than %dus: %dus!!\n"), emuclient_params.refresh_period, emuclient_params.refresh_period - time_to_sleep);
}
}
}
}
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;
}
void
Display::Run()
{
if (m_isOwner)
display_run(m_display);
}
int main(int argc, char *argv[])
{
struct fullscreen fullscreen;
struct display *d;
int i;
fullscreen.width = 640;
fullscreen.height = 480;
fullscreen.fullscreen = 0;
fullscreen.present_method = _WL_FULLSCREEN_SHELL_PRESENT_METHOD_DEFAULT;
wl_list_init(&fullscreen.output_list);
fullscreen.current_output = NULL;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-w") == 0) {
if (++i >= argc)
usage(EXIT_FAILURE);
fullscreen.width = atol(argv[i]);
} else if (strcmp(argv[i], "-h") == 0) {
if (++i >= argc)
usage(EXIT_FAILURE);
fullscreen.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;
}
fullscreen.display = d;
fullscreen.fshell = NULL;
display_set_user_data(fullscreen.display, &fullscreen);
display_set_global_handler(fullscreen.display, global_handler);
display_set_output_configure_handler(fullscreen.display, output_handler);
if (fullscreen.fshell) {
fullscreen.window = window_create_custom(d);
_wl_fullscreen_shell_present_surface(fullscreen.fshell,
window_get_wl_surface(fullscreen.window),
fullscreen.present_method,
NULL);
/* If we get the CURSOR_PLANE capability, we'll change this */
fullscreen.draw_cursor = 1;
} else {
fullscreen.window = window_create(d);
fullscreen.draw_cursor = 0;
}
fullscreen.widget =
window_add_widget(fullscreen.window, &fullscreen);
window_set_title(fullscreen.window, "Fullscreen");
widget_set_transparent(fullscreen.widget, 0);
widget_set_default_cursor(fullscreen.widget, CURSOR_LEFT_PTR);
widget_set_redraw_handler(fullscreen.widget, redraw_handler);
widget_set_button_handler(fullscreen.widget, button_handler);
widget_set_motion_handler(fullscreen.widget, motion_handler);
widget_set_enter_handler(fullscreen.widget, enter_handler);
widget_set_touch_down_handler(fullscreen.widget, touch_handler);
window_set_key_handler(fullscreen.window, key_handler);
window_set_fullscreen_handler(fullscreen.window, fullscreen_handler);
window_set_user_data(fullscreen.window, &fullscreen);
/* Hack to set minimum allocation so we can shrink later */
window_schedule_resize(fullscreen.window,
1, 1);
window_schedule_resize(fullscreen.window,
fullscreen.width, fullscreen.height);
display_run(d);
return 0;
}
int
main(int argc, char *argv[])
{
struct editor editor;
int i;
uint32_t click_to_show = 0;
const char *preferred_language = NULL;
for (i = 1; i < argc; i++) {
if (strcmp("--click-to-show", argv[i]) == 0)
click_to_show = 1;
else if (strcmp("--preferred-language", argv[i]) == 0) {
if (i + 1 < argc) {
preferred_language = argv[i + 1];
i++;
}
}
}
memset(&editor, 0, sizeof editor);
#ifdef HAVE_PANGO
g_type_init();
#endif
editor.display = display_create(&argc, argv);
if (editor.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
display_set_user_data(editor.display, &editor);
display_set_global_handler(editor.display, global_handler);
editor.window = window_create(editor.display);
editor.widget = frame_create(editor.window, &editor);
editor.entry = text_entry_create(&editor, "Entry");
editor.entry->click_to_show = click_to_show;
if (preferred_language)
editor.entry->preferred_language = strdup(preferred_language);
editor.editor = text_entry_create(&editor, "Numeric");
editor.editor->content_purpose = WL_TEXT_INPUT_CONTENT_PURPOSE_NUMBER;
editor.editor->click_to_show = click_to_show;
window_set_title(editor.window, "Text Editor");
window_set_key_handler(editor.window, key_handler);
window_set_user_data(editor.window, &editor);
widget_set_redraw_handler(editor.widget, redraw_handler);
widget_set_resize_handler(editor.widget, resize_handler);
widget_set_button_handler(editor.widget, editor_button_handler);
window_schedule_resize(editor.window, 500, 400);
display_run(editor.display);
text_entry_destroy(editor.entry);
text_entry_destroy(editor.editor);
return 0;
}