void gui_window_set_title(struct gui_window *gw, const char *title) { if (gw == NULL) return; if (gw->root) { int l; char * conv; l = strlen(title)+1; if (utf8_to_local_encoding(title, l-1, &conv) == UTF8_CONVERT_OK ) { l = MIN((uint32_t)atari_sysinfo.aes_max_win_title_len, strlen(conv)); if(gw->title == NULL) gw->title = malloc(l); else gw->title = realloc(gw->title, l); strncpy(gw->title, conv, l); free( conv ); } else { l = MIN((size_t)atari_sysinfo.aes_max_win_title_len, strlen(title)); if(gw->title == NULL) gw->title = malloc(l); else gw->title = realloc(gw->title, l); strncpy(gw->title, title, l); } gw->title[l] = 0; if(input_window == gw) window_set_title(gw->root, gw->title); } }
static void set_title(struct wl_client * client, struct wl_resource * resource, const char * title) { struct shell_surface * shell_surface = wl_resource_get_user_data(resource); window_set_title(&shell_surface->window, title, -1); }
static void keyboard_create(struct output *output, struct virtual_keyboard *virtual_keyboard) { struct keyboard *keyboard; keyboard = malloc(sizeof *keyboard); memset(keyboard, 0, sizeof *keyboard); keyboard->keyboard = virtual_keyboard; keyboard->window = window_create_custom(virtual_keyboard->display); keyboard->widget = window_add_widget(keyboard->window, keyboard); window_set_title(keyboard->window, "Virtual keyboard"); window_set_user_data(keyboard->window, keyboard); widget_set_redraw_handler(keyboard->widget, redraw_handler); widget_set_resize_handler(keyboard->widget, resize_handler); widget_set_button_handler(keyboard->widget, button_handler); window_schedule_resize(keyboard->window, columns * key_width, rows * key_height); input_panel_set_surface(virtual_keyboard->input_panel, window_get_wl_surface(keyboard->window), output_get_wl_output(output)); }
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 void keyboard_create(struct output *output, struct virtual_keyboard *virtual_keyboard) { struct keyboard *keyboard; const struct layout *layout; struct wl_input_panel_surface *ips; layout = get_current_layout(virtual_keyboard); keyboard = xzalloc(sizeof *keyboard); keyboard->keyboard = virtual_keyboard; keyboard->window = window_create_custom(virtual_keyboard->display); keyboard->widget = window_add_widget(keyboard->window, keyboard); virtual_keyboard->keyboard = keyboard; window_set_title(keyboard->window, "Virtual keyboard"); window_set_user_data(keyboard->window, keyboard); widget_set_redraw_handler(keyboard->widget, redraw_handler); widget_set_resize_handler(keyboard->widget, resize_handler); widget_set_button_handler(keyboard->widget, button_handler); window_schedule_resize(keyboard->window, layout->columns * key_width, layout->rows * key_height); ips = wl_input_panel_get_input_panel_surface(virtual_keyboard->input_panel, window_get_wl_surface(keyboard->window)); wl_input_panel_surface_set_toplevel(ips, output_get_wl_output(output), WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM); }
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; }
int main( int argc, char *argv[] ) { layout_t *lt, *lt2, *lt3, *lt4; bounds_t *b; object_t *rg, *btn, *fr; claro_base_init( ); claro_graphics_init( ); log_fd_set_level( CL_DEBUG, stderr ); clog( CL_INFO, "%s running using Claro!", __FILE__ ); b = new_bounds( 100, 100, 460, 230 ); w = window_widget_create( 0, b, 0 ); object_addhandler( w, "destroy", window_closed ); window_set_title( w, "Radio button example" ); lt = layout_create( w, "[][_<|set1|<|set3|<][][_<|set2|<|set4|<][]", *b, 10, 10 ); /* create a frame */ b = lt_bounds(lt,"set1"); fr = frame_widget_create_with_label( w, b, 0, "Group 1" ); lt2 = layout_create( fr, "[r1][r2][r3][_]", *b, 20, 20 ); rg = radiogroup_create( fr, 0 ); btn = radiobutton_widget_create( fr, rg, lt_bounds(lt2,"r1"), "Button 1", 0 ); btn = radiobutton_widget_create( fr, rg, lt_bounds(lt2,"r2"), "Button 2", 0 ); btn = radiobutton_widget_create( fr, rg, lt_bounds(lt2,"r3"), "Button 3", 0 ); /* create a frame */ b = lt_bounds(lt,"set2"); fr = frame_widget_create_with_label( w, b, 0, "Group 2" ); lt3 = layout_create( fr, "[r1][r2][r3][_]", *b, 20, 20 ); rg = radiogroup_create( fr, 0 ); btn = radiobutton_widget_create( fr, rg, lt_bounds(lt3,"r1"), "Button 1", 0 ); btn = radiobutton_widget_create( fr, rg, lt_bounds(lt3,"r2"), "Button 2", 0 ); btn = radiobutton_widget_create( fr, rg, lt_bounds(lt3,"r3"), "Button 3", 0 ); /* create a frame */ b = lt_bounds(lt,"set3"); fr = frame_widget_create_with_label( w, b, 0, "Group 3" ); lt4 = layout_create( fr, "[r1][r2][r3][_]", *b, 20, 20 ); btn = checkbox_widget_create_with_label( fr, lt_bounds(lt4,"r1"), 0, "Button 1" ); btn = checkbox_widget_create_with_label( fr, lt_bounds(lt4,"r2"), 0, "Button 2" ); btn = checkbox_widget_create_with_label( fr, lt_bounds(lt4,"r3"), 0, "Button 3" ); window_show( w ); window_focus( w ); block_heap_loginfo( ); claro_loop( ); 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; }
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; }
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; }
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; }
void b_open_autowin( ) { int y, yi, w, h, mpos; int btn_w; w = 650; h = 200; yi = 30; mpos = 120; if ( autowin == 0 ) { bounds_t *b = new_bounds( -1, -1, w, h ); layout_t *lt; autowin = window_widget_create( bersirc->mainwin, b, cWindowModalDialog | cWindowCenterParent ); window_set_icon( autowin, b_icon( "bersirc" ) ); window_set_title( autowin, lang_phrase_quick( "autoconnectwin" ) ); object_addhandler( autowin, "destroy", b_autowin_killed ); object_addhandler( autowin, "closing", b_autowin_closing ); lt = layout_create( autowin, "[][_<|list|<][][{25}<|btnadd|<|btnedit|<|btndelete|<|btncancel|<][]", *b, 10, 10 ); y = 10; autowin_servlist = listview_widget_create( autowin, lt_bounds(lt,"list"), 3, 0, "", cListViewTypeCheckBox, lang_phrase_quick( "serveraddy" ), cListViewTypeText, lang_phrase_quick( "channels" ), cListViewTypeText ); btn_w = ((w-20-20)/4); btnadd = button_widget_create_with_label( autowin, lt_bounds(lt,"btnadd"), 0, lang_phrase_quick( "addserver" ) ); btnedit = button_widget_create_with_label( autowin, lt_bounds(lt,"btnedit"), 0, lang_phrase_quick( "editserver" ) ); btndelete = button_widget_create_with_label( autowin, lt_bounds(lt,"btndelete"), 0, lang_phrase_quick( "deleteserver" ) ); btncancel = button_widget_create_with_label( autowin, lt_bounds(lt,"btncancel"), 0, lang_phrase_quick( "close" ) ); // no edit or delete until selected widget_disable( OBJECT( btndelete ) ); widget_disable( OBJECT( btnedit ) ); object_addhandler( autowin_servlist, "selected", b_autowin_serversel ); object_addhandler( btnadd, "pushed", b_autowin_add ); object_addhandler( btnedit, "pushed", b_autowin_edit ); object_addhandler( btndelete, "pushed", b_autowin_delete ); object_addhandler( btncancel, "pushed", b_autowin_close ); window_show( autowin ); b_autowin_gui_init( ); } else { widget_focus( OBJECT( autowin ) ); } }
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; }
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 action_window( Display * disp, Window win, char mode ) { /*{{{ */ p_verbose( "Using window: 0x%.8lx\n", win ); switch ( mode ) { case 'a': return activate_window( disp, win, TRUE ); case 'c': return close_window( disp, win ); case 'e': /* resize/move the window around the desktop => -r -e */ return window_move_resize( disp, win, options.param ); case 'b': /* change state of a window => -r -b */ return window_state( disp, win, options.param ); case 't': /* move the window to the specified desktop => -r -t */ return window_to_desktop( disp, win, atoi( options.param ) ); case 'R': /* move the window to the current desktop and activate it => -r */ if ( window_to_desktop( disp, win, -1 ) == EXIT_SUCCESS ) { usleep( 100000 ); /* 100 ms - make sure the WM has enough time to move the window, before we activate it */ return activate_window( disp, win, FALSE ); } else { return EXIT_FAILURE; } case 'N': case 'I': case 'T': window_set_title( disp, win, options.param, mode ); return EXIT_SUCCESS; default: fprintf( stderr, "Unknown action: '%c'\n", mode ); return EXIT_FAILURE; } }
static struct ModeInfo * create_wscreensaver_instance(struct wscreensaver *screensaver, struct wl_output *output, int width, int height) { static int instance; struct ModeInfo *mi; struct rectangle drawarea; mi = calloc(1, sizeof *mi); if (!mi) return NULL; if (demo_mode) mi->window = window_create(screensaver->display); else mi->window = window_create_custom(screensaver->display); if (!mi->window) { fprintf(stderr, "%s: creating a window failed.\n", progname); free(mi); return NULL; } window_set_title(mi->window, progname); if (screensaver->interface && !demo_mode) { mi->widget = window_add_widget(mi->window, mi); screensaver_set_surface(screensaver->interface, window_get_wl_surface(mi->window), output); } else { mi->widget = frame_create(mi->window, mi); } widget_set_redraw_handler(mi->widget, redraw_handler); mi->priv = screensaver; mi->eglctx = EGL_NO_CONTEXT; mi->instance_number = instance++; /* XXX */ widget_get_allocation(mi->widget, &drawarea); mi->width = drawarea.width; mi->height = drawarea.height; screensaver->plugin->init(mi); window_schedule_resize(mi->window, width, height); return mi; }
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; }
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; }
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[] ) { claro_base_init( ); claro_graphics_init( ); log_fd_set_level( CL_DEBUG, stderr ); clog( CL_INFO, "%s running using Claro!", __FILE__ ); w = window_widget_create( 0, new_bounds( 100, 100, 230, 230 ), cWidgetCustomDraw ); window_set_title( w, "Hello, World!" ); /* t = textbox_widget_create( w, new_bounds( 10, 10, 210, -1 ), 0 ); widget_set_notify( WIDGET(t), cNotifyKey ); textbox_set_text( t, "Yeehaw!" ); */ b = button_widget_create( w, new_bounds( 0, 0, 230, -1 ), 0 ); button_set_text( b, "Close me!" ); object_addhandler( b, "pushed", push_my_button ); #ifndef NO_CAIRO c = canvas_widget_create( w, new_bounds( 15, 30, 200, 200 ), 0 ); object_addhandler(OBJECT(c), "redraw", handle_redraw ); /* add our main loop */ object_addhandler( claro, "mainloop", handle_main ); #endif window_show( w ); window_focus( w ); block_heap_loginfo( ); claro_loop( ); 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[] ) { object_t *w; layout_t *lt; object_t *btn = NULL; bounds_t *b = NULL; claro_base_init( ); claro_graphics_init( ); //log_fd_set_level( CL_DEBUG, stderr ); clog( CL_INFO, "%s running using Claro!", __FILE__ ); b = new_bounds(50, 50, 300, 300); w = window_widget_create(NULL, b, 0); window_set_title(w, "Canvas Speed Test"); object_addhandler(w, "destroy", window_closed); lt = layout_create(w, "[][_<a|canvas|>a][]", *b, 10, 10 ); assert(lt != NULL && "layout was failed to parse"); c = (widget_t *)canvas_widget_create( w, lt_bounds(lt, "canvas"), 0 ); object_addhandler( OBJECT(c), "redraw", handle_redraw ); object_addhandler( OBJECT(c), "clicked", handle_mousedown ); object_addhandler( OBJECT(c), "released", handle_mouseup ); object_addhandler( OBJECT(c), "mouse_moved", handle_mousemove ); window_show( w ); window_focus( w ); claro_loop( ); 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 calibrator * calibrator_create(struct display *display) { struct calibrator *calibrator; calibrator = malloc(sizeof *calibrator); if (calibrator == NULL) return NULL; calibrator->window = window_create(display); calibrator->widget = window_add_widget(calibrator->window, calibrator); window_set_title(calibrator->window, "Wayland calibrator"); calibrator->display = display; calibrator->current_test = ARRAY_LENGTH(test_ratios) - 1; widget_set_button_handler(calibrator->widget, button_handler); widget_set_redraw_handler(calibrator->widget, redraw_handler); window_set_fullscreen(calibrator->window, 1); return calibrator; }
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; }
int main(int argc, char *argv[]) { claro_base_init(); claro_graphics_init(); types = g_hash_table_new(g_str_hash, g_str_equal); log_fd_set_level(CL_DEBUG, stderr); clog(CL_INFO, "%s running using Claro!", __FILE__); w = window_widget_create(0, new_bounds(100, 100, 230, 100), 0); object_addhandler(w, "destroy", window_closed); window_set_title(w, "Cursor Types"); c = combo_widget_create(w, new_bounds(10, 10, 210, -1), 0); object_addhandler(c, "selected", combo_selected); list_item_t * item = COMBO_APPEND(c, cCursorNormal); combo_select_item(c, item); COMBO_APPEND(c, cCursorTextEdit); COMBO_APPEND(c, cCursorWait); COMBO_APPEND(c, cCursorPoint); window_show(w); window_focus(w); block_heap_loginfo(); claro_loop(); g_hash_table_destroy(types); return 0; }
void parse_pushed(object_t *obj, event_t *evt) { object_t *window = NULL; bounds_t *b; object_t *lelex = NULL; size_t len; int type; lelex = (object_t *)store_get("lelex", &len, &type); assert(len == sizeof(textbox_widget_t) && type == TYPE_TEXTBOX && "invalid object in store for lelex"); // first kill the old window if it is still around window = store_take("display.window", &len, &type); if(window) { window_hide(window); event_send(window, "destroy", ""); } b = new_bounds(0,0,0,0); *b = store_get_bounds_t("window.bounds"); window = window_widget_create(NULL, b, 0); window_set_title(window, "Layout Display"); object_addhandler(window, "destroy", window_destroy_handle); object_addhandler(window, "moved", window_moved_handle); object_addhandler(window, "resized", window_moved_handle); if(!make_layout(window, b, textarea_get_text(lelex))) { event_send(window, "destroy", ""); printf("FAILED TO PARSE"); } else { store_put("display.window", window, sizeof(window_widget_t), TYPE_WINDOW); window_show( window ); window_focus( window ); } }
int main(int argc, char *argv[]) { image_t * img; object_t * menu; list_item_t * quit_item; claro_base_init(); claro_graphics_init(); log_fd_set_level(CL_DEBUG, stderr); clog(CL_INFO, "%s running using Claro!", __FILE__); w = window_widget_create(0, new_bounds(100, 100, 230, 230), 0); object_addhandler(w, "destroy", window_closed); window_set_title(w, "Status Icon"); menu = menu_widget_create(w, 0); quit_item = menu_append_item(menu, NULL, stock_get_image("system-log-out"), "Quit"); object_addhandler(OBJECT(quit_item), "pushed", window_closed); img = image_load(w, "icon.png"); s = status_icon_create(w, img, 0); status_icon_set_tooltip(s, "Claro - Status Icon"); status_icon_set_menu(s, menu); object_addhandler(s, "pushed", status_icon_pushed); window_show(w); window_focus(w); block_heap_loginfo(); claro_loop(); return 0; }
static struct gears * gears_create(struct display *display) { const int width = 450, height = 500; struct gears *gears; struct timeval tv; int i; gears = zalloc(sizeof *gears); gears->d = display; gears->window = window_create(display); gears->widget = window_frame_create(gears->window, gears); window_set_title(gears->window, "Wayland Gears"); gears->display = display_get_egl_display(gears->d); if (gears->display == NULL) die("failed to create egl display\n"); eglBindAPI(EGL_OPENGL_API); gears->config = display_get_argb_egl_config(gears->d); gears->context = eglCreateContext(gears->display, gears->config, EGL_NO_CONTEXT, NULL); if (gears->context == NULL) die("failed to create context\n"); if (!eglMakeCurrent(gears->display, NULL, NULL, gears->context)) die("failed to make context current\n"); for (i = 0; i < 3; i++) { gears->gear_list[i] = glGenLists(1); glNewList(gears->gear_list[i], GL_COMPILE); make_gear(&gear_templates[i]); glEndList(); } gears->button_down = 0; gears->last_x = 0; gears->last_y = 0; gears->view.rotx = 20.0; gears->view.roty = 30.0; gettimeofday(&tv, NULL); gears->last_fps = tv.tv_sec * 1000 + tv.tv_usec / 1000; printf("Warning: FPS count is limited by the wayland compositor or monitor refresh rate\n"); glEnable(GL_NORMALIZE); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 200.0); glMatrixMode(GL_MODELVIEW); glLightfv(GL_LIGHT0, GL_POSITION, light_pos); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glClearColor(0, 0, 0, 0.92); window_set_user_data(gears->window, gears); widget_set_resize_handler(gears->widget, resize_handler); widget_set_redraw_handler(gears->widget, redraw_handler); widget_set_button_handler(gears->widget, button_handler); widget_set_motion_handler(gears->widget, motion_handler); window_set_keyboard_focus_handler(gears->window, keyboard_focus_handler); window_set_fullscreen_handler(gears->window, fullscreen_handler); window_schedule_resize(gears->window, width, height); return gears; }
int main( int argc, char *argv[] ) { object_t *w, *sw, *sw2, *cw; layout_t *lt; object_t *btn; bounds_t *b = NULL; claro_base_init( ); claro_graphics_init( ); log_fd_set_level( CL_DEBUG, stderr ); clog( CL_INFO, "%s running using Claro!", __FILE__ ); b = new_bounds(50, 50, 300, 300); w = window_widget_create(NULL, b, 0); window_set_title(w, "Splitter Demo"); object_addhandler(w, "destroy", window_closed); lt = layout_create(w, "[_splitter]", *b, 10, 10 ); assert(lt != NULL && "failed to parse layout"); sw = splitter_widget_create( w, lt_bounds(lt, "splitter"), cSplitterHorizontal ); splitter_set_info( sw, cSplitterFirst, 0, 200 ); splitter_set_info( sw, cSplitterSecond, 1, 0 ); btn = button_widget_create( sw, NO_BOUNDS, 0 ); lb = btn; button_set_text(btn, "Button Left"); sw2 = splitter_widget_create( sw, NO_BOUNDS, cSplitterVertical ); splitter_set_info( sw2, cSplitterFirst, 1, 0 ); splitter_set_info( sw2, cSplitterSecond, 0, 200 ); btn = button_widget_create( sw2, NO_BOUNDS, 0 ); object_addhandler( btn, "pushed", show_button ); button_set_text(btn, "Button Top-Right"); cw = container_widget_create( sw2, NO_BOUNDS, 0 ); lt = layout_create(cw, "[_ul|(10)|ur][{10}][_ll|(10)|lr]", *b, 10, 10 ); btn = button_widget_create( cw, lt_bounds( lt, "ul" ), 0 ); object_addhandler( btn, "pushed", hide_button ); button_set_text(btn, "B-U-L"); btn = button_widget_create( cw, lt_bounds( lt, "ur" ), 0 ); button_set_text(btn, "B-U-R"); btn = button_widget_create( cw, lt_bounds( lt, "ll" ), 0 ); button_set_text(btn, "B-L-L"); btn = button_widget_create( cw, lt_bounds( lt, "lr" ), 0 ); button_set_text(btn, "B-L-R"); window_show( w ); window_focus( w ); block_heap_loginfo( ); claro_loop( ); return 0; }