static struct resizor *
resizor_create(struct display *display)
{
struct resizor *resizor;
int32_t height;
resizor = malloc(sizeof *resizor);
if (resizor == NULL)
return resizor;
memset(resizor, 0, sizeof *resizor);
resizor->window = window_create(display, "Wayland Resizor", 500, 400);
resizor->display = display;
window_set_key_handler(resizor->window, key_handler);
window_set_user_data(resizor->window, resizor);
window_set_redraw_handler(resizor->window, redraw_handler);
window_set_keyboard_focus_handler(resizor->window,
keyboard_focus_handler);
resizor->width = 300;
resizor->height.current = 400;
resizor->height.previous = resizor->height.current;
resizor->height.target = resizor->height.current;
height = resizor->height.current + 0.5;
window_set_child_size(resizor->window, resizor->width, height);
resizor_draw(resizor);
return resizor;
}
static struct cliptest *
cliptest_create(struct display *display)
{
struct cliptest *cliptest;
cliptest = xzalloc(sizeof *cliptest);
cliptest->view.geometry = &cliptest->geometry;
cliptest->view.transform.enabled = 0;
geometry_init(&cliptest->geometry);
geometry_init(&cliptest->ui.geometry);
cliptest->window = window_create(display);
cliptest->widget = window_frame_create(cliptest->window, cliptest);
window_set_title(cliptest->window, "cliptest");
cliptest->display = display;
window_set_user_data(cliptest->window, cliptest);
widget_set_redraw_handler(cliptest->widget, redraw_handler);
widget_set_button_handler(cliptest->widget, button_handler);
widget_set_motion_handler(cliptest->widget, motion_handler);
widget_set_axis_handler(cliptest->widget, axis_handler);
window_set_keyboard_focus_handler(cliptest->window,
keyboard_focus_handler);
window_set_key_handler(cliptest->window, key_handler);
window_set_fullscreen_handler(cliptest->window, fullscreen_handler);
/* set minimum size */
widget_schedule_resize(cliptest->widget, 200, 100);
/* set current size */
widget_schedule_resize(cliptest->widget, 500, 400);
return cliptest;
}
static struct clickdot *
clickdot_create(struct display *display)
{
struct clickdot *clickdot;
clickdot = xzalloc(sizeof *clickdot);
clickdot->window = window_create(display);
clickdot->widget = frame_create(clickdot->window, clickdot);
window_set_title(clickdot->window, "Wayland ClickDot");
clickdot->display = display;
clickdot->buffer = NULL;
window_set_key_handler(clickdot->window, key_handler);
window_set_user_data(clickdot->window, clickdot);
window_set_keyboard_focus_handler(clickdot->window,
keyboard_focus_handler);
widget_set_redraw_handler(clickdot->widget, redraw_handler);
widget_set_button_handler(clickdot->widget, button_handler);
widget_set_motion_handler(clickdot->widget, motion_handler);
widget_set_resize_handler(clickdot->widget, resize_handler);
widget_set_leave_handler(clickdot->widget, leave_handler);
widget_schedule_resize(clickdot->widget, 500, 400);
clickdot->dot.x = 250;
clickdot->dot.y = 200;
clickdot->line.x = -1;
clickdot->line.y = -1;
clickdot->line.old_x = -1;
clickdot->line.old_y = -1;
clickdot->reset = 0;
return clickdot;
}
static struct resizor *
resizor_create(struct display *display)
{
struct resizor *resizor;
resizor = malloc(sizeof *resizor);
if (resizor == NULL)
return resizor;
memset(resizor, 0, sizeof *resizor);
resizor->window = window_create(display);
resizor->widget = frame_create(resizor->window, resizor);
window_set_title(resizor->window, "Wayland Resizor");
resizor->display = display;
window_set_key_handler(resizor->window, key_handler);
window_set_user_data(resizor->window, resizor);
widget_set_redraw_handler(resizor->widget, redraw_handler);
window_set_keyboard_focus_handler(resizor->window,
keyboard_focus_handler);
widget_set_button_handler(resizor->widget, button_handler);
resizor->height.previous = 400;
resizor->height.current = 400;
resizor->height.target = 400;
resizor->width.previous = 400;
resizor->width.current = 400;
resizor->width.target = 400;
widget_schedule_resize(resizor->widget, 400, 400);
return resizor;
}
static struct view *
view_create(struct display *display,
uint32_t key, const char *filename, int fullscreen, int *view_counter)
{
struct view *view;
gchar *basename;
gchar *title;
GFile *file = NULL;
GError *error = NULL;
view = malloc(sizeof *view);
if (view == NULL)
return view;
memset(view, 0, sizeof *view);
file = g_file_new_for_commandline_arg(filename);
basename = g_file_get_basename(file);
if(!basename) {
title = g_strdup("Wayland View");
} else {
title = g_strdup_printf("Wayland View - %s", basename);
g_free(basename);
}
view->document = poppler_document_new_from_file(g_file_get_uri(file),
NULL, &error);
if(error) {
title = g_strdup("File not found");
}
view->window = window_create(display);
view->widget = frame_create(view->window, view);
window_set_title(view->window, title);
g_free(title);
view->display = display;
window_set_user_data(view->window, view);
window_set_key_handler(view->window, key_handler);
window_set_keyboard_focus_handler(view->window,
keyboard_focus_handler);
window_set_fullscreen_handler(view->window, fullscreen_handler);
window_set_close_handler(view->window, close_handler);
widget_set_button_handler(view->widget, button_handler);
widget_set_resize_handler(view->widget, resize_handler);
widget_set_redraw_handler(view->widget, redraw_handler);
view->page = 0;
view->fullscreen = fullscreen;
window_set_fullscreen(view->window, view->fullscreen);
window_schedule_resize(view->window, 500, 400);
view->view_counter = view_counter;
*view_counter += 1;
return view;
}
static struct image *
image_create(struct display *display, const char *filename,
int *image_counter)
{
struct image *image;
char *b, *copy, title[512];;
image = malloc(sizeof *image);
if (image == NULL)
return image;
memset(image, 0, sizeof *image);
copy = strdup(filename);
b = basename(copy);
snprintf(title, sizeof title, "Wayland Image - %s", b);
free(copy);
image->filename = strdup(filename);
image->image = load_cairo_surface(filename);
if (!image->image) {
fprintf(stderr, "could not find the image %s!\n", b);
free(image);
return NULL;
}
image->window = window_create(display);
image->widget = frame_create(image->window, image);
window_set_title(image->window, title);
image->display = display;
image->image_counter = image_counter;
*image_counter += 1;
image->initialized = false;
window_set_user_data(image->window, image);
widget_set_redraw_handler(image->widget, redraw_handler);
widget_set_resize_handler(image->widget, resize_handler);
window_set_keyboard_focus_handler(image->window,
keyboard_focus_handler);
window_set_fullscreen_handler(image->window, fullscreen_handler);
window_set_close_handler(image->window, close_handler);
widget_set_enter_handler(image->widget, enter_handler);
widget_set_motion_handler(image->widget, motion_handler);
widget_set_button_handler(image->widget, button_handler);
widget_set_axis_handler(image->widget, axis_handler);
window_set_key_handler(image->window, key_handler);
widget_schedule_resize(image->widget, 500, 400);
return image;
}
static struct demoapp *
demoapp_create(struct display *display)
{
struct demoapp *app;
app = calloc(1, sizeof *app);
if (!app)
return NULL;
app->egl = egl_state_create(display_get_display(display));
app->display = display;
display_set_user_data(app->display, app);
app->window = window_create(app->display);
app->widget = frame_create(app->window, app);
window_set_title(app->window, "Wayland Sub-surface Demo");
window_set_key_handler(app->window, key_handler);
window_set_user_data(app->window, app);
window_set_keyboard_focus_handler(app->window, keyboard_focus_handler);
widget_set_redraw_handler(app->widget, redraw_handler);
widget_set_resize_handler(app->widget, resize_handler);
app->subsurface = window_add_subsurface(app->window, app,
int_to_mode(option_red_mode));
widget_set_redraw_handler(app->subsurface, sub_redraw_handler);
widget_set_resize_handler(app->subsurface, sub_resize_handler);
if (app->egl && !option_no_triangle)
app->triangle = triangle_create(app->window, app->egl);
/* minimum size */
widget_schedule_resize(app->widget, 100, 100);
/* initial size */
widget_schedule_resize(app->widget, 400, 300);
app->animate = 1;
return app;
}
static struct clickdot *
clickdot_create(struct display *display)
{
struct clickdot *clickdot;
clickdot = xzalloc(sizeof *clickdot);
clickdot->window = window_create(display);
clickdot->widget = window_frame_create(clickdot->window, clickdot);
window_set_title(clickdot->window, "Wayland ClickDot");
clickdot->display = display;
clickdot->buffer = NULL;
window_set_key_handler(clickdot->window, key_handler);
window_set_user_data(clickdot->window, clickdot);
window_set_keyboard_focus_handler(clickdot->window,
keyboard_focus_handler);
widget_set_redraw_handler(clickdot->widget, redraw_handler);
widget_set_button_handler(clickdot->widget, button_handler);
widget_set_motion_handler(clickdot->widget, motion_handler);
widget_set_resize_handler(clickdot->widget, resize_handler);
widget_set_leave_handler(clickdot->widget, leave_handler);
widget_schedule_resize(clickdot->widget, 500, 400);
clickdot->dot.x = 250;
clickdot->dot.y = 200;
clickdot->line.x = -1;
clickdot->line.y = -1;
clickdot->line.old_x = -1;
clickdot->line.old_y = -1;
clickdot->reset = 0;
clickdot->cursor_timeout_fd =
timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
clickdot->cursor_timeout_task.run = cursor_timeout_func;
display_watch_fd(window_get_display(clickdot->window),
clickdot->cursor_timeout_fd,
EPOLLIN, &clickdot->cursor_timeout_task);
return clickdot;
}
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;
}
/* Iff parent_window is set, the new window will be transient. */
static struct window *
new_window(struct stacking *stacking, struct window *parent_window)
{
struct window *new_window;
struct widget *new_widget;
new_window = window_create(stacking->display);
window_set_parent(new_window, parent_window);
new_widget = window_frame_create(new_window, new_window);
window_set_title(new_window, "Stacking Test");
window_set_key_handler(new_window, key_handler);
window_set_keyboard_focus_handler(new_window, keyboard_focus_handler);
window_set_fullscreen_handler(new_window, fullscreen_handler);
widget_set_button_handler(new_widget, button_handler);
widget_set_redraw_handler(new_widget, redraw_handler);
window_set_user_data(new_window, stacking);
window_schedule_resize(new_window, 300, 300);
return new_window;
}
static struct resizor *
resizor_create(struct display *display)
{
struct resizor *resizor;
resizor = xzalloc(sizeof *resizor);
resizor->window = window_create(display);
resizor->widget = window_frame_create(resizor->window, resizor);
window_set_title(resizor->window, "Wayland Resizor");
resizor->display = display;
window_set_key_handler(resizor->window, key_handler);
window_set_user_data(resizor->window, resizor);
widget_set_redraw_handler(resizor->widget, redraw_handler);
window_set_keyboard_focus_handler(resizor->window,
keyboard_focus_handler);
widget_set_enter_handler(resizor->widget, enter_handler);
widget_set_motion_handler(resizor->widget, motion_handler);
window_set_locked_pointer_motion_handler(
resizor->window, locked_pointer_handle_motion);
widget_set_button_handler(resizor->widget, button_handler);
resizor->height.previous = 400;
resizor->height.current = 400;
resizor->height.target = 400;
resizor->width.previous = 400;
resizor->width.current = 400;
resizor->width.target = 400;
widget_schedule_resize(resizor->widget, 400, 400);
return resizor;
}
/**
* \brief Create and initialise a new eventdemo window.
* The returned eventdemo instance should be destroyed using \c eventdemo_destroy().
* \param d associated display
*/
static struct eventdemo *
eventdemo_create(struct display *d)
{
struct eventdemo *e;
e = zalloc(sizeof (struct eventdemo));
if (e == NULL)
return NULL;
e->window = window_create(d);
if (noborder) {
/* Demonstrate how to create a borderless window.
* Move windows with META + left mouse button.
*/
e->widget = window_add_widget(e->window, e);
} else {
e->widget = window_frame_create(e->window, e);
window_set_title(e->window, title);
}
e->display = d;
/* The eventdemo window draws a red rectangle as a demonstration
* of per-window data. The dimensions of that rectangle are set
* here.
*/
e->x = width * 1.0 / 4.0;
e->w = width * 2.0 / 4.0;
e->y = height * 1.0 / 4.0;
e->h = height * 2.0 / 4.0;
/* Connect the user data to the window */
window_set_user_data(e->window, e);
/* Set the callback redraw handler for the window */
widget_set_redraw_handler(e->widget, redraw_handler);
/* Set the callback resize handler for the window */
widget_set_resize_handler(e->widget, resize_handler);
/* Set the callback focus handler for the window */
window_set_keyboard_focus_handler(e->window,
keyboard_focus_handler);
/* Set the callback key handler for the window */
window_set_key_handler(e->window, key_handler);
/* Set the callback button handler for the window */
widget_set_button_handler(e->widget, button_handler);
/* Set the callback motion handler for the window */
widget_set_motion_handler(e->widget, motion_handler);
/* Set the callback pointer frame handler for the window */
widget_set_pointer_frame_handler(e->widget, pointer_frame_handler);
/* Set the callback axis handler for the window */
widget_set_axis_handlers(e->widget,
axis_handler,
axis_source_handler,
axis_stop_handler,
axis_discrete_handler);
/* Initial drawing of the window */
window_schedule_resize(e->window, width, height);
return e;
}
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;
}
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;
}
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;
}
