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

static voidgst_wl_window_finalize (GObject * gobject){  GstWlWindow *self = GST_WL_WINDOW (gobject);  if (self->shell_surface)    wl_shell_surface_destroy (self->shell_surface);  if (self->video_viewport)    wp_viewport_destroy (self->video_viewport);  wl_proxy_wrapper_destroy (self->video_surface_wrapper);  wl_subsurface_destroy (self->video_subsurface);  wl_surface_destroy (self->video_surface);  if (self->area_subsurface)    wl_subsurface_destroy (self->area_subsurface);  if (self->area_viewport)    wp_viewport_destroy (self->area_viewport);  wl_proxy_wrapper_destroy (self->area_surface_wrapper);  wl_surface_destroy (self->area_surface);  g_clear_object (&self->display);  G_OBJECT_CLASS (gst_wl_window_parent_class)->finalize (gobject);}

/* * Closes a window, destroying the frame and OpenGL context */void fgPlatformCloseWindow( SFG_Window* window ){    fghPlatformCloseWindowEGL(window);    if ( window->Window.pContext.egl_window )      wl_egl_window_destroy( window->Window.pContext.egl_window );    if ( window->Window.pContext.shsurface )      wl_shell_surface_destroy( window->Window.pContext.shsurface );    if ( window->Window.pContext.surface )      wl_surface_destroy( window->Window.pContext.surface );    if ( window->Window.pContext.cursor_surface )      wl_surface_destroy( window->Window.pContext.cursor_surface );}

void_ecore_wl_window_semi_free(Ecore_Wl2_Window *window){   if (window->zxdg_popup) zxdg_popup_v6_destroy(window->zxdg_popup);   window->zxdg_popup = NULL;   if (window->zxdg_toplevel) zxdg_toplevel_v6_destroy(window->zxdg_toplevel);   window->zxdg_toplevel = NULL;   if (window->zxdg_surface) zxdg_surface_v6_destroy(window->zxdg_surface);   window->zxdg_surface = NULL;   if (window->xdg_surface) xdg_surface_destroy(window->xdg_surface);   window->xdg_surface = NULL;   if (window->xdg_popup) xdg_popup_destroy(window->xdg_popup);   window->xdg_popup = NULL;   if (window->www_surface)     www_surface_destroy(window->www_surface);   window->www_surface = NULL;   if (window->surface) wl_surface_destroy(window->surface);   window->surface = NULL;   window->surface_id = -1;}

static void_cogl_winsys_egl_cleanup_context (CoglDisplay *display){  CoglRenderer *renderer = display->renderer;  CoglRendererEGL *egl_renderer = renderer->winsys;  CoglDisplayEGL *egl_display = display->winsys;  CoglDisplayWayland *wayland_display = egl_display->platform;  if (egl_display->dummy_surface != EGL_NO_SURFACE)    {      eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface);      egl_display->dummy_surface = EGL_NO_SURFACE;    }  if (wayland_display->dummy_wayland_egl_native_window)    {      wl_egl_window_destroy (wayland_display->dummy_wayland_egl_native_window);      wayland_display->dummy_wayland_egl_native_window = NULL;    }  if (wayland_display->dummy_wayland_surface)    {      wl_surface_destroy (wayland_display->dummy_wayland_surface);      wayland_display->dummy_wayland_surface = NULL;    }}

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;}

struct wl_shell_surface *hello_create_surface(void){    struct wl_surface *surface;    struct wl_shell_surface *shell_surface;    surface = wl_compositor_create_surface(compositor);    if (surface == NULL)        return NULL;    shell_surface = wl_shell_get_shell_surface(shell, surface);    if (shell_surface == NULL) {        wl_surface_destroy(surface);        return NULL;    }    wl_shell_surface_add_listener(shell_surface,        &shell_surface_listener, 0);    wl_shell_surface_set_toplevel(shell_surface);    wl_shell_surface_set_user_data(shell_surface, surface);    wl_surface_set_user_data(surface, NULL);    return shell_surface;}

void hello_set_cursor_from_pool(struct wl_shm_pool *pool,    unsigned width, unsigned height,    int32_t hot_spot_x, int32_t hot_spot_y){    struct pointer_data *data;    data = malloc(sizeof(struct pointer_data));    if (data == NULL)        goto error;    data->hot_spot_x = hot_spot_x;    data->hot_spot_y = hot_spot_y;    data->surface = wl_compositor_create_surface(compositor);    if (data->surface == NULL)        goto cleanup_alloc;    data->buffer = hello_create_buffer(pool, width, height);    if (data->buffer == NULL)        goto cleanup_surface;    wl_pointer_set_user_data(pointer, data);    return;cleanup_surface:    wl_surface_destroy(data->surface);cleanup_alloc:    free(data);error:    perror("Unable to allocate cursor");}

void cWaylandInterface::DestroyWindow(void){	wl_egl_window_destroy(GLWin.wl_egl_native);	wl_shell_surface_destroy(GLWin.wl_shell_surface);	wl_surface_destroy(GLWin.wl_surface);}

QWaylandCursor::~QWaylandCursor(){    if (mSurface)        wl_surface_destroy(mSurface);    delete mBuffer;}

static void delete_window (struct window *window) {	eglDestroySurface (egl_display, window->egl_surface);	wl_egl_window_destroy (window->egl_window);	wl_shell_surface_destroy (window->shell_surface);	wl_surface_destroy (window->surface);	eglDestroyContext (egl_display, window->egl_context);}

UwacReturnCode UwacDestroyWindow(UwacWindow** pwindow){	UwacWindow* w;	assert(pwindow);	w = *pwindow;	UwacWindowDestroyBuffers(w);	if (w->frame_callback)		wl_callback_destroy(w->frame_callback);	if (w->xdg_surface)		xdg_surface_destroy(w->xdg_surface);#if BUILD_IVI	if (w->ivi_surface)		ivi_surface_destroy(w->ivi_surface);#endif	if (w->opaque_region)		wl_region_destroy(w->opaque_region);	if (w->input_region)		wl_region_destroy(w->opaque_region);	wl_surface_destroy(w->surface);	wl_list_remove(&w->link);	free(w);	*pwindow = NULL;	return UWAC_SUCCESS;}

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);  }}

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_vaapi_window_wayland_destroy (GstVaapiWindow * window){    GstVaapiWindowWaylandPrivate *const priv =        GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window);    /* Wait for the last frame to complete redraw */    gst_vaapi_window_wayland_sync (window);    if (priv->last_frame) {        frame_state_free (priv->last_frame);        priv->last_frame = NULL;    }    if (priv->shell_surface) {        wl_shell_surface_destroy (priv->shell_surface);        priv->shell_surface = NULL;    }    if (priv->surface) {        wl_surface_destroy (priv->surface);        priv->surface = NULL;    }    if (priv->event_queue) {        wl_event_queue_destroy (priv->event_queue);        priv->event_queue = NULL;    }    gst_vaapi_filter_replace (&priv->filter, NULL);    gst_vaapi_video_pool_replace (&priv->surface_pool, NULL);    gst_poll_free (priv->poll);}

void Wayland_DestroyWindow(_THIS, SDL_Window *window){    SDL_VideoData *data = _this->driverdata;    SDL_WindowData *wind = window->driverdata;    if (data) {        SDL_EGL_DestroySurface(_this, wind->egl_surface);        WAYLAND_wl_egl_window_destroy(wind->egl_window);        if (wind->shell_surface)            wl_shell_surface_destroy(wind->shell_surface);#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH        if (wind->extended_surface) {            QtExtendedSurface_Unsubscribe(wind->extended_surface, SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION);            QtExtendedSurface_Unsubscribe(wind->extended_surface, SDL_HINT_QTWAYLAND_WINDOW_FLAGS);            qt_extended_surface_destroy(wind->extended_surface);        }#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */        wl_surface_destroy(wind->surface);        SDL_free(wind);        WAYLAND_wl_display_flush(data->display);    }    window->driverdata = NULL;}

WLSurface::~WLSurface(){    if (m_ilmSurfaceId > 0)        ilm_surfaceRemove(m_ilmSurfaceId);    if (m_wlSurface)        wl_surface_destroy(m_wlSurface);}

void hello_free_surface(struct wl_shell_surface *shell_surface){    struct wl_surface *surface;    surface = wl_shell_surface_get_user_data(shell_surface);    wl_shell_surface_destroy(shell_surface);    wl_surface_destroy(surface);}

QWaylandWindow::~QWaylandWindow(){    if (mSurface)        wl_surface_destroy(mSurface);    QList<QWaylandInputDevice *> inputDevices = mDisplay->inputDevices();    for (int i = 0; i < inputDevices.size(); ++i)        inputDevices.at(i)->handleWindowDestroyed(this);}

WaylandSurface::~WaylandSurface(){    // The surface couldn't have been created in the first place if WaylandDisplay wasn't properly initialized.    ASSERT(WaylandDisplay::instance());    eglMakeCurrent(WaylandDisplay::instance()->eglDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);    wl_egl_window_destroy(m_nativeWindow);    wl_surface_destroy(m_wlSurface);}

static voiddestroy_window (struct window *window){  if (window->shell_surface)    wl_shell_surface_destroy (window->shell_surface);  if (window->surface)    wl_surface_destroy (window->surface);  free (window);}

void hello_free_cursor(void){    struct pointer_data *data;    data = wl_pointer_get_user_data(pointer);    wl_buffer_destroy(data->buffer);    wl_surface_destroy(data->surface);    free(data);    wl_pointer_set_user_data(pointer, NULL);}

static void destroyWLContext(){    if (g_wlContextStruct.wlSurface)    {        wl_surface_destroy(g_wlContextStruct.wlSurface);    }    if (g_wlContextStruct.wlCompositor)    {        wl_compositor_destroy(g_wlContextStruct.wlCompositor);    }}

static voiddestroy_window(struct window *window){	if (window->callback)		wl_callback_destroy(window->callback);	wl_buffer_destroy(window->buffer);	wl_shell_surface_destroy(window->shell_surface);	wl_surface_destroy(window->surface);	free(window);}

static voiddestroy_surface(struct window *window){	wl_egl_window_destroy(window->native);	wl_shell_surface_destroy(window->shell_surface);	wl_surface_destroy(window->surface);	if (window->callback)		wl_callback_destroy(window->callback);}

static voidcursor_surface_destroy(struct cursor_surface *cursor){    if (cursor->shsurf)        wl_shell_surface_destroy(cursor->shsurf);    if (cursor->surface)        wl_surface_destroy(cursor->surface);    if (cursor->frame)        wl_callback_destroy(cursor->frame);    free(cursor);}

static void _ecore_wl_input_seat_handle_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps){   Ecore_Wl_Input *input;   if (!(input = data)) return;   LOGFN(__FILE__, __LINE__, __FUNCTION__);   if ((caps & WL_SEAT_CAPABILITY_POINTER) && (!input->pointer))     {        input->pointer = wl_seat_get_pointer(seat);        wl_pointer_set_user_data(input->pointer, input);        wl_pointer_add_listener(input->pointer, &pointer_listener, input);        if (!input->cursor_surface)          {             input->cursor_surface =                wl_compositor_create_surface(_ecore_wl_disp->wl.compositor);          }     }   else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && (input->pointer))     {        if (input->cursor_surface) wl_surface_destroy(input->cursor_surface);        input->cursor_surface = NULL;        wl_pointer_destroy(input->pointer);        input->pointer = NULL;     }   if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && (!input->keyboard))     {        input->keyboard = wl_seat_get_keyboard(seat);        wl_keyboard_set_user_data(input->keyboard, input);        wl_keyboard_add_listener(input->keyboard, &keyboard_listener, input);     }   else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && (input->keyboard))     {        wl_keyboard_destroy(input->keyboard);        input->keyboard = NULL;     }   if ((caps & WL_SEAT_CAPABILITY_TOUCH) && (!input->touch))     {        input->touch = wl_seat_get_touch(seat);        wl_touch_set_user_data(input->touch, input);        wl_touch_add_listener(input->touch, &touch_listener, input);     }   else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && (input->touch))     {        wl_touch_destroy(input->touch);        input->touch = NULL;     }}

void QWaylandWindow::setVisible(bool visible){    if (!mSurface && visible) {        mSurface = mDisplay->createSurface(this);        newSurfaceCreated();    }    if (!visible) {        wl_surface_destroy(mSurface);        mSurface = NULL;    }}

QWaylandWindow::~QWaylandWindow(){    if (mSurface) {        delete mShellSurface;        delete mExtendedWindow;        wl_surface_destroy(mSurface);    }    QList<QWaylandInputDevice *> inputDevices = mDisplay->inputDevices();    for (int i = 0; i < inputDevices.size(); ++i)        inputDevices.at(i)->handleWindowDestroyed(this);}