自学教程：C++ wl_container_of函数代码示例

/* This is a basic grid arrange function that tries to give each window an * equal space. */static voidarrange(struct screen *screen){	struct window *window = NULL;	unsigned num_columns, num_rows, column_index, row_index;	struct swc_rectangle geometry;	struct swc_rectangle *screen_geometry = &screen->swc->usable_geometry;	if (screen->num_windows == 0)		return;	num_columns = ceil(sqrt(screen->num_windows));	num_rows = screen->num_windows / num_columns + 1;	window = wl_container_of(screen->windows.next, window, link);	for (column_index = 0; &window->link != &screen->windows; ++column_index) {		geometry.x = screen_geometry->x + border_width		             + screen_geometry->width * column_index / num_columns;		geometry.width = screen_geometry->width / num_columns		                 - 2 * border_width;		if (column_index == screen->num_windows % num_columns)			--num_rows;		for (row_index = 0; row_index < num_rows; ++row_index) {			geometry.y = screen_geometry->y + border_width			             + screen_geometry->height * row_index / num_rows;			geometry.height = screen_geometry->height / num_rows			                  - 2 * border_width;			swc_window_set_geometry(window->swc, &geometry);			window = wl_container_of(window->link.next, window, link);		}	}}

static voidpointer_handle_focus_surface_destroy (struct wl_listener *listener, void *data){  MetaWaylandPointer *pointer = wl_container_of (listener, pointer, focus_surface_listener);  meta_wayland_pointer_set_focus (pointer, NULL);}

static void handle_buffer_destroy(struct wld_destructor * destructor){    struct pool_reference * reference        = wl_container_of(destructor, reference, destructor);    unref_pool(reference->pool);}

static void handle_set_title(struct wl_listener *listener, void *data) {	struct sway_xdg_shell_v6_view *xdg_shell_v6_view =		wl_container_of(listener, xdg_shell_v6_view, set_title);	struct sway_view *view = &xdg_shell_v6_view->view;	view_update_title(view, false);	view_execute_criteria(view);}

static void handle_resize(struct view_handler * handler,                          uint32_t old_width, uint32_t old_height){    struct panel * panel = wl_container_of(handler, panel, view_handler);    update_position(panel);}

static int attach(struct view * view, struct wld_buffer * buffer){    struct cursor_plane * plane = wl_container_of(view, plane, view);    if (buffer)    {        union wld_object object;        if (!wld_export(buffer, WLD_DRM_OBJECT_HANDLE, &object))        {            ERROR("Could not get export buffer to DRM handle/n");            /* XXX: Not the best error code, but we don't know better until wld             * returns an actual error code. */            return -EINVAL;        }        if (swc.active && drmModeSetCursor(swc.drm->fd, plane->crtc, object.u32,                                           buffer->width, buffer->height) < 0)        {            ERROR("Could not set cursor: %s/n", strerror(errno));            return -errno;        }    }    else if (swc.active && drmModeSetCursor(swc.drm->fd, plane->crtc,                                            0, 0, 0) < 0)    {        ERROR("Could not unset cursor: %s/n", strerror(errno));        return -errno;    }    view_set_size_from_buffer(view, buffer);    return 0;}

static voiddestroy_drag_focus (struct wl_listener *listener, void *data){  MetaWaylandDragGrab *grab = wl_container_of (listener, grab, drag_focus_listener);  grab->drag_focus_data_device = NULL;}

static CoglandBuffer *cogland_buffer_from_resource (struct wl_resource *resource){  CoglandBuffer *buffer;  struct wl_listener *listener;  listener = wl_resource_get_destroy_listener (resource,                                               cogland_buffer_destroy_handler);  if (listener)    {      buffer = wl_container_of (listener, buffer, destroy_listener);    }  else    {      buffer = g_slice_new0 (CoglandBuffer);      buffer->resource = resource;      wl_signal_init (&buffer->destroy_signal);      buffer->destroy_listener.notify = cogland_buffer_destroy_handler;      wl_resource_add_destroy_listener (resource, &buffer->destroy_listener);    }  return buffer;}

MetaWaylandBuffer *meta_wayland_buffer_from_resource (struct wl_resource *resource){  MetaWaylandBuffer *buffer;  struct wl_listener *listener;  listener =    wl_resource_get_destroy_listener (resource,                                      meta_wayland_buffer_destroy_handler);  if (listener)    {      buffer = wl_container_of (listener, buffer, destroy_listener);    }  else    {      buffer = g_object_new (META_TYPE_WAYLAND_BUFFER, NULL);      buffer->resource = resource;      buffer->destroy_listener.notify = meta_wayland_buffer_destroy_handler;      wl_resource_add_destroy_listener (resource, &buffer->destroy_listener);    }  return buffer;}

QWaylandClient *QWaylandClient::fromWlClient(wl_client *wlClient){    if (!wlClient)        return 0;    QWaylandClient *client = Q_NULLPTR;    wl_listener *l = wl_client_get_destroy_listener(wlClient,        QWaylandClientPrivate::client_destroy_callback);    if (l)        client = reinterpret_cast<QWaylandClientPrivate::Listener *>(            wl_container_of(l, (QWaylandClientPrivate::Listener *)0, listener))->parent;    if (!client) {        // The original idea was to create QWaylandClient instances when        // a client bound wl_compositor, but it's legal for a client to        // bind several times resulting in multiple QWaylandClient        // instances for the same wl_client therefore we create it from        // here on demand        client = new QWaylandClient(wlClient);        QtWayland::Compositor::instance()->m_clients.append(client);    }    return client;}

static intlauncher_logind_activate_vt(struct weston_launcher *launcher, int vt){	struct launcher_logind *wl = wl_container_of(launcher, wl, base);	DBusMessage *m;	bool b;	int r;	m = dbus_message_new_method_call("org.freedesktop.login1",					 "/org/freedesktop/login1/seat/self",					 "org.freedesktop.login1.Seat",					 "SwitchTo");	if (!m)		return -ENOMEM;	b = dbus_message_append_args(m,				     DBUS_TYPE_UINT32, &vt,				     DBUS_TYPE_INVALID);	if (!b) {		r = -ENOMEM;		goto err_unref;	}	dbus_connection_send(wl->dbus, m, NULL);	r = 0; err_unref:	dbus_message_unref(m);	return r;}

static intlauncher_direct_open(struct weston_launcher *launcher_base, const char *path, int flags){	struct launcher_direct *launcher = wl_container_of(launcher_base, launcher, base);	struct stat s;	int fd;	fd = open(path, flags | O_CLOEXEC);	if (fd == -1)		return -1;	if (fstat(fd, &s) == -1) {		close(fd);		return -1;	}	if (major(s.st_rdev) == DRM_MAJOR) {		launcher->drm_fd = fd;		if (!is_drm_master(fd)) {			weston_log("drm fd not master/n");			close(fd);			return -1;		}	}	return fd;}

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 handle_commit(struct wl_listener *listener, void *data) {	struct sway_xdg_shell_v6_view *xdg_shell_v6_view =		wl_container_of(listener, xdg_shell_v6_view, commit);	struct sway_view *view = &xdg_shell_v6_view->view;	struct wlr_xdg_surface_v6 *xdg_surface_v6 = view->wlr_xdg_surface_v6;	if (view->container->node.instruction) {		wlr_xdg_surface_v6_get_geometry(xdg_surface_v6, &view->geometry);		transaction_notify_view_ready_by_serial(view,				xdg_surface_v6->configure_serial);	} else {		struct wlr_box new_geo;		wlr_xdg_surface_v6_get_geometry(xdg_surface_v6, &new_geo);		struct sway_container *con = view->container;		if ((new_geo.width != con->surface_width ||					new_geo.height != con->surface_height)) {			// The view has unexpectedly sent a new size			desktop_damage_view(view);			view_update_size(view, new_geo.width, new_geo.height);			memcpy(&view->geometry, &new_geo, sizeof(struct wlr_box));			desktop_damage_view(view);			transaction_commit_dirty();		} else {			memcpy(&view->geometry, &new_geo, sizeof(struct wlr_box));		}	}	view_damage_from(view);}

/* Tall layout */static voidtall_next_col(struct col *col){	struct tall_layout *layout = wl_container_of(col, layout, grid.col);	grid(&layout->grid, &layout->grid_area, layout->grid.num_windows,	     MIN(layout->grid.num_windows, layout->num_columns));}

static void toggle(struct config_node * node){    struct tag * tag = wl_container_of(node, tag, config.toggle);    struct screen * screen = velox.active_screen;    screen_set_tags(velox.active_screen, screen->mask ^ tag->mask);    update();}

static voidpointer_handle_cursor_surface_destroy (struct wl_listener *listener, void *data){  MetaWaylandPointer *pointer = wl_container_of (listener, pointer, cursor_surface_destroy_listener);  set_cursor_surface (pointer, NULL);  meta_wayland_pointer_update_cursor_surface (pointer);}

static voidweston_desktop_seat_destroy(struct wl_listener *listener, void *data){	struct weston_desktop_seat *seat =		wl_container_of(listener, seat, seat_destroy_listener);	free(seat);}

static voidweston_desktop_seat_popup_grab_keyboard_cancel(struct weston_keyboard_grab *grab){	struct weston_desktop_seat *seat =		wl_container_of(grab, seat, popup_grab.keyboard);	weston_desktop_seat_popup_grab_end(seat);}

static voidweston_desktop_seat_popup_grab_pointer_cancel(struct weston_pointer_grab *grab){	struct weston_desktop_seat *seat =		wl_container_of(grab, seat, popup_grab.pointer);	weston_desktop_seat_popup_grab_end(seat);}

static voidkeyboard_surface_destroyed(struct wl_listener *listener, void *data){	struct wlb_keyboard *keyboard =		wl_container_of(listener, keyboard, surface_destroy_listener);	wlb_keyboard_set_focus(keyboard, NULL);}

static voidweston_desktop_seat_popup_grab_touch_cancel(struct weston_touch_grab *grab){	struct weston_desktop_seat *seat =		wl_container_of(grab, seat, popup_grab.touch);	weston_desktop_seat_popup_grab_end(seat);}

static voidpointer_handle_sprite_destroy (struct wl_listener *listener, void *data){  ClaylandSeat *seat =    wl_container_of (listener, seat, sprite_destroy_listener);  seat->sprite = NULL;}

static voidcogland_buffer_destroy_handler (struct wl_listener *listener,                                void *data){  CoglandBuffer *buffer = wl_container_of (listener, buffer, destroy_listener);  wl_signal_emit (&buffer->destroy_signal, buffer);  g_slice_free (CoglandBuffer, buffer);}

static void apply(struct config_node * node){    struct tag * tag = wl_container_of(node, tag, config.apply);    struct window * window = velox.active_screen->focus;    if (window)        window_set_tag(window, tag);    update();}

static voiddestroy_data_device_source (struct wl_listener *listener, void *data){  MetaWaylandDragGrab *drag_grab =    wl_container_of (listener, drag_grab, drag_data_source_listener);  drag_grab->drag_data_source = NULL;  data_device_end_drag_grab (drag_grab);}

static voiddestroy_selection_data_source (struct wl_listener *listener, void *data){  MetaWaylandDataDevice *data_device = wl_container_of (listener, data_device, selection_data_source_listener);  MetaWaylandSeat *seat = wl_container_of (data_device, seat, data_device);  struct wl_resource *data_device_resource;  struct wl_client *focus_client = NULL;  data_device->selection_data_source = NULL;  focus_client = meta_wayland_keyboard_get_focus_client (&seat->keyboard);  if (focus_client)    {      data_device_resource = wl_resource_find_for_client (&data_device->resource_list, focus_client);      if (data_device_resource)        wl_data_device_send_selection (data_device_resource, NULL);    }}

static voiddestroy_offer_data_source (struct wl_listener *listener, void *data){  MetaWaylandDataOffer *offer;  offer = wl_container_of (listener, offer, source_destroy_listener);  offer->source = NULL;}

static voidsurface_handle_pending_buffer_destroy (struct wl_listener *listener,                                       void *data){  CoglandSurface *surface =    wl_container_of (listener, surface, pending.buffer_destroy_listener);  surface->pending.buffer = NULL;}

static void activate(struct config_node * node){    struct tag * tag = wl_container_of(node, tag, config.activate);    struct screen * screen = velox.active_screen;    screen->last_mask = screen->mask;    screen_set_tags(screen, tag->mask);    update();}