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

static void gfx_ctx_wl_destroy_resources(gfx_ctx_wayland_data_t *wl){   if (!wl)      return;   switch (wl_api)   {      case GFX_CTX_OPENGL_API:      case GFX_CTX_OPENGL_ES_API:      case GFX_CTX_OPENVG_API:#ifdef HAVE_EGL         egl_destroy(&wl->egl);         if (wl->win)            wl_egl_window_destroy(wl->win);#endif         break;      case GFX_CTX_VULKAN_API:#ifdef HAVE_VULKAN         vulkan_context_destroy(&wl->vk, wl->surface);         if (wl->fd >= 0)            close(wl->fd);#endif         break;      case GFX_CTX_NONE:      default:         break;   }   if (wl->shell)      wl_shell_destroy(wl->shell);   if (wl->compositor)      wl_compositor_destroy(wl->compositor);   if (wl->registry)      wl_registry_destroy(wl->registry);   if (wl->shell_surf)      wl_shell_surface_destroy(wl->shell_surf);   if (wl->surface)      wl_surface_destroy(wl->surface);   if (wl->dpy)   {      wl_display_flush(wl->dpy);      wl_display_disconnect(wl->dpy);   }#ifdef HAVE_EGL   wl->win        = NULL;#endif   wl->shell      = NULL;   wl->compositor = NULL;   wl->registry   = NULL;   wl->dpy        = NULL;   wl->shell_surf = NULL;   wl->surface    = NULL;   wl->width      = 0;   wl->height     = 0;}

bool WaylandBackend::available() const{    wl_display* dpy = wl_display_connect(nullptr);    if(!dpy) return false;    wl_display_disconnect(dpy);    return true;}

NativeStateWayland::~NativeStateWayland(){    if (window_) {        if (window_->shell_surface)            wl_shell_surface_destroy(window_->shell_surface);        if (window_->opaque_reqion)            wl_region_destroy(window_->opaque_reqion);        if (window_->surface)            wl_surface_destroy(window_->surface);        if (window_->native)            wl_egl_window_destroy(window_->native);        delete window_;    }    if (display_) {        if (display_->shell)            wl_shell_destroy(display_->shell);        for (OutputsVector::iterator it = display_->outputs.begin();             it != display_->outputs.end(); ++it) {            wl_output_destroy((*it)->output);            delete *it;        }        if (display_->compositor)            wl_compositor_destroy(display_->compositor);        if (display_->registry)            wl_registry_destroy(display_->registry);        if (display_->display) {            wl_display_flush(display_->display);            wl_display_disconnect(display_->display);        }        delete display_;    }}

static voidgst_gl_window_wayland_egl_close (GstGLWindow * window){  GstGLWindowWaylandEGL *window_egl;  window_egl = GST_GL_WINDOW_WAYLAND_EGL (window);  destroy_surface (window_egl);  if (window_egl->display.cursor_surface)    wl_surface_destroy (window_egl->display.cursor_surface);  if (window_egl->display.cursor_theme)    wl_cursor_theme_destroy (window_egl->display.cursor_theme);  if (window_egl->display.shell)    wl_shell_destroy (window_egl->display.shell);  if (window_egl->display.compositor)    wl_compositor_destroy (window_egl->display.compositor);  if (window_egl->display.display) {    wl_display_flush (window_egl->display.display);    wl_display_disconnect (window_egl->display.display);  }}

WaylandDisplay::~WaylandDisplay(){    if (m_eventSource)        g_source_unref(m_eventSource);    m_eventSource = nullptr;    if (m_interfaces.compositor)        wl_compositor_destroy(m_interfaces.compositor);    if (m_interfaces.drm)        wl_drm_destroy(m_interfaces.drm);    if (m_interfaces.seat)        wl_seat_destroy(m_interfaces.seat);    if (m_interfaces.xdg)        xdg_shell_destroy(m_interfaces.xdg);    if (m_interfaces.ivi_application)        ivi_application_destroy(m_interfaces.ivi_application);    m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr };    if (m_registry)        wl_registry_destroy(m_registry);    m_registry = nullptr;    if (m_display)        wl_display_disconnect(m_display);    m_display = nullptr;}

int main(int argc, char **argv){    get_server_references();    surface = wl_compositor_create_surface(compositor);    if (surface == NULL) {        fprintf(stderr, "Can't create surface/n");        exit(1);    } else {        fprintf(stderr, "Created surface/n");    }    shell_surface = wl_shell_get_shell_surface(shell, surface);    wl_shell_surface_set_toplevel(shell_surface);//    create_opaque_region();    init_egl();    create_window();    init_gl();    while (1) {        draw();        if (eglSwapBuffers(egl_display, egl_surface)) {            fprintf(stderr, "Swapped buffers/n");       } else {        fprintf(stderr, "Swapped buffers failed/n");    }    }    wl_display_disconnect(display);    printf("disconnected from display/n");    exit(0);}

static voidsanity_client_no_leak(void){	struct wl_display *display = wl_display_connect(NULL);	assert(display);	wl_display_disconnect(display);}

bool WL_destroy() {    wl_registry_destroy(_WL_display.registry);    NWMan_events_destroy();    wl_display_flush(_WL_display.display);    wl_display_disconnect(_WL_display.display);    return true;}

void client_finalize(struct registry *reg){	wl_shm_destroy(reg->shm);	wl_compositor_destroy(reg->compositor);	wl_display_disconnect(reg->display);	free(reg);	//the last memory management is users job}

/*virtual*/ Display::~Display(){	if (xkbContext_)	{		xkb_context_unref(xkbContext_);	}	wl_registry_destroy(wl_registry_);	wl_display_disconnect(*this);}

PlatformDisplayWayland::~PlatformDisplayWayland(){    if (m_compositor)        wl_compositor_destroy(m_compositor);    if (m_registry)        wl_registry_destroy(m_registry);    if (m_display)        wl_display_disconnect(m_display);}

voidp_cleanup(){	assert(g_wl_compositor != NULL);	assert(g_wl_shell != NULL);	assert(g_wl_shm != NULL);	assert(g_wl_display != NULL);	wl_display_disconnect(g_wl_display);}

void hello_cleanup_wayland(void){    wl_pointer_destroy(pointer);    wl_seat_destroy(seat);    wl_shell_destroy(shell);    wl_shm_destroy(shm);    wl_compositor_destroy(compositor);    wl_display_disconnect(display);}

static voidgst_wl_display_finalize (GObject * gobject){  GstWlDisplay *self = GST_WL_DISPLAY (gobject);  gst_poll_set_flushing (self->wl_fd_poll, TRUE);  if (self->thread)    g_thread_join (self->thread);  /* to avoid buffers being unregistered from another thread   * at the same time, take their ownership */  g_mutex_lock (&self->buffers_mutex);  self->shutting_down = TRUE;  g_hash_table_foreach (self->buffers, (GHFunc) g_object_ref, NULL);  g_mutex_unlock (&self->buffers_mutex);  g_hash_table_foreach (self->buffers,      (GHFunc) gst_wl_buffer_force_release_and_unref, NULL);  g_hash_table_remove_all (self->buffers);  g_array_unref (self->shm_formats);  g_array_unref (self->dmabuf_formats);  gst_poll_free (self->wl_fd_poll);  g_hash_table_unref (self->buffers);  g_mutex_clear (&self->buffers_mutex);  if (self->viewporter)    wp_viewporter_destroy (self->viewporter);  if (self->shm)    wl_shm_destroy (self->shm);  if (self->dmabuf)    zwp_linux_dmabuf_v1_destroy (self->dmabuf);  if (self->shell)    wl_shell_destroy (self->shell);  if (self->compositor)    wl_compositor_destroy (self->compositor);  if (self->subcompositor)    wl_subcompositor_destroy (self->subcompositor);  if (self->registry)    wl_registry_destroy (self->registry);  if (self->queue)    wl_event_queue_destroy (self->queue);  if (self->own_display) {    wl_display_flush (self->display);    wl_display_disconnect (self->display);  }  G_OBJECT_CLASS (gst_wl_display_parent_class)->finalize (gobject);}

int main(int argc, char **argv) {    display = wl_display_connect(NULL);    if (display == NULL) {        fprintf(stderr, "Can't connect to display/n");        exit(1);    }    printf("connected to display/n");    struct wl_registry *registry = wl_display_get_registry(display);    wl_registry_add_listener(registry, &registry_listener, NULL);    wl_display_dispatch(display);    wl_display_roundtrip(display);    if (compositor == NULL) {        fprintf(stderr, "Can't find compositor/n");        exit(1);    } else {        fprintf(stderr, "Found compositor/n");    }    surface = wl_compositor_create_surface(compositor);    if (surface == NULL) {        fprintf(stderr, "Can't create surface/n");        exit(1);    } else {        fprintf(stderr, "Created surface/n");    }    shell_surface = wl_shell_get_shell_surface(shell, surface);    if (shell_surface == NULL) {        fprintf(stderr, "Can't create shell surface/n");        exit(1);    } else {        fprintf(stderr, "Created shell surface/n");    }    wl_shell_surface_set_toplevel(shell_surface);    wl_shell_surface_add_listener(shell_surface,                                  &shell_surface_listener, NULL);    create_window();    paint_pixels();    while (wl_display_dispatch(display) != -1) {        ;    }    wl_display_disconnect(display);    printf("disconnected from display/n");    exit(0);}

void fgPlatformCloseDisplay ( void ){    wl_cursor_theme_destroy( fgDisplay.pDisplay.cursor_theme );    wl_shm_destroy( fgDisplay.pDisplay.shm );    wl_seat_destroy( fgDisplay.pDisplay.seat );    wl_shell_destroy( fgDisplay.pDisplay.shell );    wl_compositor_destroy( fgDisplay.pDisplay.compositor );    wl_registry_destroy( fgDisplay.pDisplay.registry );    wl_display_disconnect( fgDisplay.pDisplay.display );}

TestBase::~TestBase(){    for (std::vector<wl_surface *>::reverse_iterator it = wlSurfaces.rbegin();         it != wlSurfaces.rend();         ++it)    {        wl_surface_destroy(*it);    }    wlSurfaces.clear();    wl_compositor_destroy(wlCompositor);    wl_registry_destroy(wlRegistry);    wl_display_disconnect(wlDisplay);}

int main(int argc, char **argv) {	display = wl_display_connect(NULL);	if (display == NULL) {		fprintf(stderr, "Can't connect to display/n");		exit(1);	}	printf("connected to display/n");	wl_display_disconnect(display);	printf("disconnected from display/n");	exit(0);}

intmain(int argc, char **argv){	struct sigaction sigint;	struct display display = { 0 };	struct window  window  = { 0 };	window.display = &display;	window.geometry.width  = 250;	window.geometry.height = 250;	display.display = wl_display_connect(NULL);	assert(display.display);	wl_display_add_global_listener(display.display,				       display_handle_global, &display);	wl_display_get_fd(display.display, event_mask_update, &display);	wl_display_iterate(display.display, WL_DISPLAY_READABLE);	init_egl(&display);	create_surface(&window);	init_gl(&window);	sigint.sa_handler = signal_int;	sigemptyset(&sigint.sa_mask);	sigint.sa_flags = SA_RESETHAND;	sigaction(SIGINT, &sigint, NULL);	redraw(&window, NULL, 0);	while (running)		wl_display_iterate(display.display, display.mask);	fprintf(stderr, "simple-egl exiting/n");	destroy_surface(&window);	fini_egl(&display);	if (display.shell)		wl_shell_destroy(display.shell);	if (display.compositor)		wl_compositor_destroy(display.compositor);	wl_display_flush(display.display);	wl_display_disconnect(display.display);	return 0;}

static void Close(vlc_object_t *obj){    demux_t *demux = (demux_t *)obj;    demux_sys_t *sys = demux->p_sys;    vlc_cancel(sys->thread);    vlc_join(sys->thread, NULL);    screenshooter_destroy(sys->screenshooter);    wl_shm_destroy(sys->shm);    wl_output_destroy(sys->output);    wl_display_disconnect(sys->display);    free(sys);}

static void Wayland_MainLoop(){	// Wait for display to be initialized	while (!GLWin.wl_display)		usleep(20000);	GLWin.running = 1;	while (GLWin.running)		wl_display_dispatch(GLWin.wl_display);	if (GLWin.wl_display)		wl_display_disconnect(GLWin.wl_display);}

void _glfwPlatformTerminate(void){    _glfwTerminateContextAPI();    if (_glfw.wl.cursorTheme)        wl_cursor_theme_destroy(_glfw.wl.cursorTheme);    if (_glfw.wl.cursorSurface)        wl_surface_destroy(_glfw.wl.cursorSurface);    if (_glfw.wl.registry)        wl_registry_destroy(_glfw.wl.registry);    if (_glfw.wl.display)        wl_display_flush(_glfw.wl.display);    if (_glfw.wl.display)        wl_display_disconnect(_glfw.wl.display);}

static gpointeris_wayland_session (gpointer user_data){#if HAVE_WAYLAND        struct wl_display *display;        display = wl_display_connect (NULL);        if (!display)                return GUINT_TO_POINTER(FALSE);        wl_display_disconnect (display);        return GUINT_TO_POINTER(TRUE);#else        return GUINT_TO_POINTER(FALSE);#endif}

static voiddestroy_display (struct display *display){  if (display->shm)    wl_shm_destroy (display->shm);  if (display->shell)    wl_shell_destroy (display->shell);  if (display->compositor)    wl_compositor_destroy (display->compositor);  wl_display_flush (display->display);  wl_display_disconnect (display->display);  free (display);}

WaylandDisplay::~WaylandDisplay(){    if (m_eventSource)        g_source_unref(m_eventSource);    m_eventSource = nullptr;    if (m_interfaces.compositor)        wl_compositor_destroy(m_interfaces.compositor);    if (m_interfaces.data_device_manager)        wl_data_device_manager_destroy(m_interfaces.data_device_manager);    if (m_interfaces.drm)        wl_drm_destroy(m_interfaces.drm);    if (m_interfaces.seat)        wl_seat_destroy(m_interfaces.seat);    if (m_interfaces.xdg)        xdg_shell_destroy(m_interfaces.xdg);    if (m_interfaces.ivi_application)        ivi_application_destroy(m_interfaces.ivi_application);    m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };    if (m_registry)        wl_registry_destroy(m_registry);    m_registry = nullptr;    if (m_display)        wl_display_disconnect(m_display);    m_display = nullptr;    if (m_seatData.pointer.object)        wl_pointer_destroy(m_seatData.pointer.object);    if (m_seatData.keyboard.object)        wl_keyboard_destroy(m_seatData.keyboard.object);    if (m_seatData.touch.object)        wl_touch_destroy(m_seatData.touch.object);    if (m_seatData.xkb.context)        xkb_context_unref(m_seatData.xkb.context);    if (m_seatData.xkb.keymap)        xkb_keymap_unref(m_seatData.xkb.keymap);    if (m_seatData.xkb.state)        xkb_state_unref(m_seatData.xkb.state);    if (m_seatData.xkb.composeTable)        xkb_compose_table_unref(m_seatData.xkb.composeTable);    if (m_seatData.xkb.composeState)        xkb_compose_state_unref(m_seatData.xkb.composeState);    if (m_seatData.repeatData.eventSource)        g_source_remove(m_seatData.repeatData.eventSource);    m_seatData = SeatData{ };}

static voidcursor_viewer_destroy(struct cursor_viewer *viewer){    if (viewer->cursor_theme)        wl_cursor_theme_destroy(viewer->cursor_theme);    if (viewer->shell)        wl_shell_destroy(viewer->shell);    if (viewer->compositor)        wl_compositor_destroy(viewer->compositor);    if (viewer->shm)        wl_shm_destroy(viewer->shm);    if (viewer->registry)        wl_registry_destroy(viewer->registry);    if (viewer->display)        wl_display_disconnect(viewer->display);    free(viewer);}

/** * Destroys a Wayland shell surface. */static void Close(vout_window_t *wnd){    vout_window_sys_t *sys = wnd->sys;    vlc_cancel(sys->thread);    vlc_join(sys->thread, NULL);    wl_shell_surface_destroy(sys->shell_surface);    wl_surface_destroy(wnd->handle.wl);    wl_shell_destroy(sys->shell);    if (sys->output != NULL)        wl_output_destroy(sys->output);    wl_compositor_destroy(sys->compositor);    wl_display_disconnect(wnd->display.wl);    vlc_mutex_destroy(&sys->lock);    free(sys);}

static voidnested_client_destroy(struct nested_client *client){  eglMakeCurrent(client->egl_display,                 EGL_NO_SURFACE, EGL_NO_SURFACE,                 EGL_NO_CONTEXT);  wl_egl_window_destroy(client->native);  wl_surface_destroy(client->surface);  if (client->compositor)    wl_compositor_destroy(client->compositor);  wl_registry_destroy(client->registry);  wl_display_flush(client->display);  wl_display_disconnect(client->display);}

static voidleak_after_error(void){	struct client *c = client_connect();	/* this should return -1, because we'll send error	 * from server. */	assert(stop_display(c, 1) == -1);	assert(wl_display_dispatch_pending(c->wl_display) == -1);	assert(wl_display_get_error(c->wl_display) == ENOMEM);	/* after we got error, we have display_resume event	 * in the queue. It should be freed in wl_display_disconnect().	 * Let's see! */	wl_proxy_destroy((struct wl_proxy *) c->tc);	wl_display_disconnect(c->wl_display);	free(c);}

static voiddestroy_display(struct display *display){	if (display->dmabuf)		zwp_linux_dmabuf_v1_destroy(display->dmabuf);	if (display->shell)		xdg_shell_destroy(display->shell);	if (display->fshell)		zwp_fullscreen_shell_v1_release(display->fshell);	if (display->compositor)		wl_compositor_destroy(display->compositor);	wl_registry_destroy(display->registry);	wl_display_flush(display->display);	wl_display_disconnect(display->display);	free(display);}