void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) { struct wlr_xdg_surface_v6 *xdg_surface = data; if (xdg_surface->role == WLR_XDG_SURFACE_V6_ROLE_POPUP) { sway_log(SWAY_DEBUG, "New xdg_shell_v6 popup"); return; } sway_log(SWAY_DEBUG, "New xdg_shell_v6 toplevel title='%s' app_id='%s'", xdg_surface->toplevel->title, xdg_surface->toplevel->app_id); wlr_xdg_surface_v6_ping(xdg_surface); struct sway_xdg_shell_v6_view *xdg_shell_v6_view = calloc(1, sizeof(struct sway_xdg_shell_v6_view)); if (!sway_assert(xdg_shell_v6_view, "Failed to allocate view")) { return; } view_init(&xdg_shell_v6_view->view, SWAY_VIEW_XDG_SHELL_V6, &view_impl); xdg_shell_v6_view->view.wlr_xdg_surface_v6 = xdg_surface; xdg_shell_v6_view->map.notify = handle_map; wl_signal_add(&xdg_surface->events.map, &xdg_shell_v6_view->map); xdg_shell_v6_view->unmap.notify = handle_unmap; wl_signal_add(&xdg_surface->events.unmap, &xdg_shell_v6_view->unmap); xdg_shell_v6_view->destroy.notify = handle_destroy; wl_signal_add(&xdg_surface->events.destroy, &xdg_shell_v6_view->destroy); xdg_surface->data = xdg_shell_v6_view; }
WL_EXPORT int module_init(struct weston_compositor *ec, int *argc, char *argv[]) { struct cms_static *cms; struct weston_output *output; weston_log("cms-static: initialized\n"); /* create local state object */ cms = malloc(sizeof *cms); if (cms == NULL) return -1; memset(cms, 0, sizeof *cms); cms->ec = ec; cms->destroy_listener.notify = cms_notifier_destroy; wl_signal_add(&ec->destroy_signal, &cms->destroy_listener); cms->output_created_listener.notify = cms_notifier_output_created; wl_signal_add(&ec->output_created_signal, &cms->output_created_listener); /* discover outputs */ wl_list_for_each(output, &ec->output_list, link) cms_output_created(cms, output); return 0; }
static int pixman_renderer_create_surface(struct weston_surface *surface) { struct pixman_surface_state *ps; struct pixman_renderer *pr = get_renderer(surface->compositor); ps = calloc(1, sizeof *ps); if (!ps) return -1; surface->renderer_state = ps; ps->surface = surface; ps->surface_destroy_listener.notify = surface_state_handle_surface_destroy; wl_signal_add(&surface->destroy_signal, &ps->surface_destroy_listener); ps->renderer_destroy_listener.notify = surface_state_handle_renderer_destroy; wl_signal_add(&pr->destroy_signal, &ps->renderer_destroy_listener); return 0; }
void wayfire_core::init(wayfire_config *conf) { configure(conf); wf_input_device::config.load(conf); protocols.data_device = wlr_data_device_manager_create(display); protocols.data_control = wlr_data_control_manager_v1_create(display); wlr_renderer_init_wl_display(renderer, display); output_layout = wlr_output_layout_create(); output_layout_changed.notify = handle_output_layout_changed; wl_signal_add(&output_layout->events.change, &output_layout_changed); core->compositor = wlr_compositor_create(display, wlr_backend_get_renderer(backend)); init_desktop_apis(); input = new input_manager(); protocols.screenshooter = wlr_screenshooter_create(display); protocols.screencopy = wlr_screencopy_manager_v1_create(display); protocols.gamma = wlr_gamma_control_manager_create(display); protocols.gamma_v1 = wlr_gamma_control_manager_v1_create(display); protocols.linux_dmabuf = wlr_linux_dmabuf_v1_create(display, renderer); protocols.export_dmabuf = wlr_export_dmabuf_manager_v1_create(display); protocols.decorator_manager = wlr_server_decoration_manager_create(display); wlr_server_decoration_manager_set_default_mode(protocols.decorator_manager, WLR_SERVER_DECORATION_MANAGER_MODE_CLIENT); input_inhibit_activated.notify = handle_input_inhibit_activated; input_inhibit_deactivated.notify = handle_input_inhibit_deactivated; protocols.input_inhibit = wlr_input_inhibit_manager_create(display); wl_signal_add(&protocols.input_inhibit->events.activate, &input_inhibit_activated); wl_signal_add(&protocols.input_inhibit->events.deactivate, &input_inhibit_deactivated); decoration_created.notify = handle_decoration_created; wl_signal_add(&protocols.decorator_manager->events.new_decoration, &decoration_created); protocols.output_manager = wlr_xdg_output_manager_v1_create(display, output_layout); protocols.vkbd_manager = wlr_virtual_keyboard_manager_v1_create(display); vkbd_created.notify = handle_virtual_keyboard; wl_signal_add(&protocols.vkbd_manager->events.new_virtual_keyboard, &vkbd_created); protocols.idle = wlr_idle_create(display); protocols.idle_inhibit = wlr_idle_inhibit_v1_create(display); protocols.wf_shell = wayfire_shell_create(display); protocols.gtk_shell = wf_gtk_shell_create(display); protocols.toplevel_manager = wlr_foreign_toplevel_manager_v1_create(display); protocols.pointer_gestures = wlr_pointer_gestures_v1_create(display); image_io::init(); OpenGL::init(); }
wf_touch::wf_touch(wlr_cursor *cursor) { down.notify = handle_touch_down; up.notify = handle_touch_up; motion.notify = handle_touch_motion; wl_signal_add(&cursor->events.touch_up, &up); wl_signal_add(&cursor->events.touch_down, &down); wl_signal_add(&cursor->events.touch_motion, &motion); this->cursor = cursor; }
struct wb_cursor *wb_cursor_create() { struct wb_cursor *cursor = malloc(sizeof(struct wb_cursor)); cursor->cursor = wlr_cursor_create(); cursor->xcursor_manager = wlr_xcursor_manager_create("default", 24); cursor->cursor_motion.notify = handle_cursor_motion; wl_signal_add(&cursor->cursor->events.motion, &cursor->cursor_motion); cursor->cursor_motion_absolute.notify = handle_cursor_motion_absolute; wl_signal_add(&cursor->cursor->events.motion_absolute, &cursor->cursor_motion_absolute); return cursor; }
static void get_shell_surface (struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surface_resource) { CoglandSurface *surface = wl_resource_get_user_data (surface_resource); CoglandShellSurface *shell_surface; if (surface->has_shell_surface) { wl_resource_post_error (surface_resource, WL_DISPLAY_ERROR_INVALID_OBJECT, "wl_shell::get_shell_surface already requested"); return; } shell_surface = g_new0 (CoglandShellSurface, 1); shell_surface->surface = surface; shell_surface->surface_destroy_listener.notify = shell_handle_surface_destroy; wl_signal_add (&surface->destroy_signal, &shell_surface->surface_destroy_listener); surface->has_shell_surface = TRUE; shell_surface->resource = wl_client_add_object (client, &wl_shell_surface_interface, &cogl_shell_surface_interface, id, shell_surface); wl_resource_set_destructor (shell_surface->resource, destroy_shell_surface_cb); }
static struct wl_resource * weston_data_source_send_offer(struct weston_data_source *source, struct wl_resource *target) { struct weston_data_offer *offer; char **p; offer = malloc(sizeof *offer); if (offer == NULL) return NULL; offer->resource = wl_resource_create(wl_resource_get_client(target), &wl_data_offer_interface, 1, 0); if (offer->resource == NULL) { free(offer); return NULL; } wl_resource_set_implementation(offer->resource, &data_offer_interface, offer, destroy_data_offer); offer->source = source; offer->source_destroy_listener.notify = destroy_offer_data_source; wl_signal_add(&source->destroy_signal, &offer->source_destroy_listener); wl_data_device_send_data_offer(target, offer->resource); wl_array_for_each(p, &source->mime_types) wl_data_offer_send_offer(offer->resource, *p); return offer->resource; }
static void cogland_buffer_reference (CoglandBufferReference *ref, CoglandBuffer *buffer) { if (ref->buffer && buffer != ref->buffer) { ref->buffer->busy_count--; if (ref->buffer->busy_count == 0) { g_assert (wl_resource_get_client (ref->buffer->resource)); wl_resource_queue_event (ref->buffer->resource, WL_BUFFER_RELEASE); } wl_list_remove (&ref->destroy_listener.link); } if (buffer && buffer != ref->buffer) { buffer->busy_count++; wl_signal_add (&buffer->destroy_signal, &ref->destroy_listener); } ref->buffer = buffer; ref->destroy_listener.notify = cogland_buffer_reference_handle_destroy; }
struct weston_desktop_seat * weston_desktop_seat_from_seat(struct weston_seat *wseat) { struct wl_listener *listener; struct weston_desktop_seat *seat; listener = wl_signal_get(&wseat->destroy_signal, weston_desktop_seat_destroy); if (listener != NULL) return wl_container_of(listener, seat, seat_destroy_listener); seat = zalloc(sizeof(struct weston_desktop_seat)); if (seat == NULL) return NULL; seat->seat = wseat; seat->seat_destroy_listener.notify = weston_desktop_seat_destroy; wl_signal_add(&wseat->destroy_signal, &seat->seat_destroy_listener); seat->popup_grab.keyboard.interface = &weston_desktop_seat_keyboard_popup_grab_interface; seat->popup_grab.pointer.interface = &weston_desktop_seat_pointer_popup_grab_interface; seat->popup_grab.touch.interface = &weston_desktop_seat_touch_popup_grab_interface; wl_list_init(&seat->popup_grab.surfaces); return seat; }
static void cogland_surface_attach (struct wl_client *wayland_client, struct wl_resource *wayland_surface_resource, struct wl_resource *wayland_buffer_resource, int32_t sx, int32_t sy) { CoglandSurface *surface = wl_resource_get_user_data (wayland_surface_resource); CoglandBuffer *buffer; if (wayland_buffer_resource) buffer = cogland_buffer_from_resource (wayland_buffer_resource); else buffer = NULL; /* Attach without commit in between does not went wl_buffer.release */ if (surface->pending.buffer) wl_list_remove (&surface->pending.buffer_destroy_listener.link); surface->pending.sx = sx; surface->pending.sy = sy; surface->pending.buffer = buffer; surface->pending.newly_attached = TRUE; if (buffer) wl_signal_add (&buffer->destroy_signal, &surface->pending.buffer_destroy_listener); }
static struct wl_resource * wl_data_source_send_offer(struct wl_data_source *source, struct wl_resource *target) { struct wl_data_offer *offer; char **p; offer = malloc(sizeof *offer); if (offer == NULL) return NULL; offer->resource.destroy = destroy_data_offer; offer->resource.object.id = 0; offer->resource.object.interface = &wl_data_offer_interface; offer->resource.object.implementation = (void (**)(void)) &data_offer_interface; offer->resource.data = offer; wl_signal_init(&offer->resource.destroy_signal); offer->source = source; offer->source_destroy_listener.notify = destroy_offer_data_source; wl_signal_add(&source->resource.destroy_signal, &offer->source_destroy_listener); wl_client_add_resource(target->client, &offer->resource); wl_data_device_send_data_offer(target, &offer->resource); wl_array_for_each(p, &source->mime_types) wl_data_offer_send_offer(&offer->resource, *p); return &offer->resource; }
ShellSeat::ShellSeat(struct weston_seat *seat) : m_seat(seat) { m_popupGrab.client = nullptr; m_popupGrab.seat = this; m_listeners.seat = this; m_listeners.seatDestroy.notify = seatDestroyed; wl_signal_add(&seat->destroy_signal, &m_listeners.seatDestroy); if (seat->pointer) { m_listeners.focus.notify = pointerFocus; wl_signal_add(&seat->pointer->focus_signal, &m_listeners.focus); } else { wl_list_init(&m_listeners.focus.link); } }
WL_EXPORT int weston_touch_start_drag(struct weston_touch *touch, struct weston_data_source *source, struct weston_surface *icon, struct wl_client *client) { struct weston_touch_drag *drag; drag = zalloc(sizeof *drag); if (drag == NULL) return -1; drag->grab.interface = &touch_drag_grab_interface; drag->base.client = client; drag->base.data_source = source; if (icon) { drag->base.icon = weston_view_create(icon); if (drag->base.icon == NULL) { free(drag); return -1; } drag->base.icon_destroy_listener.notify = handle_drag_icon_destroy; wl_signal_add(&icon->destroy_signal, &drag->base.icon_destroy_listener); icon->configure = touch_drag_surface_configure; icon->configure_private = drag; } else { drag->base.icon = NULL; } if (source) { drag->base.data_source_listener.notify = destroy_touch_data_device_source; wl_signal_add(&source->destroy_signal, &drag->base.data_source_listener); } weston_touch_start_grab(touch, &drag->grab); drag_grab_touch_focus(drag); return 0; }
void registerResource(wl_list *list, wl_resource *resource) { wl_list_insert(list, &resource->link); wl_listener *listener = new wl_listener; listener->notify = unregisterResourceCallback; wl_signal_add(&resource->destroy_signal, listener); }
WL_EXPORT int wet_shell_init(struct weston_compositor *ec, int *argc, char *argv[]) { struct desktest_shell *dts; dts = zalloc(sizeof *dts); if (!dts) return -1; dts->compositor_destroy_listener.notify = shell_destroy; wl_signal_add(&ec->destroy_signal, &dts->compositor_destroy_listener); weston_layer_init(&dts->layer, ec); weston_layer_init(&dts->background_layer, ec); weston_layer_set_position(&dts->layer, WESTON_LAYER_POSITION_NORMAL); weston_layer_set_position(&dts->background_layer, WESTON_LAYER_POSITION_BACKGROUND); dts->background_surface = weston_surface_create(ec); if (dts->background_surface == NULL) goto out_free; dts->background_view = weston_view_create(dts->background_surface); if (dts->background_view == NULL) goto out_surface; weston_surface_set_color(dts->background_surface, 0.16, 0.32, 0.48, 1.); pixman_region32_fini(&dts->background_surface->opaque); pixman_region32_init_rect(&dts->background_surface->opaque, 0, 0, 2000, 2000); pixman_region32_fini(&dts->background_surface->input); pixman_region32_init_rect(&dts->background_surface->input, 0, 0, 2000, 2000); weston_surface_set_size(dts->background_surface, 2000, 2000); weston_view_set_position(dts->background_view, 0, 0); weston_layer_entry_insert(&dts->background_layer.view_list, &dts->background_view->layer_link); weston_view_update_transform(dts->background_view); dts->desktop = weston_desktop_create(ec, &shell_desktop_api, dts); if (dts->desktop == NULL) goto out_view; return 0; out_view: weston_view_destroy(dts->background_view); out_surface: weston_surface_destroy(dts->background_surface); out_free: free(dts); return -1; }
void Touch::setFocus(Surface *surface) { wl_list_remove(&m_focusDestroyListener.listener.link); wl_list_init(&m_focusDestroyListener.listener.link); if (surface) wl_signal_add(&surface->resource()->handle->destroy_signal, &m_focusDestroyListener.listener); m_focus = surface; m_focusResource = surface ? resourceMap().value(surface->resource()->client()) : 0; }
struct clipboard * clipboard_create(struct weston_seat *seat) { struct clipboard *clipboard; clipboard = zalloc(sizeof *clipboard); if (clipboard == NULL) return NULL; clipboard->seat = seat; clipboard->selection_listener.notify = clipboard_set_selection; clipboard->destroy_listener.notify = clipboard_destroy; wl_signal_add(&seat->selection_signal, &clipboard->selection_listener); wl_signal_add(&seat->destroy_signal, &clipboard->destroy_listener); return clipboard; }
bool cursor_plane_initialize(struct cursor_plane * plane, uint32_t crtc, const struct swc_rectangle * origin) { plane->origin = origin; plane->crtc = crtc; plane->swc_listener.notify = &handle_swc_event; wl_signal_add(&swc.event_signal, &plane->swc_listener); view_initialize(&plane->view, &view_impl); return true; }
WL_EXPORT void weston_output_activate_zoom(struct weston_output *output) { struct weston_seat *seat = weston_zoom_pick_seat(output->compositor); if (output->zoom.active) return; output->zoom.active = 1; output->disable_planes++; wl_signal_add(&seat->pointer->motion_signal, &output->zoom.motion_listener); }
static void data_device_start_drag(struct wl_client *client, struct wl_resource *resource, struct wl_resource *source_resource, struct wl_resource *origin_resource, struct wl_resource *icon_resource, uint32_t serial) { struct wl_seat *seat = resource->data; /* FIXME: Check that client has implicit grab on the origin * surface that matches the given time. */ /* FIXME: Check that the data source type array isn't empty. */ seat->drag_grab.interface = &drag_grab_interface; seat->drag_client = client; seat->drag_data_source = NULL; if (source_resource) { seat->drag_data_source = source_resource->data; seat->drag_data_source_listener.notify = destroy_data_device_source; wl_signal_add(&source_resource->destroy_signal, &seat->drag_data_source_listener); } if (icon_resource) { seat->drag_surface = icon_resource->data; seat->drag_icon_listener.notify = destroy_data_device_icon; wl_signal_add(&icon_resource->destroy_signal, &seat->drag_icon_listener); wl_signal_emit(&seat->drag_icon_signal, icon_resource); } wl_pointer_set_focus(seat->pointer, NULL, wl_fixed_from_int(0), wl_fixed_from_int(0)); wl_pointer_start_grab(seat->pointer, &seat->drag_grab); }
bool cursor_plane_initialize(struct cursor_plane * plane, uint32_t crtc, const struct swc_rectangle * origin) { if (drmModeSetCursor(swc.drm->fd, crtc, 0, 0, 0) != 0) return false; plane->origin = origin; plane->crtc = crtc; plane->launch_listener.notify = &handle_launch_event; wl_signal_add(&swc.launch->event_signal, &plane->launch_listener); view_initialize(&plane->view, &view_impl); return true; }
WL_EXPORT int module_init(struct weston_compositor *compositor, int *argc, char *argv[]) { char *watchdog_time_env; struct wl_event_loop *loop; long watchdog_time_conv; struct systemd_notifier *notifier; notifier = zalloc(sizeof *notifier); if (notifier == NULL) return -1; notifier->compositor_destroy_listener.notify = weston_compositor_destroy_listener; wl_signal_add(&compositor->destroy_signal, ¬ifier->compositor_destroy_listener); if (add_systemd_sockets(compositor) < 0) return -1; sd_notify(0, "READY=1"); /* 'WATCHDOG_USEC' is environment variable that is set * by systemd to transfer 'WatchdogSec' watchdog timeout * setting from service file.*/ watchdog_time_env = getenv("WATCHDOG_USEC"); if (!watchdog_time_env) return 0; if (!safe_strtoint(watchdog_time_env, &watchdog_time_conv)) return 0; /* Convert 'WATCHDOG_USEC' to milliseconds and notify * systemd every half of that time.*/ watchdog_time_conv /= 1000 * 2; if (watchdog_time_conv <= 0) return 0; notifier->watchdog_time = watchdog_time_conv; loop = wl_display_get_event_loop(compositor->wl_display); notifier->watchdog_source = wl_event_loop_add_timer(loop, watchdog_handler, notifier); wl_event_source_timer_update(notifier->watchdog_source, notifier->watchdog_time); return 0; }
WL_EXPORT void weston_output_activate_zoom(struct weston_output *output, struct weston_seat *seat) { struct weston_pointer *pointer = weston_seat_get_pointer(seat); if (output->zoom.active) return; output->zoom.active = true; output->zoom.seat = seat; output->disable_planes++; wl_signal_add(&pointer->motion_signal, &output->zoom.motion_listener); }
static void handle_map(struct wl_listener *listener, void *data) { struct sway_xdg_shell_v6_view *xdg_shell_v6_view = wl_container_of(listener, xdg_shell_v6_view, map); struct sway_view *view = &xdg_shell_v6_view->view; struct wlr_xdg_surface_v6 *xdg_surface = view->wlr_xdg_surface_v6; view->natural_width = view->wlr_xdg_surface_v6->geometry.width; view->natural_height = view->wlr_xdg_surface_v6->geometry.height; if (!view->natural_width && !view->natural_height) { view->natural_width = view->wlr_xdg_surface_v6->surface->current.width; view->natural_height = view->wlr_xdg_surface_v6->surface->current.height; } struct sway_server_decoration *deco = decoration_from_surface(xdg_surface->surface); bool csd = !deco || deco->wlr_server_decoration->mode == WLR_SERVER_DECORATION_MANAGER_MODE_CLIENT; view_map(view, view->wlr_xdg_surface_v6->surface, xdg_surface->toplevel->client_pending.fullscreen, csd); transaction_commit_dirty(); xdg_shell_v6_view->commit.notify = handle_commit; wl_signal_add(&xdg_surface->surface->events.commit, &xdg_shell_v6_view->commit); xdg_shell_v6_view->new_popup.notify = handle_new_popup; wl_signal_add(&xdg_surface->events.new_popup, &xdg_shell_v6_view->new_popup); xdg_shell_v6_view->request_fullscreen.notify = handle_request_fullscreen; wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen, &xdg_shell_v6_view->request_fullscreen); xdg_shell_v6_view->request_move.notify = handle_request_move; wl_signal_add(&xdg_surface->toplevel->events.request_move, &xdg_shell_v6_view->request_move); xdg_shell_v6_view->request_resize.notify = handle_request_resize; wl_signal_add(&xdg_surface->toplevel->events.request_resize, &xdg_shell_v6_view->request_resize); xdg_shell_v6_view->set_title.notify = handle_set_title; wl_signal_add(&xdg_surface->toplevel->events.set_title, &xdg_shell_v6_view->set_title); xdg_shell_v6_view->set_app_id.notify = handle_set_app_id; wl_signal_add(&xdg_surface->toplevel->events.set_app_id, &xdg_shell_v6_view->set_app_id); }
static void drag_grab_focus(struct wl_pointer_grab *grab, struct wl_surface *surface, wl_fixed_t x, wl_fixed_t y) { struct wl_seat *seat = container_of(grab, struct wl_seat, drag_grab); struct wl_resource *resource, *offer = NULL; struct wl_display *display; uint32_t serial; if (seat->drag_focus_resource) { wl_data_device_send_leave(seat->drag_focus_resource); wl_list_remove(&seat->drag_focus_listener.link); seat->drag_focus_resource = NULL; seat->drag_focus = NULL; } if (!surface) return; if (!seat->drag_data_source && surface->resource.client != seat->drag_client) return; resource = find_resource(&seat->drag_resource_list, surface->resource.client); if (!resource) return; display = wl_client_get_display(resource->client); serial = wl_display_next_serial(display); if (seat->drag_data_source) offer = wl_data_source_send_offer(seat->drag_data_source, resource); wl_data_device_send_enter(resource, serial, &surface->resource, x, y, offer); seat->drag_focus = surface; seat->drag_focus_listener.notify = destroy_drag_focus; wl_signal_add(&resource->destroy_signal, &seat->drag_focus_listener); seat->drag_focus_resource = resource; grab->focus = surface; }
void weston_timeline_open(struct weston_compositor *compositor) { if (weston_timeline_enabled_) return; if (weston_timeline_do_open() < 0) return; timeline_.compositor_destroy_listener.notify = timeline_notify_destroy; wl_signal_add(&compositor->destroy_signal, &timeline_.compositor_destroy_listener); if (++timeline_.series == 0) ++timeline_.series; weston_timeline_enabled_ = 1; }
void SurfaceBuffer::initialize(struct ::wl_resource *buffer) { m_buffer = buffer; m_committed = false; m_is_registered_for_buffer = true; m_surface_has_buffer = true; m_is_displayed = false; m_destroyed = false; m_destroy_listener.surfaceBuffer = this; m_destroy_listener.listener.notify = destroy_listener_callback; if (buffer) { #ifdef QT_WAYLAND_COMPOSITOR_GL if (ClientBufferIntegration *integration = QWaylandCompositorPrivate::get(m_compositor)->clientBufferIntegration()) integration->initializeBuffer(buffer); #endif wl_signal_add(&buffer->destroy_signal, &m_destroy_listener.listener); } }
WL_EXPORT void wl_seat_set_selection(struct wl_seat *seat, struct wl_data_source *source, uint32_t serial) { struct wl_resource *data_device, *offer; struct wl_resource *focus = NULL; if (seat->selection_data_source && seat->selection_serial - serial < UINT32_MAX / 2) return; if (seat->selection_data_source) { seat->selection_data_source->cancel(seat->selection_data_source); wl_list_remove(&seat->selection_data_source_listener.link); seat->selection_data_source = NULL; } seat->selection_data_source = source; seat->selection_serial = serial; if (seat->keyboard) focus = seat->keyboard->focus_resource; if (focus) { data_device = find_resource(&seat->drag_resource_list, focus->client); if (data_device && source) { offer = wl_data_source_send_offer(seat->selection_data_source, data_device); wl_data_device_send_selection(data_device, offer); } else if (data_device) { wl_data_device_send_selection(data_device, NULL); } } wl_signal_emit(&seat->selection_signal, seat); if (source) { seat->selection_data_source_listener.notify = destroy_selection_data_source; wl_signal_add(&source->resource.destroy_signal, &seat->selection_data_source_listener); } }
void SurfaceBuffer::initialize(struct ::wl_resource *buffer) { m_buffer = buffer; m_texture = 0; m_committed = false; m_is_registered_for_buffer = true; m_surface_has_buffer = true; m_is_displayed = false; m_destroyed = false; m_handle = 0; m_is_shm_resolved = false; m_shmBuffer = 0; m_isSizeResolved = false; m_size = QSize(); m_destroy_listener.surfaceBuffer = this; m_destroy_listener.listener.notify = destroy_listener_callback; if (buffer) wl_signal_add(&buffer->destroy_signal, &m_destroy_listener.listener); m_damageRect = QRect(); }