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

static voidsync_callback(void *data, struct wl_callback *callback, uint32_t serial){	struct multiple_queues_state *state = data;	state->done = true;	wl_callback_destroy(callback);	wl_display_dispatch_pending(state->display);	wl_callback_destroy(state->callback2);}

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 void frame_listener_func(void *data, struct wl_callback *callback, uint32_t time){    if (callback)    {        wl_callback_destroy(callback);    }}

static voidredraw(void *data, struct wl_callback *callback, uint32_t time){	struct window *window = data;	struct buffer *buffer;	buffer = window_next_buffer(window);	if (!buffer) {		fprintf(stderr,			!callback ? "Failed to create the first buffer./n" :			"Both buffers busy at redraw(). Server bug?/n");		abort();	}	paint_pixels(buffer->shm_data, 20, window->width, window->height, time);	wl_surface_attach(window->surface, buffer->buffer, 0, 0);	wl_surface_damage(window->surface,			  20, 20, window->width - 40, window->height - 40);	if (callback)		wl_callback_destroy(callback);	window->callback = wl_surface_frame(window->surface);	wl_callback_add_listener(window->callback, &frame_listener, window);	wl_surface_commit(window->surface);	buffer->busy = 1;}

static voidframe_redraw_callback (void *data, struct wl_callback *callback, uint32_t time){  struct window *window = (struct window *) data;  window->redraw_pending = FALSE;  wl_callback_destroy (callback);}

static voidframe_callback(void *data, struct wl_callback *callback, uint32_t time){	struct resizor *resizor = data;	assert(!callback || callback == resizor->frame_callback);	if (resizor->frame_callback) {		wl_callback_destroy(resizor->frame_callback);		resizor->frame_callback = NULL;	}	if (window_is_maximized(resizor->window))		return;	spring_update(&resizor->width);	spring_update(&resizor->height);	widget_schedule_resize(resizor->widget,			       resizor->width.current + 0.5,			       resizor->height.current + 0.5);	if (!spring_done(&resizor->width) || !spring_done(&resizor->height)) {		resizor->frame_callback =			wl_surface_frame(				window_get_wl_surface(resizor->window));		wl_callback_add_listener(resizor->frame_callback, &listener,					 resizor);	}}

void QWaylandShmBackingStore::done(void *data, wl_callback *callback, uint32_t time){    Q_UNUSED(time);    QWaylandShmBackingStore *self =            static_cast<QWaylandShmBackingStore *>(data);    if (callback != self->mFrameCallback) // others, like QWaylandWindow, may trigger callbacks too        return;    QWaylandShmWindow *window = self->waylandWindow();    wl_callback_destroy(self->mFrameCallback);    self->mFrameCallback = 0;    if (self->mFrontBuffer != window->attached()) {        delete window->attached();    }    if (window->attached() != self->mFrontBuffer)        window->attachOffset(self->mFrontBuffer);    if (self->mFrontBufferIsDirty && !self->mPainting) {        self->mFrontBufferIsDirty = false;        self->mFrameCallback = wl_surface_frame(window->wl_surface());        wl_callback_add_listener(self->mFrameCallback,&self->frameCallbackListener,self);        window->damage(QRect(QPoint(0,0),self->mFrontBuffer->size()));    }}

static voidleak_closure(void){	struct wl_callback *cb;	struct pollfd pfd;	struct client *c = client_connect();	cb = wl_display_sync(c->wl_display);	assert(cb);	assert(wl_display_flush(c->wl_display) > 0);	/* we don't need it, it is referenced */	wl_callback_destroy(cb);	pfd.fd = wl_display_get_fd(c->wl_display);	pfd.events = POLLIN;	test_set_timeout(2);	assert(poll(&pfd, 1, -1) == 1);	/* read events, but do not dispatch them */	assert(wl_display_prepare_read(c->wl_display) == 0);	assert(wl_display_read_events(c->wl_display) == 0);	/*	 * now we have wl_callback.done and wl_display.delete_id queued;	 * if we now release the queue (in wl_display_disconnect())	 * we should not leak memory	 */	client_disconnect(c);}

QWaylandWindow::~QWaylandWindow(){    delete mWindowDecoration;    if (isInitialized()) {        delete mShellSurface;        destroy();    }    if (mFrameCallback)        wl_callback_destroy(mFrameCallback);    QList<QWaylandInputDevice *> inputDevices = mDisplay->inputDevices();    for (int i = 0; i < inputDevices.size(); ++i)        inputDevices.at(i)->handleWindowDestroyed(this);    const QWindow *parent = window();    foreach (QWindow *w, QGuiApplication::topLevelWindows()) {        if (w->transientParent() == parent)            QWindowSystemInterface::handleCloseEvent(w);    }    if (mMouseGrab == this) {        mMouseGrab = 0;    }}

static voidtriangle_frame_callback(void *data, struct wl_callback *callback,			uint32_t time){	struct triangle *tri = data;	DBG("%stime %u/n", callback ? "" : "artificial ", time);	assert(callback == tri->frame_cb);	tri->time = time;	if (callback)		wl_callback_destroy(callback);	eglMakeCurrent(tri->egl->dpy, tri->egl_surface,				   tri->egl_surface, tri->egl->ctx);	glViewport(0, 0, tri->width, tri->height);	triangle_draw(&tri->gl, tri->time);	tri->frame_cb = wl_surface_frame(tri->wl_surface);	wl_callback_add_listener(tri->frame_cb, &triangle_frame_listener, tri);	eglSwapBuffers(tri->egl->dpy, tri->egl_surface);}

static voidredraw(void *data, struct wl_callback *callback, uint32_t time){	struct window *window = data;	struct buffer *buffer;	buffer = window_next_buffer(window);	if (!buffer) {		fprintf(stderr,			!callback ? "Failed to create the first buffer./n" :			"Both buffers busy at redraw(). Server bug?/n");		abort();	}	/* XXX: would be nice to draw something that changes here... */	wl_surface_attach(window->surface, buffer->buffer, 0, 0);	wl_surface_damage(window->surface, 0, 0, window->width, window->height);	if (callback)		wl_callback_destroy(callback);	window->callback = wl_surface_frame(window->surface);	wl_callback_add_listener(window->callback, &frame_listener, window);	wl_surface_commit(window->surface);	buffer->busy = 1;}

    static voidwayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time){    WaylandNativeWindow *surface = static_cast<WaylandNativeWindow *>(data);    surface->frame();    wl_callback_destroy(callback);}

static void roundtrip_callback(void *data, struct wl_callback *callback, uint32_t serial){   int *done = (int *)data;   *done = 1;   wl_callback_destroy(callback);}

static voidlocked_pointer_frame_callback(void *data,			      struct wl_callback *callback,			      uint32_t time){	struct resizor *resizor = data;	struct wl_surface *surface;	struct rectangle allocation;	float x, y;	if (resizor->pointer_locked) {		widget_get_allocation(resizor->widget, &allocation);		x = resizor->pointer_x + (allocation.width - allocation.x);		y = resizor->pointer_y + (allocation.height - allocation.y);		widget_set_locked_pointer_cursor_hint(resizor->widget, x, y);	}	wl_callback_destroy(callback);	surface = window_get_wl_surface(resizor->window);	callback = wl_surface_frame(surface);	wl_callback_add_listener(callback,				 &locked_pointer_frame_listener,				 resizor);}

static void wl_callback_done(void* data, struct wl_callback* callback, uint32_t time){	wlfWindow* window = data;	wlfBuffer* buffer;	struct wl_shm_pool* shm_pool;	void* shm_data;	void* free_data;	int fd;	int fdt;	if (!window->buffers[0].busy)		buffer = &window->buffers[0];	else if (!window->buffers[1].busy)		buffer = &window->buffers[1];	else		return;	if (!buffer->buffer) {		fd = shm_open("/wlfreerdp_shm", O_CREAT | O_RDWR, 0666);		fdt = ftruncate(fd, window->width * window->height * 4);		if (fdt != 0)		{			WLog_ERR(TAG, "window_redraw: could not allocate memory");			close(fd);			return;		}		shm_data = mmap(NULL, window->width * window->height * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);		if (shm_data == MAP_FAILED)		{			WLog_ERR(TAG, "window_redraw: failed to memory map buffer");			close(fd);			return;		}		shm_pool = wl_shm_create_pool(window->display->shm, fd, window->width * window->height * 4);		buffer->buffer = wl_shm_pool_create_buffer(shm_pool, 0, window->width, window->height, window->width* 4, WL_SHM_FORMAT_XRGB8888);		wl_buffer_add_listener(buffer->buffer, &wl_buffer_listener, buffer);		wl_shm_pool_destroy(shm_pool);		shm_unlink("/wlfreerdp_shm");		close(fd);		free_data = buffer->shm_data;		buffer->shm_data = shm_data;		munmap(free_data, window->width * window->height * 4);	}	 /* this is the real surface data */	memcpy(buffer->shm_data, (void*) window->data, window->width * window->height * 4);	wl_surface_attach(window->surface, buffer->buffer, 0, 0);	wl_surface_damage(window->surface, 0, 0, window->width, window->height);	if (callback) wl_callback_destroy(callback);	window->callback = wl_surface_frame(window->surface);	wl_callback_add_listener(window->callback, &wl_callback_listener, window);	wl_surface_commit(window->surface);	buffer->busy = TRUE;}

static voidsync_callback(void *data, struct wl_callback *callback, uint32_t time){    struct wl_egl_window *window = data;    window->block_swap_buffers = 0; /* false */    wl_callback_destroy(callback);}

static voidsync_callback(void *data, struct wl_callback *callback, uint32_t serial){   int *done = data;   *done = 1;   wl_callback_destroy(callback);}

    voidWaylandNativeWindow::sync_callback(void *data, struct wl_callback *callback, uint32_t serial){    int *done = static_cast<int *>(data);    *done = 1;    wl_callback_destroy(callback);}

static voidinit_sync_callback(void *data, struct wl_callback *callback, uint32_t serial){  GdkWaylandDisplay *display = data;  display->init_ref_count--;  wl_callback_destroy(callback);}

static voidbuffer_create_sync_callback(void *data, struct wl_callback *callback, uint32_t serial){   struct wl_callback **created_callback = static_cast<struct wl_callback **>(data);   *created_callback = NULL;   wl_callback_destroy(callback);}

static voidwayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time){   struct dri2_egl_surface *dri2_surf = data;   dri2_surf->block_swap_buffers = EGL_FALSE;   wl_callback_destroy(callback);}

static voidfree_frame_callback_data (FrameCallbackData *callback_data){  cogl_object_unref (callback_data->frame_info);  wl_callback_destroy (callback_data->callback);  _cogl_list_remove (&callback_data->link);  g_slice_free (FrameCallbackData, callback_data);}

static voidframe_done(void *data, struct wl_callback *callback, uint32_t time){	struct weston_output *output = data;	wl_callback_destroy(callback);	weston_output_finish_frame(output, time);}

static voidframe_callback(void *data, struct wl_callback *callback, uint32_t time){	struct ModeInfo *mi = data;	window_schedule_redraw(mi->window);	wl_callback_destroy(callback);}

static voidwayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time){    //wsegl_info("wayland-wsegl: wayland_frame_callback");    struct wl_egl_window *drawable = (struct wl_egl_window *)data;    drawable->display->frame_callback = NULL;    wl_callback_destroy(callback);}

static voidredraw(void *data, struct wl_callback *callback, uint32_t time){	struct window *window = data;	static const GLfloat verts[3][2] = {		{ -0.5, -0.5 },		{  0.5, -0.5 },		{  0,    0.5 }	};	static const GLfloat colors[3][3] = {		{ 1, 0, 0 },		{ 0, 1, 0 },		{ 0, 0, 1 }	};	GLfloat angle;	GLfloat rotation[4][4] = {		{ 1, 0, 0, 0 },		{ 0, 1, 0, 0 },		{ 0, 0, 1, 0 },		{ 0, 0, 0, 1 }	};	static const int32_t speed_div = 5;	static uint32_t start_time = 0;	if (start_time == 0)		start_time = time;	angle = ((time-start_time) / speed_div) % 360 * M_PI / 180.0;	rotation[0][0] =  cos(angle);	rotation[0][2] =  sin(angle);	rotation[2][0] = -sin(angle);	rotation[2][2] =  cos(angle);	glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,			   (GLfloat *) rotation);	glClearColor(0.0, 0.0, 0.0, 0.5);	glClear(GL_COLOR_BUFFER_BIT);	glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);	glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);	glEnableVertexAttribArray(window->gl.pos);	glEnableVertexAttribArray(window->gl.col);	glDrawArrays(GL_TRIANGLES, 0, 3);	glDisableVertexAttribArray(window->gl.pos);	glDisableVertexAttribArray(window->gl.col);	glFlush();	eglSwapBuffers(window->display->egl.dpy, window->egl_surface);	if (callback)		wl_callback_destroy(callback);	window->callback = wl_surface_frame(window->surface);	wl_callback_add_listener(window->callback, &frame_listener, window);}

void WaylandNativeWindow::finishSwap(){    int ret = 0;    lock();    WaylandNativeWindowBuffer *wnb = queue.front();    if (!wnb) {        wnb = m_lastBuffer;    } else {        queue.pop_front();    }    assert(wnb);    m_lastBuffer = wnb;    wnb->busy = 1;    ret = readQueue(false);    if (this->frame_callback) {        do {            ret = readQueue(true);        } while (this->frame_callback && ret != -1);    }    if (ret < 0) {        HYBRIS_TRACE_END("wayland-platform", "queueBuffer_wait_for_frame_callback", "-%p", wnb);        return;    }    if (wnb->wlbuffer == NULL)    {        wnb->wlbuffer_from_native_handle(m_android_wlegl, m_display, wl_queue);        TRACE("%p add listener with %p inside", wnb, wnb->wlbuffer);        wl_buffer_add_listener(wnb->wlbuffer, &wl_buffer_listener, this);        wl_proxy_set_queue((struct wl_proxy *) wnb->wlbuffer, this->wl_queue);    }    if (m_swap_interval > 0) {        this->frame_callback = wl_surface_frame(m_window->surface);        wl_callback_add_listener(this->frame_callback, &frame_listener, this);        wl_proxy_set_queue((struct wl_proxy *) this->frame_callback, this->wl_queue);    }    wl_surface_attach(m_window->surface, wnb->wlbuffer, 0, 0);    wl_surface_damage(m_window->surface, 0, 0, wnb->width, wnb->height);    wl_surface_commit(m_window->surface);    // Some compositors, namely Weston, queue buffer release events instead    // of sending them immediately.  If a frame event is used, this should    // not be a problem.  Without a frame event, we need to send a sync    // request to ensure that they get flushed.    wl_callback_destroy(wl_display_sync(m_display));    wl_display_flush(m_display);    fronted.push_back(wnb);    m_window->attached_width = wnb->width;    m_window->attached_height = wnb->height;    m_damage_rects = NULL;    m_damage_n_rects = 0;    unlock();}

static voidwayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time){   struct wayland_surface *surface = data;   surface->block_swap_buffers = FALSE;   wl_callback_destroy(callback);}

static voidframe_callback_handler(void *data, struct wl_callback *callback, uint32_t time){	int *done = data;	*done = 1;	wl_callback_destroy(callback);}

void QWaylandXCompositeEGLWindow::done(void *data,             struct wl_callback *callback,             uint32_t time){    Q_UNUSED(time);    bool *waitingForSync = static_cast<bool *>(data);    *waitingForSync=false;    wl_callback_destroy(callback);}