conf.h   conf.h 
skipping to change at line 56 skipping to change at line 56
struct { struct {
DFBDisplayLayerBackgroundMode mode; DFBDisplayLayerBackgroundMode mode;
DFBColor color; DFBColor color;
int color_index; int color_index;
char *filename; char *filename;
} background; } background;
DFBWindowStackingClass stacking; DFBWindowStackingClass stacking;
DFBColor palette[256]; DFBColor *palette;
bool palette_set; bool palette_set;
int rotate; int rotate;
} DFBConfigLayer; } DFBConfigLayer;
typedef enum {
DCWF_NONE = 0x00000000,
DCWF_CREATE_SURFACE = 0x00000001,
DCWF_CREATE_WINDOW = 0x00000002,
DCWF_ALLOCATE_BUFFER = 0x00000010,
DCWF_ALL = 0x00000013,
} DFBConfigWarnFlags;
typedef struct typedef struct
{ {
bool mouse_motion_compression; /* use motion compression ? */ bool mouse_motion_compression; /* use motion compression ? */
char *mouse_protocol; /* mouse protocol */ char *mouse_protocol; /* mouse protocol */
char *mouse_source; /* mouse source device na me */ char *mouse_source; /* mouse source device na me */
bool mouse_gpm_source; /* mouse source is gpm? * / bool mouse_gpm_source; /* mouse source is gpm? * /
int window_policy; /* swapping policy for th e int window_policy; /* swapping policy for th e
surface of a window */ surface of a window */
int buffer_mode; /* default buffer mode fo r int buffer_mode; /* default buffer mode fo r
skipping to change at line 214 skipping to change at line 225
bool linux_input_grab; /* Grab input devices. */ bool linux_input_grab; /* Grab input devices. */
bool autoflip_window; /* If primary surface is non-flipping, but windowed, flip automatically. */ bool autoflip_window; /* If primary surface is non-flipping, but windowed, flip automatically. */
bool software_warn; /* Show warnings when doi ng/dropping software operations. */ bool software_warn; /* Show warnings when doi ng/dropping software operations. */
int surface_shmpool_size; /* Set the size of the sh ared memory pool used for int surface_shmpool_size; /* Set the size of the sh ared memory pool used for
shared system memory s urfaces. */ shared system memory s urfaces. */
bool no_cursor_updates; /* Never show the cursor etc. */ bool no_cursor_updates; /* Never show the cursor etc. */
struct {
DFBConfigWarnFlags flags; /* Warn on various action
s as window/surface creation. */
struct {
DFBDimension min_size;
} create_surface;
struct {
DFBDimension min_size;
} allocate_buffer;
} warn;
int keep_accumulators; /* Free accumulators abov
e this limit */
} DFBConfig; } DFBConfig;
extern DFBConfig *dfb_config; extern DFBConfig *dfb_config;
/* /*
* Allocate Config struct, fill with defaults and parse command line option s * Allocate Config struct, fill with defaults and parse command line option s
* for overrides. Options identified as DirectFB options are stripped out * for overrides. Options identified as DirectFB options are stripped out
* of the array. * of the array.
*/ */
DFBResult dfb_config_init( int *argc, char *(*argv[]) ); DFBResult dfb_config_init( int *argc, char *(*argv[]) );
 End of changes. 3 change blocks. 
1 lines changed or deleted 28 lines changed or added


 convert.h   convert.h 
skipping to change at line 434 skipping to change at line 434
void dfb_convert_to_rgb16( DFBSurfacePixelFormat format, void dfb_convert_to_rgb16( DFBSurfacePixelFormat format,
void *src, void *src,
int spitch, int spitch,
int surface_height, int surface_height,
u16 *dst, u16 *dst,
int dpitch, int dpitch,
int width, int width,
int height ); int height );
void dfb_convert_to_rgb555( DFBSurfacePixelFormat format,
void *src,
int spitch,
int surface_height,
u16 *dst,
int dpitch,
int width,
int height );
void dfb_convert_to_argb( DFBSurfacePixelFormat format,
void *src,
int spitch,
int surface_height,
u32 *dst,
int dpitch,
int width,
int height );
void dfb_convert_to_rgb32( DFBSurfacePixelFormat format, void dfb_convert_to_rgb32( DFBSurfacePixelFormat format,
void *src, void *src,
int spitch, int spitch,
int surface_height, int surface_height,
u32 *dst, u32 *dst,
int dpitch, int dpitch,
int width, int width,
int height ); int height );
void dfb_convert_to_a4( DFBSurfacePixelFormat format, void dfb_convert_to_a4( DFBSurfacePixelFormat format,
 End of changes. 1 change blocks. 
0 lines changed or deleted 18 lines changed or added


 core.h   core.h 
skipping to change at line 41 skipping to change at line 41
#include <fusion/types.h> #include <fusion/types.h>
#include <fusion/lock.h> #include <fusion/lock.h>
#include <fusion/object.h> #include <fusion/object.h>
#include <directfb.h> #include <directfb.h>
#include "coretypes.h" #include "coretypes.h"
#include "coredefs.h" #include "coredefs.h"
#define DIRECTFB_CORE_ABI 44 #define DIRECTFB_CORE_ABI 45
typedef enum { typedef enum {
DFCP_CLIPBOARD, DFCP_CLIPBOARD,
DFCP_COLORHASH, DFCP_COLORHASH,
DFCP_GRAPHICS, DFCP_GRAPHICS,
DFCP_INPUT, DFCP_INPUT,
DFCP_LAYER, DFCP_LAYER,
DFCP_SCREEN, DFCP_SCREEN,
DFCP_SURFACE, DFCP_SURFACE,
DFCP_SYSTEM, DFCP_SYSTEM,
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 directfb.h   directfb.h 
skipping to change at line 3856 skipping to change at line 3856
* *
* See also IDirectFBSurface::SetBlittingFlags(). * See also IDirectFBSurface::SetBlittingFlags().
*/ */
DFBResult (*SetSourceMask) ( DFBResult (*SetSourceMask) (
IDirectFBSurface *thiz, IDirectFBSurface *thiz,
IDirectFBSurface *mask, IDirectFBSurface *mask,
int x, int x,
int y, int y,
DFBSurfaceMaskFlags flags DFBSurfaceMaskFlags flags
); );
/** Lightweight helpers **/
/*
* Make this a sub surface or adjust the rectangle of this sub surface
.
*/
DFBResult (*MakeSubSurface) (
IDirectFBSurface *thiz,
IDirectFBSurface *from,
const DFBRectangle *rect
);
) )
/******************** /********************
* IDirectFBPalette * * IDirectFBPalette *
********************/ ********************/
/* /*
* <i>No summary yet...</i> * <i>No summary yet...</i>
*/ */
DEFINE_INTERFACE( IDirectFBPalette, DEFINE_INTERFACE( IDirectFBPalette,
skipping to change at line 5474 skipping to change at line 5485
/* /*
* Registers a callback for progressive image loading. * Registers a callback for progressive image loading.
* *
* The function is called each time a chunk of the image is decoded. * The function is called each time a chunk of the image is decoded.
*/ */
DFBResult (*SetRenderCallback) ( DFBResult (*SetRenderCallback) (
IDirectFBImageProvider *thiz, IDirectFBImageProvider *thiz,
DIRenderCallback callback, DIRenderCallback callback,
void *callback_data void *callback_data
); );
/** Encoding **/
/*
* Encode a portion of a surface.
*/
DFBResult (*WriteBack) (
IDirectFBImageProvider *thiz,
IDirectFBSurface *surface,
const DFBRectangle *src_rect,
const char *filename
);
) )
/* /*
* Capabilities of an audio/video stream. * Capabilities of an audio/video stream.
*/ */
typedef enum { typedef enum {
DVSCAPS_NONE = 0x00000000, /* None of these. */ DVSCAPS_NONE = 0x00000000, /* None of these. */
DVSCAPS_VIDEO = 0x00000001, /* Stream contains video. */ DVSCAPS_VIDEO = 0x00000001, /* Stream contains video. */
DVSCAPS_AUDIO = 0x00000002 /* Stream contains audio. */ DVSCAPS_AUDIO = 0x00000002 /* Stream contains audio. */
/* DVSCAPS_SUBPICTURE ?! */ /* DVSCAPS_SUBPICTURE ?! */
 End of changes. 2 change blocks. 
0 lines changed or deleted 24 lines changed or added


 directfb_version.h   directfb_version.h 
skipping to change at line 34 skipping to change at line 34
License along with this library; if not, write to the License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330, Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
*/ */
#ifndef __DIRECTFB_VERSION_H__ #ifndef __DIRECTFB_VERSION_H__
#define __DIRECTFB_VERSION_H__ #define __DIRECTFB_VERSION_H__
#define DIRECTFB_MAJOR_VERSION (1) #define DIRECTFB_MAJOR_VERSION (1)
#define DIRECTFB_MINOR_VERSION (2) #define DIRECTFB_MINOR_VERSION (2)
#define DIRECTFB_MICRO_VERSION (0) #define DIRECTFB_MICRO_VERSION (1)
#define DIRECTFB_BINARY_AGE (0) #define DIRECTFB_BINARY_AGE (1)
#define DIRECTFB_INTERFACE_AGE (0) #define DIRECTFB_INTERFACE_AGE (0)
#endif /* __DIRECTFB_VERSION_H__ */ #endif /* __DIRECTFB_VERSION_H__ */
 End of changes. 1 change blocks. 
2 lines changed or deleted 2 lines changed or added


 ref.h   ref.h 
skipping to change at line 61 skipping to change at line 61
int call_arg; int call_arg;
} builtin; } builtin;
} multi; } multi;
/* single app */ /* single app */
struct { struct {
int refs; int refs;
pthread_cond_t cond; pthread_cond_t cond;
pthread_mutex_t lock; pthread_mutex_t lock;
bool destroyed; bool destroyed;
int waiting; int locked;
FusionCall *call; FusionCall *call;
int call_arg; int call_arg;
} single; } single;
} FusionRef; } FusionRef;
/* /*
* Initialize. * Initialize.
*/ */
DirectResult fusion_ref_init (FusionRef *ref, DirectResult fusion_ref_init (FusionRef *ref,
const char *name, const char *name,
const FusionWorld *world); const FusionWorld *world);
DirectResult fusion_ref_set_name (FusionRef *ref,
const char *name);
/* /*
* Lock, increase, unlock. * Lock, increase, unlock.
*/ */
DirectResult fusion_ref_up (FusionRef *ref, bool global); DirectResult fusion_ref_up (FusionRef *ref, bool global);
/* /*
* Lock, decrease, unlock. * Lock, decrease, unlock.
*/ */
DirectResult fusion_ref_down (FusionRef *ref, bool global); DirectResult fusion_ref_down (FusionRef *ref, bool global);
 End of changes. 2 change blocks. 
1 lines changed or deleted 4 lines changed or added


 surface.h   surface.h 
skipping to change at line 268 skipping to change at line 268
static inline DirectResult static inline DirectResult
dfb_surface_lock( CoreSurface *surface ) dfb_surface_lock( CoreSurface *surface )
{ {
D_MAGIC_ASSERT( surface, CoreSurface ); D_MAGIC_ASSERT( surface, CoreSurface );
return fusion_skirmish_prevail( &surface->lock ); return fusion_skirmish_prevail( &surface->lock );
} }
static inline DirectResult static inline DirectResult
dfb_surface_trylock( CoreSurface *surface )
{
D_MAGIC_ASSERT( surface, CoreSurface );
return fusion_skirmish_swoop( &surface->lock );
}
static inline DirectResult
dfb_surface_unlock( CoreSurface *surface ) dfb_surface_unlock( CoreSurface *surface )
{ {
D_MAGIC_ASSERT( surface, CoreSurface ); D_MAGIC_ASSERT( surface, CoreSurface );
return fusion_skirmish_dismiss( &surface->lock ); return fusion_skirmish_dismiss( &surface->lock );
} }
static inline CoreSurfaceBuffer * static inline CoreSurfaceBuffer *
dfb_surface_get_buffer( CoreSurface *surface, dfb_surface_get_buffer( CoreSurface *surface,
CoreSurfaceBufferRole role ) CoreSurfaceBufferRole role )
 End of changes. 1 change blocks. 
0 lines changed or deleted 8 lines changed or added


 surface_buffer.h   surface_buffer.h 
skipping to change at line 62 skipping to change at line 62
/* /*
* Configuration and State flags of a Surface Buffer Allocation * Configuration and State flags of a Surface Buffer Allocation
*/ */
typedef enum { typedef enum {
CSALF_NONE = 0x00000000, /* None of these. */ CSALF_NONE = 0x00000000, /* None of these. */
CSALF_ONEFORALL = 0x00000001, /* Only one allocation in pool for all buffers. */ CSALF_ONEFORALL = 0x00000001, /* Only one allocation in pool for all buffers. */
CSALF_VOLATILE = 0x00000002, /* Allocation should be freed when no longer up to date. */ CSALF_VOLATILE = 0x00000002, /* Allocation should be freed when no longer up to date. */
CSALF_PREALLOCATED = 0x00000004, /* Preallocated memory, don't zap w hen "thrifty-surface-buffers" is active. */ CSALF_PREALLOCATED = 0x00000004, /* Preallocated memory, don't zap w hen "thrifty-surface-buffers" is active. */
CSALF_ALL = 0x00000007 /* All of these. */ CSALF_MUCKOUT = 0x00001000, /* Indicates surface pool being in
the progress of mucking out this and possibly
other allocations to have enough
space for a new allocation to be made. */
CSALF_ALL = 0x00001007 /* All of these. */
} CoreSurfaceAllocationFlags; } CoreSurfaceAllocationFlags;
/* /*
* An Allocation of a Surface Buffer * An Allocation of a Surface Buffer
*/ */
struct __DFB_CoreSurfaceAllocation { struct __DFB_CoreSurfaceAllocation {
int magic; int magic;
DirectSerial serial; /* Equals serial of buffe r if content is up to date. */ DirectSerial serial; /* Equals serial of buffe r if content is up to date. */
skipping to change at line 88 skipping to change at line 91
CoreSurfaceAccessFlags access; /* Possible access flags. */ CoreSurfaceAccessFlags access; /* Possible access flags. */
CoreSurfaceAllocationFlags flags; /* Pool can return CSALF_ ONEFORALL upon allocation of first buffer. */ CoreSurfaceAllocationFlags flags; /* Pool can return CSALF_ ONEFORALL upon allocation of first buffer. */
CoreSurfaceAccessFlags accessed; /* Access since last sync hronization. */ CoreSurfaceAccessFlags accessed; /* Access since last sync hronization. */
}; };
#define CORE_SURFACE_ALLOCATION_ASSERT(alloc) \ #define CORE_SURFACE_ALLOCATION_ASSERT(alloc) \
do { \ do { \
D_MAGIC_ASSERT( alloc, CoreSurfaceAllocation ); \ D_MAGIC_ASSERT( alloc, CoreSurfaceAllocation ); \
/*CORE_SURFACE_BUFFER_ASSERT( (alloc)->buffer );*/
\
/*CORE_SURFACE_POOL_ASSERT( (alloc)->pool );*/
\
D_ASSUME( (alloc)->size > 0 ); \ D_ASSUME( (alloc)->size > 0 ); \
D_ASSERT( (alloc)->size >= 0 ); \ D_ASSERT( (alloc)->size >= 0 ); \
D_ASSERT( (alloc)->offset + (alloc)->size <= ((alloc)->pool->desc .size ?:~0UL) ); \ D_ASSERT( (alloc)->offset + (alloc)->size <= ((alloc)->pool->desc .size ?:~0UL) ); \
D_FLAGS_ASSERT( (alloc)->access, CSAF_ALL ); \ D_FLAGS_ASSERT( (alloc)->access, CSAF_ALL ); \
D_FLAGS_ASSERT( (alloc)->flags, CSALF_ALL ); \ D_FLAGS_ASSERT( (alloc)->flags, CSALF_ALL ); \
D_FLAGS_ASSERT( (alloc)->accessed, CSAF_ALL ); \ D_FLAGS_ASSERT( (alloc)->accessed, CSAF_ALL ); \
} while (0) } while (0)
/* /*
* A Lock on a Surface Buffer * A Lock on a Surface Buffer
*/ */
struct __DFB_CoreSurfaceBufferLock { struct __DFB_CoreSurfaceBufferLock {
int magic; int magic; /* Must be valid before c alling dfb_surface_pool_lock() */
CoreSurfaceAccessFlags access; CoreSurfaceAccessFlags access; /* " */
CoreSurfaceBuffer *buffer; CoreSurfaceBuffer *buffer; /* Set by dfb_surface_poo
CoreSurfaceAllocation *allocation; l_lock() */
CoreSurfaceAllocation *allocation; /* " */
void *addr; void *addr; /* " */
unsigned long phys; unsigned long phys; /* " */
unsigned long offset; unsigned long offset; /* " */
unsigned int pitch; unsigned int pitch; /* " */
void *handle; void *handle; /* " */
}; };
#define CORE_SURFACE_BUFFER_LOCK_ASSERT(lock) static inline void
\ dfb_surface_buffer_lock_reset( CoreSurfaceBufferLock *lock )
do { {
\ D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock );
D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock );
\ lock->buffer = NULL;
D_FLAGS_ASSERT( (lock)->access, CSAF_ALL ); lock->allocation = NULL;
\ lock->addr = NULL;
CORE_SURFACE_ALLOCATION_ASSERT( (lock)->allocation ); lock->phys = 0;
\ lock->offset = ~0;
D_ASSERT( (lock)->buffer == (lock)->allocation->buffer ); lock->pitch = 0;
\ lock->handle = NULL;
D_ASSUME( (lock)->addr != NULL || }
\
!((lock)->access & (CSAF_CPU_READ|CSAF_CPU_WRITE)) ); static inline void
\ dfb_surface_buffer_lock_init( CoreSurfaceBufferLock *lock, CoreSurfaceAcces
D_ASSUME( (lock)->phys != 0 || (lock)->handle != NULL || sFlags access )
\ {
!((lock)->access & (CSAF_GPU_READ|CSAF_GPU_WRITE)) ); D_MAGIC_SET( lock, CoreSurfaceBufferLock );
\
D_ASSUME( (lock)->offset == (lock)->allocation->offset ); lock->access = access;
\
D_ASSERT( (lock)->pitch > 0 ); dfb_surface_buffer_lock_reset( lock );
\ }
#define CORE_SURFACE_BUFFER_LOCK_ASSERT(lock)
\
do {
\
D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock );
\
D_FLAGS_ASSERT( (lock)->access, CSAF_ALL );
\
if ((lock)->buffer) {
\
D_ASSERT( (lock)->allocation != NULL );
\
D_ASSERT( (lock)->buffer == (lock)->allocation->buffer );
\
D_ASSUME( (lock)->addr != NULL ||
\
!((lock)->access & (CSAF_CPU_READ|CSAF_CPU_WRITE))
); \
D_ASSUME( (lock)->phys != 0 || (lock)->offset != ~0 || (lock
)->handle != NULL || \
!((lock)->access & (CSAF_GPU_READ|CSAF_GPU_WRITE))
); \
D_ASSUME( (lock)->offset == (lock)->allocation->offset || (l
ock)->offset == ~0 ); \
D_ASSERT( (lock)->pitch > 0 );
\
}
\
else {
\
D_ASSERT( (lock)->allocation == NULL );
\
D_ASSERT( (lock)->addr == NULL );
\
D_ASSERT( (lock)->phys == 0 );
\
D_ASSERT( (lock)->offset == ~0 );
\
D_ASSERT( (lock)->pitch == 0 );
\
D_ASSERT( (lock)->handle == NULL );
\
}
\
} while (0) } while (0)
/* /*
* A Surface Buffer of a Surface * A Surface Buffer of a Surface
*/ */
struct __DFB_CoreSurfaceBuffer { struct __DFB_CoreSurfaceBuffer {
int magic; int magic;
DirectSerial serial; /* Increased when content is w ritten. */ DirectSerial serial; /* Increased when content is w ritten. */
CoreSurfaceAllocation *written; /* Allocation with the last wr ite access. */ CoreSurfaceAllocation *written; /* Allocation with the last wr ite access. */
skipping to change at line 198 skipping to change at line 233
for (index=0; index<MAX_SURFACE_BUFFERS; index++) { for (index=0; index<MAX_SURFACE_BUFFERS; index++) {
if (surface->buffers[index] == buffer) if (surface->buffers[index] == buffer)
return index; return index;
} }
D_ASSERT( index<MAX_SURFACE_BUFFERS ); D_ASSERT( index<MAX_SURFACE_BUFFERS );
return 0; return 0;
} }
DFBResult dfb_surface_allocation_update( CoreSurfaceAllocation *allocation
,
CoreSurfaceAccessFlags access );
#endif #endif
 End of changes. 9 change blocks. 
38 lines changed or deleted 89 lines changed or added


 surface_pool.h   surface_pool.h 
skipping to change at line 155 skipping to change at line 155
const DFBRectangle *rect ); const DFBRectangle *rect );
DFBResult (*Write) ( CoreSurfacePool *pool, DFBResult (*Write) ( CoreSurfacePool *pool,
void *pool_data, void *pool_data,
void *pool_local, void *pool_local,
CoreSurfaceAllocation *allocation, CoreSurfaceAllocation *allocation,
void *alloc_data, void *alloc_data,
const void *source, const void *source,
int pitch, int pitch,
const DFBRectangle *rect ); const DFBRectangle *rect );
/*
* Muck out
*/
DFBResult (*MuckOut) ( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceBuffer *buffer );
} SurfacePoolFuncs; } SurfacePoolFuncs;
struct __DFB_CoreSurfacePool { struct __DFB_CoreSurfacePool {
int magic; int magic;
FusionSkirmish lock; FusionSkirmish lock;
CoreSurfacePoolID pool_id; CoreSurfacePoolID pool_id;
CoreSurfacePoolDescription desc; CoreSurfacePoolDescription desc;
int pool_data_size; int pool_data_size;
int pool_local_data_size; int pool_local_data_size;
int alloc_data_size; int alloc_data_size;
void *data; void *data;
FusionVector allocs; FusionVector allocs;
FusionSHMPoolShared *shmpool; FusionSHMPoolShared *shmpool;
CoreSurfacePool *backup;
}; };
typedef DFBEnumerationResult (*CoreSurfacePoolCallback)( CoreSurfacePool *p ool, typedef DFBEnumerationResult (*CoreSurfacePoolCallback)( CoreSurfacePool *p ool,
void *c tx ); void *c tx );
typedef DFBEnumerationResult (*CoreSurfaceAllocCallback)( CoreSurfaceAlloca tion *allocation, typedef DFBEnumerationResult (*CoreSurfaceAllocCallback)( CoreSurfaceAlloca tion *allocation,
void *ctx ); void *ctx );
DFBResult dfb_surface_pools_negotiate( CoreSurfaceBuffer *buffer, DFBResult dfb_surface_pools_negotiate( CoreSurfaceBuffer *buffer,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
CoreSurfacePool **ret_pool ); CoreSurfacePool **ret_pools,
unsigned int max_pools,
unsigned int *ret_num );
DFBResult dfb_surface_pools_enumerate( CoreSurfacePoolCallback callback, DFBResult dfb_surface_pools_enumerate( CoreSurfacePoolCallback callback,
void *ctx ); void *ctx );
DFBResult dfb_surface_pools_allocate ( CoreSurfaceBuffer *buffer,
CoreSurfaceAccessFlags access,
CoreSurfaceAllocation **ret_allocat
ion );
DFBResult dfb_surface_pool_initialize( CoreDFB *core, DFBResult dfb_surface_pool_initialize( CoreDFB *core,
const SurfacePoolFuncs *funcs, const SurfacePoolFuncs *funcs,
CoreSurfacePool **ret_pool ); CoreSurfacePool **ret_pool );
DFBResult dfb_surface_pool_join ( CoreDFB *core, DFBResult dfb_surface_pool_join ( CoreDFB *core,
CoreSurfacePool *pool, CoreSurfacePool *pool,
const SurfacePoolFuncs *funcs ); const SurfacePoolFuncs *funcs );
DFBResult dfb_surface_pool_destroy ( CoreSurfacePool *pool ); DFBResult dfb_surface_pool_destroy ( CoreSurfacePool *pool );
DFBResult dfb_surface_pool_leave ( CoreSurfacePool *pool ); DFBResult dfb_surface_pool_leave ( CoreSurfacePool *pool );
DFBResult dfb_surface_pool_allocate ( CoreSurfacePool *pool, DFBResult dfb_surface_pool_allocate ( CoreSurfacePool *pool,
CoreSurfaceBuffer *buffer, CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation **ret_allocat ion ); CoreSurfaceAllocation **ret_allocat ion );
DFBResult dfb_surface_pool_deallocate( CoreSurfacePool *pool, DFBResult dfb_surface_pool_deallocate( CoreSurfacePool *pool,
CoreSurfaceAllocation *allocation ); CoreSurfaceAllocation *allocation );
DFBResult dfb_surface_pool_displace ( CoreSurfacePool *pool,
CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation **ret_allocat
ion );
DFBResult dfb_surface_pool_lock ( CoreSurfacePool *pool, DFBResult dfb_surface_pool_lock ( CoreSurfacePool *pool,
CoreSurfaceAllocation *allocation, CoreSurfaceAllocation *allocation,
CoreSurfaceBufferLock *lock ); CoreSurfaceBufferLock *lock );
DFBResult dfb_surface_pool_unlock ( CoreSurfacePool *pool, DFBResult dfb_surface_pool_unlock ( CoreSurfacePool *pool,
CoreSurfaceAllocation *allocation, CoreSurfaceAllocation *allocation,
CoreSurfaceBufferLock *lock ); CoreSurfaceBufferLock *lock );
DFBResult dfb_surface_pool_enumerate ( CoreSurfacePool *pool, DFBResult dfb_surface_pool_enumerate ( CoreSurfacePool *pool,
CoreSurfaceAllocCallback callback, CoreSurfaceAllocCallback callback,
 End of changes. 5 change blocks. 
1 lines changed or deleted 23 lines changed or added


 surfacemanager.h   surfacemanager.h 
skipping to change at line 55 skipping to change at line 55
int magic; int magic;
int offset; /* offset in memory, int offset; /* offset in memory,
is greater or equal to the heap o ffset */ is greater or equal to the heap o ffset */
int length; /* length of this chunk in bytes */ int length; /* length of this chunk in bytes */
int pitch; int pitch;
CoreSurfaceBuffer *buffer; /* pointer to surface buffer occupyi ng CoreSurfaceBuffer *buffer; /* pointer to surface buffer occupyi ng
this chunk, or NULL if chunk is f ree */ this chunk, or NULL if chunk is f ree */
CoreSurfaceAllocation *allocation;
int tolerations; /* number of times this chunk was sc anned int tolerations; /* number of times this chunk was sc anned
occupied, resetted in assure_vide o */ occupied, resetted in assure_vide o */
Chunk *prev; Chunk *prev;
Chunk *next; Chunk *next;
}; };
struct _SurfaceManager {
int magic;
FusionSHMPoolShared *shmpool;
Chunk *chunks;
int offset;
int length; /* length of the heap in bytes */
int avail; /* amount of available memory in
bytes */
int min_toleration;
bool suspended;
};
DFBResult dfb_surfacemanager_create ( CoreDFB *core, DFBResult dfb_surfacemanager_create ( CoreDFB *core,
unsigned int length, unsigned int length,
SurfaceManager **ret_manager ); SurfaceManager **ret_manager );
void dfb_surfacemanager_destroy( SurfaceManager *manager ); void dfb_surfacemanager_destroy( SurfaceManager *manager );
/* /*
* finds and allocates one for the surface or fails, * finds and allocates one for the surface or fails,
* after success the video health is CSH_RESTORE. * after success the video health is CSH_RESTORE.
* NOTE: this does not notify the listeners * NOTE: this does not notify the listeners
*/ */
DFBResult dfb_surfacemanager_allocate( CoreDFB *core, DFBResult dfb_surfacemanager_allocate( CoreDFB *core,
SurfaceManager *manager, SurfaceManager *manager,
CoreSurfaceBuffer *buffer, CoreSurfaceBuffer *buffer,
Chunk **ret_chunk ); CoreSurfaceAllocation *allocation,
Chunk **ret_chunk );
DFBResult dfb_surfacemanager_displace( CoreDFB *core,
SurfaceManager *manager,
CoreSurfaceBuffer *buffer );
/* /*
* sets the video health to CSH_INVALID frees the chunk and * sets the video health to CSH_INVALID frees the chunk and
* notifies the listeners * notifies the listeners
*/ */
DFBResult dfb_surfacemanager_deallocate( SurfaceManager *manager, DFBResult dfb_surfacemanager_deallocate( SurfaceManager *manager,
Chunk *chunk ); Chunk *chunk );
#endif #endif
 End of changes. 3 change blocks. 
4 lines changed or deleted 27 lines changed or added


 windows_internal.h   windows_internal.h 
skipping to change at line 105 skipping to change at line 105
CoreGraphicsSerial serial1; CoreGraphicsSerial serial1;
CoreGraphicsSerial serial2; CoreGraphicsSerial serial2;
DirectLink *bound_windows; /* list of bound windows */ DirectLink *bound_windows; /* list of bound windows */
CoreWindow *boundto; /* window to which this window is bound */ CoreWindow *boundto; /* window to which this window is bound */
DFBWindowID parent_id; /* window id of parent window */ DFBWindowID parent_id; /* window id of parent window */
}; };
typedef enum {
CWSF_NONE = 0x00000000,
CWSF_INITIALIZED = 0x00000001,
CWSF_ACTIVATED = 0x00000002,
CWSF_ALL = 0x00000003
} CoreWindowStackFlags;
/* /*
* Core data of a window stack. * Core data of a window stack.
*/ */
struct __DFB_CoreWindowStack { struct __DFB_CoreWindowStack {
DirectLink link; DirectLink link;
int magic; int magic;
CoreLayerContext *context; CoreLayerContext *context;
skipping to change at line 162 skipping to change at line 171
GlobalReaction image_reaction; GlobalReaction image_reaction;
} bg; } bg;
DirectLink *devices; /* input devices attached to the st ack */ DirectLink *devices; /* input devices attached to the st ack */
bool hw_mode; /* recompositing is done by hardwar e */ bool hw_mode; /* recompositing is done by hardwar e */
void *stack_data; /* private data of window manager * / void *stack_data; /* private data of window manager * /
FusionSHMPoolShared *shmpool; FusionSHMPoolShared *shmpool;
CoreWindowStackFlags flags;
}; };
DFBResult dfb_wm_close_all_stacks( void *data ); DFBResult dfb_wm_close_all_stacks( void *data );
/* global reactions */ /* global reactions */
ReactionResult _dfb_windowstack_inputdevice_listener ( const void *msg_ data, ReactionResult _dfb_windowstack_inputdevice_listener ( const void *msg_ data,
void *ctx ); void *ctx );
ReactionResult _dfb_windowstack_background_image_listener( const void *msg_ data, ReactionResult _dfb_windowstack_background_image_listener( const void *msg_ data,
void *ctx ); void *ctx );
 End of changes. 2 change blocks. 
0 lines changed or deleted 11 lines changed or added


 wm.h   wm.h 
skipping to change at line 279 skipping to change at line 279
void *stack_data, void *stack_data,
CoreCursorUpdateFlags flags ); CoreCursorUpdateFlags flags );
} CoreWMFuncs; } CoreWMFuncs;
void dfb_wm_get_info( CoreWMInfo *info ); void dfb_wm_get_info( CoreWMInfo *info );
DFBResult dfb_wm_post_init ( CoreDFB *core ); DFBResult dfb_wm_post_init ( CoreDFB *core );
DFBResult dfb_wm_init_stack ( CoreWindowStack *stack ); DFBResult dfb_wm_init_stack ( CoreWindowStack *stack );
DFBResult dfb_wm_close_stack ( CoreWindowStack *stack, DFBResult dfb_wm_close_stack ( CoreWindowStack *stack );
bool final );
DFBResult dfb_wm_set_active ( CoreWindowStack *stack, DFBResult dfb_wm_set_active ( CoreWindowStack *stack,
bool active ); bool active );
DFBResult dfb_wm_resize_stack ( CoreWindowStack *stack, DFBResult dfb_wm_resize_stack ( CoreWindowStack *stack,
int width, int width,
int height ); int height );
DFBResult dfb_wm_process_input ( CoreWindowStack *stack, DFBResult dfb_wm_process_input ( CoreWindowStack *stack,
const DFBInputEvent *event ); const DFBInputEvent *event );
 End of changes. 1 change blocks. 
2 lines changed or deleted 1 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/