mirror of
https://github.com/brl/mutter.git
synced 2024-12-28 22:02:14 +00:00
534e535a28
This removes cogl-queue.h and adds a copy of Wayland's embedded list implementation. The advantage of the Wayland model is that it is much simpler and so it is easier to follow. It also doesn't require defining a typedef for every list type. The downside is that there is only one list type which is a doubly-linked list where the head has a pointer to both the beginning and the end. The BSD implementation has many more combinations some of which we were taking advantage of to reduce the size of critical structs where we didn't need a pointer to the end of the list. The corresponding changes to uses of cogl-queue.h are: • COGL_STAILQ_* was used for onscreen the list of events and dirty notifications. This makes the size of the CoglContext grow by one pointer. • COGL_TAILQ_* was used for fences. • COGL_LIST_* for CoglClosures. In this case the list head now has an extra pointer which means CoglOnscreen will grow by the size of three pointers, but this doesn't seem like a particularly important struct to optimise for size anyway. • COGL_LIST_* was used for the list of foreign GLES2 offscreens. • COGL_TAILQ_* was used for the list of sub stacks in a CoglMemoryStack. • COGL_LIST_* was used to track the list of layers that haven't had code generated yet while generating a fragment shader for a pipeline. • COGL_LIST_* was used to track the pipeline hierarchy in CoglNode. The last part is a bit more controversial because it increases the size of CoglPipeline and CoglPipelineLayer by one pointer in order to have the redundant tail pointer for the list head. Normally we try to be very careful about the size of the CoglPipeline struct. Because CoglPipeline is slice-allocated, this effectively ends up adding two pointers to the size because GSlice rounds up to the size of two pointers. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 13abf613b15f571ba1fcf6d2eb831ffc6fa31324) Conflicts: cogl/cogl-context-private.h cogl/cogl-context.c cogl/driver/gl/cogl-pipeline-fragend-glsl.c doc/reference/cogl-2.0-experimental/Makefile.am
113 lines
4.1 KiB
C
113 lines
4.1 KiB
C
/*
|
|
* Cogl
|
|
*
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
|
*
|
|
* Copyright (C) 2012,2013 Intel Corporation.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#ifndef _COGL_CLOSURE_LIST_PRIVATE_H_
|
|
#define _COGL_CLOSURE_LIST_PRIVATE_H_
|
|
|
|
#include "cogl-object.h"
|
|
#include "cogl-list.h"
|
|
|
|
/*
|
|
* This implements a list of callbacks that can be used a bit like
|
|
* signals in GObject, but that don't have any marshalling overhead.
|
|
*
|
|
* The idea is that any Cogl code that wants to provide a callback
|
|
* point will provide api to add a callback for that particular point.
|
|
* The function can take a function pointer with the correct
|
|
* signature. Internally the Cogl code can use _cogl_closure_list_add,
|
|
* _cogl_closure_disconnect and _cogl_closure_list_disconnect_all
|
|
*
|
|
* In the future we could consider exposing the CoglClosure type which
|
|
* would allow applications to use _cogl_closure_disconnect() directly
|
|
* so we don't need to expose new disconnect apis for each callback
|
|
* point.
|
|
*/
|
|
|
|
typedef struct _CoglClosure
|
|
{
|
|
CoglList link;
|
|
|
|
void *function;
|
|
void *user_data;
|
|
CoglUserDataDestroyCallback destroy_cb;
|
|
} CoglClosure;
|
|
|
|
/*
|
|
* _cogl_closure_disconnect:
|
|
* @closure: A closure connected to a Cogl closure list
|
|
*
|
|
* Removes the given closure from the callback list it is connected to
|
|
* and destroys it. If the closure was created with a destroy function
|
|
* then it will be invoked. */
|
|
void
|
|
_cogl_closure_disconnect (CoglClosure *closure);
|
|
|
|
void
|
|
_cogl_closure_list_disconnect_all (CoglList *list);
|
|
|
|
CoglClosure *
|
|
_cogl_closure_list_add (CoglList *list,
|
|
void *function,
|
|
void *user_data,
|
|
CoglUserDataDestroyCallback destroy_cb);
|
|
|
|
/*
|
|
* _cogl_closure_list_invoke:
|
|
* @list: A pointer to a CoglList containing CoglClosures
|
|
* @cb_type: The name of a typedef for the closure callback function signature
|
|
* @...: The the arguments to pass to the callback
|
|
*
|
|
* A convenience macro to invoke a closure list with a variable number
|
|
* of arguments that will be passed to the closure callback functions.
|
|
*
|
|
* Note that the arguments will be evaluated multiple times so it is
|
|
* not safe to pass expressions that have side-effects.
|
|
*
|
|
* Note also that this function ignores the return value from the
|
|
* callbacks. If you want to handle the return value you should
|
|
* manually iterate the list and invoke the callbacks yourself.
|
|
*/
|
|
#define _cogl_closure_list_invoke(list, cb_type, ...) \
|
|
G_STMT_START { \
|
|
CoglClosure *_c, *_tmp; \
|
|
\
|
|
_cogl_list_for_each_safe (_c, _tmp, (list), link) \
|
|
{ \
|
|
cb_type _cb = _c->function; \
|
|
_cb (__VA_ARGS__, _c->user_data); \
|
|
} \
|
|
} G_STMT_END
|
|
|
|
#define _cogl_closure_list_invoke_no_args(list) \
|
|
G_STMT_START { \
|
|
CoglClosure *_c, *_tmp; \
|
|
\
|
|
_cogl_list_for_each_safe (_c, _tmp, (list), link) \
|
|
{ \
|
|
void (*_cb)(void *) = _c->function; \
|
|
_cb (_c->user_data); \
|
|
} \
|
|
} G_STMT_END
|
|
|
|
#endif /* _COGL_CLOSURE_LIST_PRIVATE_H_ */
|