void register_extensions(void) { wl_global_create(wlc_get_wl_display(), &desktop_shell_interface, 3, NULL, desktop_shell_bind); desktop_shell.backgrounds = create_list(); desktop_shell.panels = create_list(); desktop_shell.lock_surfaces = create_list(); desktop_shell.is_locked = false; wl_global_create(wlc_get_wl_display(), &lock_interface, 1, NULL, swaylock_bind); }
bool swc_shell_initialize() { shell.global = wl_global_create(swc.display, &wl_shell_interface, 1, NULL, &bind_shell); return shell.global; }
Global::Global(Compositor *c, const wl_interface *i, uint32_t v) { m_global = wl_global_create(c->m_display, i, v, this, [](wl_client *client, void *data, uint32_t version, uint32_t id) { static_cast<Global *>(data)->bind(client, version, id); }); }
bool data_device_manager_initialize(void) { data_device_manager.global = wl_global_create(swc.display, &wl_data_device_manager_interface, 1, NULL, &bind_data_device_manager); return data_device_manager.global != NULL; }
void meta_wayland_pointer_gestures_init (MetaWaylandCompositor *compositor) { wl_global_create (compositor->wayland_display, &zwp_pointer_gestures_v1_interface, META_ZWP_POINTER_GESTURES_V1_VERSION, NULL, bind_pointer_gestures); }
WL_EXPORT int wl_display_init_shm(struct wl_display *display) { if (!wl_global_create(display, &wl_shm_interface, 1, NULL, bind_shm)) return -1; return 0; }
int wl_display_init_gdl(struct wl_display *display) { if (!wl_global_create(display, &wl_gdl_interface, 1, NULL, bind_gdl)) return -1; return 0; }
void compositor::initialize(wl_display* display) { static compositor comp{display}; wl_global* const g = wl_global_create(display, &wl_compositor_interface, 1, &comp, handle_bind); assert(g); wl_display_init_shm(display); }
void meta_wayland_data_device_manager_init (MetaWaylandCompositor *compositor) { if (wl_global_create (compositor->wayland_display, &wl_data_device_manager_interface, META_WL_DATA_DEVICE_MANAGER_VERSION, NULL, bind_manager) == NULL) g_error ("Could not create data_device"); }
void meta_wayland_wl_shell_init (MetaWaylandCompositor *compositor) { if (wl_global_create (compositor->wayland_display, &wl_shell_interface, META_WL_SHELL_VERSION, compositor, bind_wl_shell) == NULL) g_error ("Failed to register a global wl-shell object"); }
/** Advertise linux_dmabuf support * * Calling this initializes the zwp_linux_dmabuf protocol support, so that * the interface will be advertised to clients. Essentially it creates a * global. Do not call this function multiple times in the compositor's * lifetime. There is no way to deinit explicitly, globals will be reaped * when the wl_display gets destroyed. * * \param compositor The compositor to init for. * \return Zero on success, -1 on failure. */ WL_EXPORT int linux_dmabuf_setup(struct weston_compositor *compositor) { if (!wl_global_create(compositor->wl_display, &zwp_linux_dmabuf_v1_interface, 1, compositor, bind_linux_dmabuf)) return -1; return 0; }
WL_EXPORT int wl_data_device_manager_init(struct wl_display *display) { if (wl_global_create(display, &wl_data_device_manager_interface, 1, NULL, bind_manager) == NULL) return -1; return 0; }
void meta_wayland_init_viewporter (MetaWaylandCompositor *compositor) { if (wl_global_create (compositor->wayland_display, &wp_viewporter_interface, META_WP_VIEWPORTER_VERSION, compositor, wp_viewporter_bind) == NULL) g_error ("Failed to register a global wl-viewporter object"); }
void meta_wayland_init (void) { MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default (); GSource *wayland_event_source; if (!wl_global_create (compositor->wayland_display, &wl_compositor_interface, META_WL_COMPOSITOR_VERSION, compositor, compositor_bind)) g_error ("Failed to register the global wl_compositor"); wayland_event_source = wayland_event_source_new (compositor->wayland_display); /* XXX: Here we are setting the wayland event source to have a * slightly lower priority than the X event source, because we are * much more likely to get confused being told about surface changes * relating to X clients when we don't know what's happened to them * according to the X protocol. * * At some point we could perhaps try and get the X protocol proxied * over the wayland protocol so that we don't have to worry about * synchronizing the two command streams. */ g_source_set_priority (wayland_event_source, GDK_PRIORITY_EVENTS + 1); g_source_attach (wayland_event_source, NULL); wl_display_init_shm (compositor->wayland_display); meta_wayland_outputs_init (compositor); meta_wayland_data_device_manager_init (compositor); meta_wayland_shell_init (compositor); meta_wayland_seat_init (compositor); /* FIXME: find the first free name instead */ compositor->display_name = wl_display_add_socket_auto (compositor->wayland_display); if (compositor->display_name == NULL) g_error ("Failed to create socket"); /* XXX: It's important that we only try and start xwayland after we * have initialized EGL because EGL implements the "wl_drm" * interface which xwayland requires to determine what drm device * name it should use. * * By waiting until we've shown the stage above we ensure that the * underlying GL resources for the surface have also been allocated * and so EGL must be initialized by this point. */ if (!meta_xwayland_start (&compositor->xwayland_manager, compositor->wayland_display)) g_error ("Failed to start X Wayland"); set_gnome_env ("DISPLAY", meta_wayland_get_xwayland_display_name (compositor)); set_gnome_env ("WAYLAND_DISPLAY", meta_wayland_get_wayland_display_name (compositor)); }
bool panel_manager_initialize() { panel_manager.global = wl_global_create(swc.display, &swc_panel_manager_interface, 1, NULL, &bind_panel_manager); if (!panel_manager.global) return false; return true; }
struct tag * tag_new(unsigned index, const char * name) { struct tag * tag; if (!(tag = malloc(sizeof *tag))) goto error0; if (!(tag->name = strdup(name))) goto error1; tag->mask = TAG_MASK(index); tag->screen = NULL; tag->global = wl_global_create(velox.display, &velox_tag_interface, 1, tag, &bind_tag); if (!tag->global) goto error2; tag->config.group.name = strdup(tag->name); tag->config.group.type = CONFIG_NODE_TYPE_GROUP; wl_list_init(&tag->config.group.group); wl_list_insert(&tag_group.group, &tag->config.group.link); tag->config.name.name = "name"; tag->config.name.type = CONFIG_NODE_TYPE_PROPERTY; tag->config.name.property.set = &set_name; wl_list_insert(&tag->config.group.group, &tag->config.name.link); tag->config.activate.name = "activate"; tag->config.activate.type = CONFIG_NODE_TYPE_ACTION; tag->config.activate.action.run = &activate; wl_list_insert(&tag->config.group.group, &tag->config.activate.link); tag->config.toggle.name = "toggle"; tag->config.toggle.type = CONFIG_NODE_TYPE_ACTION; tag->config.toggle.action.run = &toggle; wl_list_insert(&tag->config.group.group, &tag->config.toggle.link); tag->config.apply.name = "apply"; tag->config.apply.type = CONFIG_NODE_TYPE_ACTION; tag->config.apply.action.run = &apply; wl_list_insert(&tag->config.group.group, &tag->config.apply.link); wl_list_init(&tag->resources); return tag; error2: free(tag->name); error1: free(tag); error0: return NULL; }
server_wlegl * server_wlegl_create(struct wl_display *display) { struct server_wlegl *wlegl; wlegl = new server_wlegl; wlegl->display = display; wlegl->global = wl_global_create(display, &android_wlegl_interface, 2, wlegl, server_wlegl_bind); return wlegl; }
static MetaWaylandOutput * meta_wayland_output_new (MetaWaylandCompositor *compositor, MetaMonitorInfo *monitor_info) { MetaWaylandOutput *wayland_output; wayland_output = g_object_new (META_TYPE_WAYLAND_OUTPUT, NULL); wayland_output->global = wl_global_create (compositor->wayland_display, &wl_output_interface, META_WL_OUTPUT_VERSION, wayland_output, bind_output); wayland_output_set_monitor_info (wayland_output, monitor_info); return wayland_output; }
static GHashTable * meta_wayland_compositor_update_outputs (MetaWaylandCompositor *compositor, MetaMonitorManager *monitors) { MetaOutput *outputs; unsigned int i, n_outputs; GHashTable *new_table; outputs = meta_monitor_manager_get_outputs (monitors, &n_outputs); new_table = g_hash_table_new_full (NULL, NULL, NULL, wayland_output_destroy_notify); for (i = 0; i < n_outputs; i++) { MetaOutput *output = &outputs[i]; MetaWaylandOutput *wayland_output; /* wayland does not expose disabled outputs */ if (output->crtc == NULL) { g_hash_table_remove (compositor->outputs, GSIZE_TO_POINTER (output->winsys_id)); continue; } wayland_output = g_hash_table_lookup (compositor->outputs, GSIZE_TO_POINTER (output->winsys_id)); if (wayland_output) { g_hash_table_steal (compositor->outputs, GSIZE_TO_POINTER (output->winsys_id)); } else { wayland_output = g_slice_new0 (MetaWaylandOutput); wayland_output->global = wl_global_create (compositor->wayland_display, &wl_output_interface, META_WL_OUTPUT_VERSION, wayland_output, bind_output); } wayland_output_update_for_output (wayland_output, output); g_hash_table_insert (new_table, GSIZE_TO_POINTER (output->winsys_id), wayland_output); } g_hash_table_destroy (compositor->outputs); return new_table; }
RestrictedGlobal::RestrictedGlobal(Compositor *c, const wl_interface *i, uint32_t v) : m_authorizer(c->authorizer()) , m_interface(i) { m_global = wl_global_create(c->m_display, i, v, this, [](wl_client *client, void *data, uint32_t version, uint32_t id) { RestrictedGlobal *_this = static_cast<RestrictedGlobal *>(data); if (_this->m_authorizer->isClientTrusted(_this->m_interface->name, client)) { _this->bind(client, version, id); } else { wl_resource *resource = wl_resource_create(client, _this->m_interface, version, id); wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT, "permission to bind the global interface '%s' denied", _this->m_interface->name); wl_resource_destroy(resource); } }); m_authorizer->addRestrictedInterface(i->name); }
struct wl_drm * wayland_drm_init(struct wl_display *display, char *device_name, struct wayland_drm_callbacks *callbacks, void *user_data, uint32_t flags) { struct wl_drm *drm; drm = malloc(sizeof *drm); drm->display = display; drm->device_name = strdup(device_name); drm->callbacks = callbacks; drm->user_data = user_data; drm->flags = flags; wl_global_create(display, &wl_drm_interface, 2, drm, bind_drm); return drm; }
WL_EXPORT int controller_module_init(struct weston_compositor *compositor, int *argc, char *argv[], const struct ivi_layout_interface *iface, size_t iface_version) { struct wl_event_loop *loop; struct test_launcher *launcher; const char *path; /* strict check, since this is an internal test module */ if (iface_version != sizeof(*iface)) { weston_log("fatal: controller interface mismatch\n"); return -1; } path = getenv("WESTON_BUILD_DIR"); if (!path) { weston_log("test setup failure: WESTON_BUILD_DIR not set\n"); return -1; } launcher = zalloc(sizeof *launcher); if (!launcher) return -1; launcher->compositor = compositor; launcher->layout_interface = iface; snprintf(launcher->exe, sizeof launcher->exe, "%s/ivi-layout.ivi", path); if (wl_global_create(compositor->wl_display, &weston_test_runner_interface, 1, launcher, bind_runner) == NULL) return -1; loop = wl_display_get_event_loop(compositor->wl_display); wl_event_loop_add_idle(loop, idle_launch_client, launcher); return 0; }
void text_cursor_position_notifier_create(struct weston_compositor *ec) { struct text_cursor_position *text_cursor_position; text_cursor_position = malloc(sizeof *text_cursor_position); if (text_cursor_position == NULL) return; text_cursor_position->ec = ec; text_cursor_position->global = wl_global_create(ec->wl_display, &text_cursor_position_interface, 1, text_cursor_position, bind_text_cursor_position); text_cursor_position->destroy_listener.notify = text_cursor_position_notifier_destroy; wl_signal_add(&ec->destroy_signal, &text_cursor_position->destroy_listener); }
bool swc_shm_initialize() { if (!(swc.shm->context = wld_pixman_create_context())) goto error0; if (!(swc.shm->renderer = wld_create_renderer(swc.shm->context))) goto error1; shm.global = wl_global_create(swc.display, &wl_shm_interface, 1, NULL, &bind_shm); if (!shm.global) goto error2; return true; error2: wld_destroy_renderer(swc.shm->renderer); error1: wld_destroy_context(swc.shm->context); error0: return false; }
static struct wl_drm* wayland_drm_init(struct wl_display *display, char *device_name, struct wayland_drm_callbacks *callbacks, void *user_data, uint32_t flags) { struct wl_drm *drm; drm = malloc(sizeof *drm); if (!drm) return NULL; drm->display = display; drm->device_name = getenv("ARCAN_RENDER_NODE"); drm->callbacks = NULL; drm->user_data = user_data; drm->flags = flags; drm->buffer_interface.destroy = drm_buffer_destroy; drm->wl_drm_global = wl_global_create(display, &wl_drm_interface, 2, drm, bind_drm); return drm; }
//Subcompositor Subcompositor::Subcompositor(Compositor& comp) : compositor_(&comp) { wlGlobal_ = wl_global_create(&comp.wlDisplay(), &wl_subcompositor_interface, 1, this, bindSubcompositor); }
bool swc_drm_initialize() { struct stat master, render; if (!find_primary_drm_device(drm.path, sizeof drm.path)) { ERROR("Could not find DRM device\n"); goto error0; } drm.taken_ids = 0; swc.drm->fd = launch_open_device(drm.path, O_RDWR | O_CLOEXEC); if (swc.drm->fd == -1) { ERROR("Could not open DRM device at %s\n", drm.path); goto error0; } if (fstat(swc.drm->fd, &master) != 0) { ERROR("Could not fstat DRM FD: %s\n", strerror(errno)); goto error1; } if (snprintf(drm.path, sizeof drm.path, "/dev/dri/renderD%d", minor(master.st_rdev) + 0x80) >= sizeof drm.path) { ERROR("Render node path is too long"); goto error1; } if (stat(drm.path, &render) != 0) { ERROR("Could not stat render node for primary DRM device: %s\n", strerror(errno)); goto error1; } if (master.st_mode != render.st_mode || minor(master.st_rdev) + 0x80 != minor(render.st_rdev)) { ERROR("Render node does not have expected mode or minor number\n"); goto error1; } if (!(swc.drm->context = wld_drm_create_context(swc.drm->fd))) { ERROR("Could not create WLD DRM context\n"); goto error1; } if (!(swc.drm->renderer = wld_create_renderer(swc.drm->context))) { ERROR("Could not create WLD DRM renderer\n"); goto error2; } drm.event_source = wl_event_loop_add_fd (swc.event_loop, swc.drm->fd, WL_EVENT_READABLE, &handle_data, NULL); if (!drm.event_source) { ERROR("Could not create DRM event source\n"); goto error3; } if (!wld_drm_is_dumb(swc.drm->context)) { drm.global = wl_global_create(swc.display, &wl_drm_interface, 2, NULL, &bind_drm); if (!drm.global) { ERROR("Could not create wl_drm global\n"); goto error4; } } return true; error4: wl_event_source_remove(drm.event_source); error3: wld_destroy_renderer(swc.drm->renderer); error2: wld_destroy_context(swc.drm->context); error1: close(swc.drm->fd); error0: return false; }