CoreDFB_includes.h		CoreDFB_includes.h
	skipping to change at line 15		skipping to change at line 15
	extern "C" {		extern "C" {
	#endif		#endif
	#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 <core/core.h>		#include <core/core.h>
			#include <core/graphics_state.h>
	#include <core/layer_context.h>		#include <core/layer_context.h>
	#include <core/layer_control.h>		#include <core/layer_control.h>
	#include <core/layers_internal.h>		#include <core/layers_internal.h>
	#include <core/palette.h>		#include <core/palette.h>
	#include <core/state.h>		#include <core/state.h>
	#include <core/surface.h>		#include <core/surface.h>
	#include <core/windows.h>		#include <core/windows.h>
	#include <core/windows_internal.h>		#include <core/windows_internal.h>
	static __inline__ DirectResult		static __inline__ DirectResult
	skipping to change at line 37		skipping to change at line 38
	int call_arg,		int call_arg,
	void *ptr,		void *ptr,
	unsigned int length,		unsigned int length,
	void *ret_ptr,		void *ret_ptr,
	unsigned int ret_size,		unsigned int ret_size,
	unsigned int *ret_length )		unsigned int *ret_length )
	{		{
	return fusion_call_execute3( &core->shared->call, flags, call_arg, ptr , length, ret_ptr, ret_size, ret_length );		return fusion_call_execute3( &core->shared->call, flags, call_arg, ptr , length, ret_ptr, ret_size, ret_length );
	}		}
			static __inline__ u32
			CoreGraphicsState_GetID( const CoreGraphicsState *state )
			{
			return state->object.id;
			}
			static __inline__ DirectResult
			CoreGraphicsState_Lookup( CoreDFB *core,
			u32 object_id,
			FusionID caller,
			CoreGraphicsState **ret_state )
			{
			DFBResult ret;
			CoreGraphicsState *state;
			ret = dfb_core_get_graphics_state( core, object_id, &state );
			if (ret)
			return (DirectResult) ret;
			if (state->object.owner && state->object.owner != caller) {
			dfb_graphics_state_unref( state );
			return DR_ACCESSDENIED;
			}
			*ret_state = state;
			return DR_OK;
			}
			static __inline__ DirectResult
			CoreGraphicsState_Unref( CoreGraphicsState *state )
			{
			return (DirectResult) dfb_graphics_state_unref( state );
			}
			static __inline__ DirectResult
			CoreGraphicsState_Catch( CoreDFB *core,
			u32 object_id,
			CoreGraphicsState **ret_state )
			{
			DirectResult ret;
			ret = (DirectResult) dfb_core_get_graphics_state( core, object_id, ret
			_state );
			if (ret)
			return ret;
			fusion_ref_catch( &(*ret_state)->object.ref );
			return DR_OK;
			}
			static __inline__ DirectResult
			CoreGraphicsState_Throw( CoreGraphicsState *state,
			FusionID catcher,
			u32 *ret_object_id )
			{
			*ret_object_id = state->object.id;
			fusion_reactor_add_permissions( state->object.reactor, catcher,
			(FusionReactorPermissions)(FUSION_REAC
			TOR_PERMIT_ATTACH_DETACH) );
			fusion_ref_add_permissions( &state->object.ref, catcher,
			(FusionRefPermissions)(FUSION_REF_PERMIT_R
			EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
			fusion_call_add_permissions( &state->call, catcher, FUSION_CALL_PERMIT
			_EXECUTE );
			if (!state->object.owner)
			state->object.owner = catcher;
			return fusion_ref_throw( &state->object.ref, catcher );
			}
			static __inline__ u32
			CoreLayer_GetID( const CoreLayer *layer )
			{
			return dfb_layer_id( layer );
			}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayer_Lookup( CoreDFB *core,		CoreLayer_Lookup( CoreDFB *core,
	u32 object_id,		u32 object_id,
			FusionID caller,
	CoreLayer **ret_layer )		CoreLayer **ret_layer )
	{		{
	if (object_id >= (u32) dfb_layer_num())		if (object_id >= (u32) dfb_layer_num())
	return DR_IDNOTFOUND;		return DR_IDNOTFOUND;
	*ret_layer = dfb_layer_at( object_id );		*ret_layer = dfb_layer_at( object_id );
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayer_Unref( CoreLayerContext *context )		CoreLayer_Unref( CoreLayer *layer )
	{		{
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayer_Catch( CoreDFB *core,		CoreLayer_Catch( CoreDFB *core,
	u32 object_id,		u32 object_id,
	CoreLayer **ret_layer )		CoreLayer **ret_layer )
	{		{
	if (object_id >= (u32) dfb_layer_num())		if (object_id >= (u32) dfb_layer_num())
	skipping to change at line 79		skipping to change at line 157
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayer_Throw( CoreLayer *layer,		CoreLayer_Throw( CoreLayer *layer,
	FusionID catcher,		FusionID catcher,
	u32 *ret_object_id )		u32 *ret_object_id )
	{		{
	*ret_object_id = layer->shared->layer_id;		*ret_object_id = layer->shared->layer_id;
	return DR_OK;		return DR_OK;
	}		}
			static __inline__ u32
			CoreLayerContext_GetID( const CoreLayerContext *context )
			{
			return context->object.id;
			}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerContext_Lookup( CoreDFB *core,		CoreLayerContext_Lookup( CoreDFB *core,
	u32 object_id,		u32 object_id,
			FusionID caller,
	CoreLayerContext **ret_context )		CoreLayerContext **ret_context )
	{		{
	return (DirectResult) dfb_core_get_layer_context( core, object_id, ret		DFBResult ret;
	_context );		CoreLayerContext *context;
			ret = dfb_core_get_layer_context( core, object_id, &context );
			if (ret)
			return (DirectResult) ret;
			if (context->object.owner && context->object.owner != caller) {
			dfb_layer_context_unref( context );
			return DR_ACCESSDENIED;
			}
			*ret_context = context;
			return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerContext_Unref( CoreLayerContext *context )		CoreLayerContext_Unref( CoreLayerContext *context )
	{		{
	return (DirectResult) dfb_layer_context_unref( context );		return (DirectResult) dfb_layer_context_unref( context );
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerContext_Catch( CoreDFB *core,		CoreLayerContext_Catch( CoreDFB *core,
	skipping to change at line 116		skipping to change at line 215
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerContext_Throw( CoreLayerContext *context,		CoreLayerContext_Throw( CoreLayerContext *context,
	FusionID catcher,		FusionID catcher,
	u32 *ret_object_id )		u32 *ret_object_id )
	{		{
	*ret_object_id = context->object.id;		*ret_object_id = context->object.id;
			fusion_reactor_add_permissions( context->object.reactor, catcher,
			(FusionReactorPermissions)(FUSION_REAC
			TOR_PERMIT_ATTACH_DETACH) );
			fusion_ref_add_permissions( &context->object.ref, catcher,
			(FusionRefPermissions)(FUSION_REF_PERMIT_R
			EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
			fusion_call_add_permissions( &context->call, catcher, FUSION_CALL_PERM
			IT_EXECUTE );
			if (context->stack)
			fusion_call_add_permissions( &context->stack->call, catcher, FUSI
			ON_CALL_PERMIT_EXECUTE );
	return fusion_ref_throw( &context->object.ref, catcher );		return fusion_ref_throw( &context->object.ref, catcher );
	}		}
			static __inline__ u32
			CoreLayerRegion_GetID( const CoreLayerRegion *region )
			{
			return region->object.id;
			}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerRegion_Lookup( CoreDFB *core,		CoreLayerRegion_Lookup( CoreDFB *core,
	u32 object_id,		u32 object_id,
			FusionID caller,
	CoreLayerRegion **ret_region )		CoreLayerRegion **ret_region )
	{		{
	return (DirectResult) dfb_core_get_layer_region( core, object_id, ret_		DFBResult ret;
	region );		CoreLayerRegion *region;
			ret = dfb_core_get_layer_region( core, object_id, &region );
			if (ret)
			return (DirectResult) ret;
			if (region->object.owner && region->object.owner != caller) {
			dfb_layer_region_unref( region );
			return DR_ACCESSDENIED;
			}
			*ret_region = region;
			return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerRegion_Unref( CoreLayerRegion *region )		CoreLayerRegion_Unref( CoreLayerRegion *region )
	{		{
	return (DirectResult) dfb_layer_region_unref( region );		return (DirectResult) dfb_layer_region_unref( region );
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerRegion_Catch( CoreDFB *core,		CoreLayerRegion_Catch( CoreDFB *core,
	skipping to change at line 156		skipping to change at line 285
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreLayerRegion_Throw( CoreLayerRegion *region,		CoreLayerRegion_Throw( CoreLayerRegion *region,
	FusionID catcher,		FusionID catcher,
	u32 *ret_object_id )		u32 *ret_object_id )
	{		{
	*ret_object_id = region->object.id;		*ret_object_id = region->object.id;
			fusion_reactor_add_permissions( region->object.reactor, catcher,
			(FusionReactorPermissions)(FUSION_REAC
			TOR_PERMIT_ATTACH_DETACH) );
			fusion_ref_add_permissions( &region->object.ref, catcher,
			(FusionRefPermissions)(FUSION_REF_PERMIT_R
			EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
			fusion_call_add_permissions( &region->call, catcher, FUSION_CALL_PERMI
			T_EXECUTE );
	return fusion_ref_throw( &region->object.ref, catcher );		return fusion_ref_throw( &region->object.ref, catcher );
	}		}
			static __inline__ u32
			CorePalette_GetID( const CorePalette *palette )
			{
			return palette->object.id;
			}
	static __inline__ DirectResult		static __inline__ DirectResult
	CorePalette_Lookup( CoreDFB *core,		CorePalette_Lookup( CoreDFB *core,
	u32 object_id,		u32 object_id,
			FusionID caller,
	CorePalette **ret_palette )		CorePalette **ret_palette )
	{		{
	return (DirectResult) dfb_core_get_palette( core, object_id, ret_palet		DFBResult ret;
	te );		CorePalette *palette;
			ret = dfb_core_get_palette( core, object_id, &palette );
			if (ret)
			return (DirectResult) ret;
			if (palette->object.owner && palette->object.owner != caller) {
			dfb_palette_unref( palette );
			return DR_ACCESSDENIED;
			}
			*ret_palette = palette;
			return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CorePalette_Unref( CorePalette *palette )		CorePalette_Unref( CorePalette *palette )
	{		{
	return (DirectResult) dfb_palette_unref( palette );		return (DirectResult) dfb_palette_unref( palette );
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CorePalette_Catch( CoreDFB *core,		CorePalette_Catch( CoreDFB *core,
	skipping to change at line 196		skipping to change at line 352
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CorePalette_Throw( CorePalette *palette,		CorePalette_Throw( CorePalette *palette,
	FusionID catcher,		FusionID catcher,
	u32 *ret_object_id )		u32 *ret_object_id )
	{		{
	*ret_object_id = palette->object.id;		*ret_object_id = palette->object.id;
			fusion_reactor_add_permissions( palette->object.reactor, catcher,
			(FusionReactorPermissions)(FUSION_REAC
			TOR_PERMIT_ATTACH_DETACH) );
			fusion_ref_add_permissions( &palette->object.ref, catcher,
			(FusionRefPermissions)(FUSION_REF_PERMIT_R
			EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
			fusion_call_add_permissions( &palette->call, catcher, FUSION_CALL_PERM
			IT_EXECUTE );
			if (!palette->object.owner)
			palette->object.owner = catcher;
	return fusion_ref_throw( &palette->object.ref, catcher );		return fusion_ref_throw( &palette->object.ref, catcher );
	}		}
			static __inline__ u32
			CoreSurface_GetID( const CoreSurface *surface )
			{
			return surface->object.id;
			}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreSurface_Lookup( CoreDFB *core,		CoreSurface_Lookup( CoreDFB *core,
	u32 object_id,		u32 object_id,
			FusionID caller,
	CoreSurface **ret_surface )		CoreSurface **ret_surface )
	{		{
	return (DirectResult) dfb_core_get_surface( core, object_id, ret_surfa		DFBResult ret;
	ce );		CoreSurface *surface;
			ret = dfb_core_get_surface( core, object_id, &surface );
			if (ret)
			return (DirectResult) ret;
			if (surface->object.owner && surface->object.owner != caller) {
			dfb_surface_unref( surface );
			return DR_ACCESSDENIED;
			}
			*ret_surface = surface;
			return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreSurface_Unref( CoreSurface *surface )		CoreSurface_Unref( CoreSurface *surface )
	{		{
	return (DirectResult) dfb_surface_unref( surface );		return (DirectResult) dfb_surface_unref( surface );
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreSurface_Catch( CoreDFB *core,		CoreSurface_Catch( CoreDFB *core,
	skipping to change at line 236		skipping to change at line 422
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreSurface_Throw( CoreSurface *surface,		CoreSurface_Throw( CoreSurface *surface,
	FusionID catcher,		FusionID catcher,
	u32 *ret_object_id )		u32 *ret_object_id )
	{		{
	*ret_object_id = surface->object.id;		*ret_object_id = surface->object.id;
			fusion_reactor_add_permissions( surface->object.reactor, catcher,
			(FusionReactorPermissions)(FUSION_REAC
			TOR_PERMIT_ATTACH_DETACH) );
			fusion_ref_add_permissions( &surface->object.ref, catcher,
			(FusionRefPermissions)(FUSION_REF_PERMIT_R
			EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
			fusion_call_add_permissions( &surface->call, catcher, FUSION_CALL_PERM
			IT_EXECUTE );
			if (!surface->object.owner)
			surface->object.owner = catcher;
	return fusion_ref_throw( &surface->object.ref, catcher );		return fusion_ref_throw( &surface->object.ref, catcher );
	}		}
			static __inline__ u32
			CoreWindow_GetID( const CoreWindow *window )
			{
			return window->object.id;
			}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreWindow_Lookup( CoreDFB *core,		CoreWindow_Lookup( CoreDFB *core,
	u32 object_id,		u32 object_id,
			FusionID caller,
	CoreWindow **ret_window )		CoreWindow **ret_window )
	{		{
	return (DirectResult) dfb_core_get_window( core, object_id, ret_window		DFBResult ret;
	);		CoreWindow *window;
			ret = dfb_core_get_window( core, object_id, &window );
			if (ret)
			return (DirectResult) ret;
			if (window->object.owner && window->object.owner != caller) {
			dfb_window_unref( window );
			return DR_ACCESSDENIED;
			}
			*ret_window = window;
			return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreWindow_Unref( CoreWindow *window )		CoreWindow_Unref( CoreWindow *window )
	{		{
	return (DirectResult) dfb_window_unref( window );		return (DirectResult) dfb_window_unref( window );
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreWindow_Catch( CoreDFB *core,		CoreWindow_Catch( CoreDFB *core,
	skipping to change at line 276		skipping to change at line 492
	return DR_OK;		return DR_OK;
	}		}
	static __inline__ DirectResult		static __inline__ DirectResult
	CoreWindow_Throw( CoreWindow *window,		CoreWindow_Throw( CoreWindow *window,
	FusionID catcher,		FusionID catcher,
	u32 *ret_object_id )		u32 *ret_object_id )
	{		{
	*ret_object_id = window->object.id;		*ret_object_id = window->object.id;
	return fusion_ref_throw( &window->object.ref, catcher );		fusion_reactor_add_permissions( window->object.reactor, catcher,
	}		(FusionReactorPermissions)(FUSION_REAC
			TOR_PERMIT_ATTACH_DETACH | FUSION_REACTOR_PERMIT_DISPATCH) );
	struct __DFB_CoreGraphicsState {		fusion_ref_add_permissions( &window->object.ref, catcher,
	int magic;		(FusionRefPermissions)(FUSION_REF_PERMIT_R
			EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
	CoreDFB *core;		fusion_call_add_permissions( &window->call, catcher, FUSION_CALL_PERMI
			T_EXECUTE );
	FusionCall call;
	CardState state;
	};
	static __inline__ DirectResult
	CoreGraphicsState_Lookup( CoreDFB *core,
	u32 object_id,
	CoreGraphicsState **ret_state )
	{
	return DR_UNSUPPORTED;
	}
	static __inline__ DirectResult
	CoreGraphicsState_Unref( CoreWindow *window )
	{
	return DR_UNSUPPORTED;
	}
	static __inline__ DirectResult
	CoreGraphicsState_Catch( CoreDFB *core,
	u32 object_id,
	CoreGraphicsState **ret_state )
	{
	CoreGraphicsState *state;
	state = (CoreGraphicsState*) D_CALLOC( 1, sizeof(CoreGraphicsState) );
	if (!state)
	return D_OOM();
	state->core = core;
	// state->state is not used on client side, FIXME: find better integra
	tion for local/proxy objects
	fusion_call_init_from( &state->call, object_id, core->world );
	D_MAGIC_SET( state, CoreGraphicsState );
	*ret_state = state;
	return DR_OK;
	}
	static __inline__ DirectResult		if (!window->object.owner)
	CoreGraphicsState_Throw( CoreGraphicsState *state,		window->object.owner = catcher;
	FusionID catcher,
	u32 *ret_object_id )
	{
	*ret_object_id = state->call.call_id;
	return DR_OK;		return fusion_ref_throw( &window->object.ref, catcher );
	}		}
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif		#endif
End of changes. 26 change blocks.
	67 lines changed or deleted		250 lines changed or added

	CoreGraphicsStateClient.h		CoreGraphicsStateClient.h
	skipping to change at line 52		skipping to change at line 52
	CoreDFB *core;		CoreDFB *core;
	CardState *state;		CardState *state;
	CoreGraphicsState *gfx_state;		CoreGraphicsState *gfx_state;
	};		};
	DFBResult CoreGraphicsStateClient_Init ( CoreGraphicsStateClient *client,		DFBResult CoreGraphicsStateClient_Init ( CoreGraphicsStateClient *client,
	CardState *state );		CardState *state );
			void CoreGraphicsStateClient_Deinit ( CoreGraphicsStateClient
			*client );
	DFBResult CoreGraphicsStateClient_SetState ( CoreGraphicsStateClient *client,		DFBResult CoreGraphicsStateClient_SetState ( CoreGraphicsStateClient *client,
	CardState *state,		CardState *state,
	StateModificationFlags flags );		StateModificationFlags flags );
	DFBResult CoreGraphicsStateClient_Update ( CoreGraphicsStateClient *client,		DFBResult CoreGraphicsStateClient_Update ( CoreGraphicsStateClient *client,
	DFBAccelerationMask accel,		DFBAccelerationMask accel,
	CardState *state );		CardState *state );
	DFBResult CoreGraphicsStateClient_DrawRectangles ( CoreGraphicsStateClient *client,		DFBResult CoreGraphicsStateClient_DrawRectangles ( CoreGraphicsStateClient *client,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	unsigned int num );		unsigned int num );
End of changes. 1 change blocks.
	0 lines changed or deleted		3 lines changed or added

	CoreLayer.h		CoreLayer.h
	skipping to change at line 52		skipping to change at line 52
	#endif		#endif
	DFBResult CoreLayer_CreateContext(		DFBResult CoreLayer_CreateContext(
	CoreLayer *obj,		CoreLayer *obj,
	CoreLayerContext **ret_context) ;		CoreLayerContext **ret_context) ;
	DFBResult CoreLayer_ActivateContext(		DFBResult CoreLayer_ActivateContext(
	CoreLayer *obj,		CoreLayer *obj,
	CoreLayerContext *context);		CoreLayerContext *context);
			DFBResult CoreLayer_GetPrimaryContext(
			CoreLayer *obj,
			bool activate,
			CoreLayerContext **ret_context)
			;
	void *CoreLayer_Init_Dispatch(		void *CoreLayer_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreLayer *obj,		CoreLayer *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreLayer_Deinit_Dispatch(		void CoreLayer_Deinit_Dispatch(
	void *dispatch		void *dispatch
	);		);
	skipping to change at line 73		skipping to change at line 78
	}		}
	namespace DirectFB {		namespace DirectFB {
	/*		/*
	* CoreLayer Calls		* CoreLayer Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreLayer_CreateContext = 1,		CoreLayer_CreateContext = 1,
	CoreLayer_ActivateContext = 2,		CoreLayer_ActivateContext = 2,
			CoreLayer_GetPrimaryContext = 3,
	} CoreLayerCall;		} CoreLayerCall;
	/*		/*
	* CoreLayer_CreateContext		* CoreLayer_CreateContext
	*/		*/
	typedef struct {		typedef struct {
	} CoreLayerCreateContext;		} CoreLayerCreateContext;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	skipping to change at line 97		skipping to change at line 103
	* CoreLayer_ActivateContext		* CoreLayer_ActivateContext
	*/		*/
	typedef struct {		typedef struct {
	u32 context_id;		u32 context_id;
	} CoreLayerActivateContext;		} CoreLayerActivateContext;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreLayerActivateContextReturn;		} CoreLayerActivateContextReturn;
			/*
			* CoreLayer_GetPrimaryContext
			*/
			typedef struct {
			bool activate;
			} CoreLayerGetPrimaryContext;
			typedef struct {
			DFBResult result;
			u32 context_id;
			} CoreLayerGetPrimaryContextReturn;
	class ILayer : public Interface		class ILayer : public Interface
	{		{
	public:		public:
	ILayer( CoreDFB *core )		ILayer( CoreDFB *core )
	:		:
	Interface( core )		Interface( core )
	{		{
	}		}
	public:		public:
	virtual DFBResult CreateContext(		virtual DFBResult CreateContext(
	CoreLayerContext **ret_context		CoreLayerContext **ret_context
	) = 0;		) = 0;
	virtual DFBResult ActivateContext(		virtual DFBResult ActivateContext(
	CoreLayerContext *context		CoreLayerContext *context
	) = 0;		) = 0;
			virtual DFBResult GetPrimaryContext(
			bool activate,
			CoreLayerContext **ret_context
			) = 0;
	};		};
	class ILayer_Real : public ILayer		class ILayer_Real : public ILayer
	{		{
	private:		private:
	CoreLayer *obj;		CoreLayer *obj;
	public:		public:
	ILayer_Real( CoreDFB *core, CoreLayer *obj )		ILayer_Real( CoreDFB *core, CoreLayer *obj )
	:		:
	skipping to change at line 139		skipping to change at line 162
	public:		public:
	virtual DFBResult CreateContext(		virtual DFBResult CreateContext(
	CoreLayerContext **ret_context		CoreLayerContext **ret_context
	);		);
	virtual DFBResult ActivateContext(		virtual DFBResult ActivateContext(
	CoreLayerContext *context		CoreLayerContext *context
	);		);
			virtual DFBResult GetPrimaryContext(
			bool activate,
			CoreLayerContext **ret_context
			);
	};		};
	class ILayer_Requestor : public ILayer		class ILayer_Requestor : public ILayer
	{		{
	private:		private:
	CoreLayer *obj;		CoreLayer *obj;
	public:		public:
	ILayer_Requestor( CoreDFB *core, CoreLayer *obj )		ILayer_Requestor( CoreDFB *core, CoreLayer *obj )
	:		:
	skipping to change at line 163		skipping to change at line 191
	public:		public:
	virtual DFBResult CreateContext(		virtual DFBResult CreateContext(
	CoreLayerContext **ret_context		CoreLayerContext **ret_context
	);		);
	virtual DFBResult ActivateContext(		virtual DFBResult ActivateContext(
	CoreLayerContext *context		CoreLayerContext *context
	);		);
			virtual DFBResult GetPrimaryContext(
			bool activate,
			CoreLayerContext **ret_context
			);
	};		};
	class CoreLayerDispatch		class CoreLayerDispatch
	{		{
	public:		public:
	CoreLayerDispatch( CoreDFB *core, ILayer *real )		CoreLayerDispatch( CoreDFB *core, ILayer *real )
	:		:
	core( core ),		core( core ),
	real( real )		real( real )
End of changes. 6 change blocks.
	0 lines changed or deleted		34 lines changed or added

	CoreLayerContext.h		CoreLayerContext.h
	skipping to change at line 47		skipping to change at line 47
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	DFBResult CoreLayerContext_CreateWindow(		DFBResult CoreLayerContext_CreateWindow(
	CoreLayerContext *obj,		CoreLayerContext *obj,
	const DFBWindowDescription *description,		const DFBWindowDescription *description,
			CoreWindow *parent,
			CoreWindow *toplevel,
	CoreWindow **ret_window);		CoreWindow **ret_window);
	DFBResult CoreLayerContext_SetConfiguration(		DFBResult CoreLayerContext_SetConfiguration(
	CoreLayerContext *obj,		CoreLayerContext *obj,
	const DFBDisplayLayerConfig *config);		const DFBDisplayLayerConfig *config);
	DFBResult CoreLayerContext_GetPrimaryRegion(		DFBResult CoreLayerContext_GetPrimaryRegion(
	CoreLayerContext *obj,		CoreLayerContext *obj,
	bool create,		bool create,
	CoreLayerRegion **ret_region);		CoreLayerRegion **ret_region);
	skipping to change at line 87		skipping to change at line 89
	CoreLayerContext_CreateWindow = 1,		CoreLayerContext_CreateWindow = 1,
	CoreLayerContext_SetConfiguration = 2,		CoreLayerContext_SetConfiguration = 2,
	CoreLayerContext_GetPrimaryRegion = 3,		CoreLayerContext_GetPrimaryRegion = 3,
	} CoreLayerContextCall;		} CoreLayerContextCall;
	/*		/*
	* CoreLayerContext_CreateWindow		* CoreLayerContext_CreateWindow
	*/		*/
	typedef struct {		typedef struct {
	DFBWindowDescription description;		DFBWindowDescription description;
			bool parent_set;
			u32 parent_id;
			bool toplevel_set;
			u32 toplevel_id;
	} CoreLayerContextCreateWindow;		} CoreLayerContextCreateWindow;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 window_id;		u32 window_id;
	} CoreLayerContextCreateWindowReturn;		} CoreLayerContextCreateWindowReturn;
	/*		/*
	* CoreLayerContext_SetConfiguration		* CoreLayerContext_SetConfiguration
	*/		*/
	skipping to change at line 129		skipping to change at line 135
	public:		public:
	ILayerContext( CoreDFB *core )		ILayerContext( CoreDFB *core )
	:		:
	Interface( core )		Interface( core )
	{		{
	}		}
	public:		public:
	virtual DFBResult CreateWindow(		virtual DFBResult CreateWindow(
	const DFBWindowDescription *description,		const DFBWindowDescription *description,
			CoreWindow *parent,
			CoreWindow *toplevel,
	CoreWindow **ret_window		CoreWindow **ret_window
	) = 0;		) = 0;
	virtual DFBResult SetConfiguration(		virtual DFBResult SetConfiguration(
	const DFBDisplayLayerConfig *config		const DFBDisplayLayerConfig *config
	) = 0;		) = 0;
	virtual DFBResult GetPrimaryRegion(		virtual DFBResult GetPrimaryRegion(
	bool create,		bool create,
	CoreLayerRegion **ret_region		CoreLayerRegion **ret_region
	skipping to change at line 159		skipping to change at line 167
	ILayerContext_Real( CoreDFB *core, CoreLayerContext *obj )		ILayerContext_Real( CoreDFB *core, CoreLayerContext *obj )
	:		:
	ILayerContext( core ),		ILayerContext( core ),
	obj( obj )		obj( obj )
	{		{
	}		}
	public:		public:
	virtual DFBResult CreateWindow(		virtual DFBResult CreateWindow(
	const DFBWindowDescription *description,		const DFBWindowDescription *description,
			CoreWindow *parent,
			CoreWindow *toplevel,
	CoreWindow **ret_window		CoreWindow **ret_window
	);		);
	virtual DFBResult SetConfiguration(		virtual DFBResult SetConfiguration(
	const DFBDisplayLayerConfig *config		const DFBDisplayLayerConfig *config
	);		);
	virtual DFBResult GetPrimaryRegion(		virtual DFBResult GetPrimaryRegion(
	bool create,		bool create,
	CoreLayerRegion **ret_region		CoreLayerRegion **ret_region
	skipping to change at line 189		skipping to change at line 199
	ILayerContext_Requestor( CoreDFB *core, CoreLayerContext *obj )		ILayerContext_Requestor( CoreDFB *core, CoreLayerContext *obj )
	:		:
	ILayerContext( core ),		ILayerContext( core ),
	obj( obj )		obj( obj )
	{		{
	}		}
	public:		public:
	virtual DFBResult CreateWindow(		virtual DFBResult CreateWindow(
	const DFBWindowDescription *description,		const DFBWindowDescription *description,
			CoreWindow *parent,
			CoreWindow *toplevel,
	CoreWindow **ret_window		CoreWindow **ret_window
	);		);
	virtual DFBResult SetConfiguration(		virtual DFBResult SetConfiguration(
	const DFBDisplayLayerConfig *config		const DFBDisplayLayerConfig *config
	);		);
	virtual DFBResult GetPrimaryRegion(		virtual DFBResult GetPrimaryRegion(
	bool create,		bool create,
	CoreLayerRegion **ret_region		CoreLayerRegion **ret_region
End of changes. 5 change blocks.
	0 lines changed or deleted		12 lines changed or added

	CoreLayerRegion.h		CoreLayerRegion.h
	skipping to change at line 49		skipping to change at line 49
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	DFBResult CoreLayerRegion_FlipUpdate(		DFBResult CoreLayerRegion_FlipUpdate(
	CoreLayerRegion *obj,		CoreLayerRegion *obj,
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags);		DFBSurfaceFlipFlags flags);
			DFBResult CoreLayerRegion_GetSurface(
			CoreLayerRegion *obj,
			CoreSurface **ret_surface)
			;
	void *CoreLayerRegion_Init_Dispatch(		void *CoreLayerRegion_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreLayerRegion *obj,		CoreLayerRegion *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreLayerRegion_Deinit_Dispatch(		void CoreLayerRegion_Deinit_Dispatch(
	void *dispatch		void *dispatch
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	namespace DirectFB {		namespace DirectFB {
	/*		/*
	* CoreLayerRegion Calls		* CoreLayerRegion Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreLayerRegion_FlipUpdate = 1,		CoreLayerRegion_FlipUpdate = 1,
			CoreLayerRegion_GetSurface = 2,
	} CoreLayerRegionCall;		} CoreLayerRegionCall;
	/*		/*
	* CoreLayerRegion_FlipUpdate		* CoreLayerRegion_FlipUpdate
	*/		*/
	typedef struct {		typedef struct {
	bool update_set;		bool update_set;
	DFBRegion update;		DFBRegion update;
	DFBSurfaceFlipFlags flags;		DFBSurfaceFlipFlags flags;
	} CoreLayerRegionFlipUpdate;		} CoreLayerRegionFlipUpdate;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreLayerRegionFlipUpdateReturn;		} CoreLayerRegionFlipUpdateReturn;
			/*
			* CoreLayerRegion_GetSurface
			*/
			typedef struct {
			} CoreLayerRegionGetSurface;
			typedef struct {
			DFBResult result;
			u32 surface_id;
			} CoreLayerRegionGetSurfaceReturn;
	class ILayerRegion : public Interface		class ILayerRegion : public Interface
	{		{
	public:		public:
	ILayerRegion( CoreDFB *core )		ILayerRegion( CoreDFB *core )
	:		:
	Interface( core )		Interface( core )
	{		{
	}		}
	public:		public:
	virtual DFBResult FlipUpdate(		virtual DFBResult FlipUpdate(
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags
	) = 0;		) = 0;
			virtual DFBResult GetSurface(
			CoreSurface **ret_surface
			) = 0;
	};		};
	class ILayerRegion_Real : public ILayerRegion		class ILayerRegion_Real : public ILayerRegion
	{		{
	private:		private:
	CoreLayerRegion *obj;		CoreLayerRegion *obj;
	public:		public:
	ILayerRegion_Real( CoreDFB *core, CoreLayerRegion *obj )		ILayerRegion_Real( CoreDFB *core, CoreLayerRegion *obj )
	:		:
	skipping to change at line 120		skipping to change at line 140
	obj( obj )		obj( obj )
	{		{
	}		}
	public:		public:
	virtual DFBResult FlipUpdate(		virtual DFBResult FlipUpdate(
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags
	);		);
			virtual DFBResult GetSurface(
			CoreSurface **ret_surface
			);
	};		};
	class ILayerRegion_Requestor : public ILayerRegion		class ILayerRegion_Requestor : public ILayerRegion
	{		{
	private:		private:
	CoreLayerRegion *obj;		CoreLayerRegion *obj;
	public:		public:
	ILayerRegion_Requestor( CoreDFB *core, CoreLayerRegion *obj )		ILayerRegion_Requestor( CoreDFB *core, CoreLayerRegion *obj )
	:		:
	skipping to change at line 141		skipping to change at line 165
	obj( obj )		obj( obj )
	{		{
	}		}
	public:		public:
	virtual DFBResult FlipUpdate(		virtual DFBResult FlipUpdate(
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags
	);		);
			virtual DFBResult GetSurface(
			CoreSurface **ret_surface
			);
	};		};
	class CoreLayerRegionDispatch		class CoreLayerRegionDispatch
	{		{
	public:		public:
	CoreLayerRegionDispatch( CoreDFB *core, ILayerRegion *real )		CoreLayerRegionDispatch( CoreDFB *core, ILayerRegion *real )
	:		:
	core( core ),		core( core ),
	real( real )		real( real )
End of changes. 6 change blocks.
	0 lines changed or deleted		29 lines changed or added

	CoreSurface.h		CoreSurface.h
	skipping to change at line 48		skipping to change at line 48
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	DFBResult CoreSurface_SetConfig(		DFBResult CoreSurface_SetConfig(
	CoreSurface *obj,		CoreSurface *obj,
	const CoreSurfaceConfig *config);		const CoreSurfaceConfig *config);
	DFBResult CoreSurface_LockBuffer(
	CoreSurface *obj,
	CoreSurfaceBufferRole role,
	CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,
	CoreSurfaceBufferLock *ret_lock);
	DFBResult CoreSurface_UnlockBuffer(
	CoreSurface *obj,
	CoreSurfaceBufferLock *lock);
	DFBResult CoreSurface_Flip(		DFBResult CoreSurface_Flip(
	CoreSurface *obj,		CoreSurface *obj,
	bool swap);		bool swap);
			DFBResult CoreSurface_GetPalette(
			CoreSurface *obj,
			CorePalette **ret_palette)
			;
	DFBResult CoreSurface_SetPalette(		DFBResult CoreSurface_SetPalette(
	CoreSurface *obj,		CoreSurface *obj,
	CorePalette *palette);		CorePalette *palette);
			DFBResult CoreSurface_PreLockBuffer(
			CoreSurface *obj,
			u32 buffer_index
			,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags access,
			u32 *ret_allocati
			on_index);
			DFBResult CoreSurface_PreReadBuffer(
			CoreSurface *obj,
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index);
			DFBResult CoreSurface_PreWriteBuffer(
			CoreSurface *obj,
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index);
	void *CoreSurface_Init_Dispatch(		void *CoreSurface_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreSurface *obj,		CoreSurface *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreSurface_Deinit_Dispatch(		void CoreSurface_Deinit_Dispatch(
	void *dispatch		void *dispatch
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	namespace DirectFB {		namespace DirectFB {
	/*		/*
	* CoreSurface Calls		* CoreSurface Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreSurface_SetConfig = 1,		CoreSurface_SetConfig = 1,
	CoreSurface_LockBuffer = 2,		CoreSurface_Flip = 2,
	CoreSurface_UnlockBuffer = 3,		CoreSurface_GetPalette = 3,
	CoreSurface_Flip = 4,		CoreSurface_SetPalette = 4,
	CoreSurface_SetPalette = 5,		CoreSurface_PreLockBuffer = 5,
			CoreSurface_PreReadBuffer = 6,
			CoreSurface_PreWriteBuffer = 7,
	} CoreSurfaceCall;		} CoreSurfaceCall;
	/*		/*
	* CoreSurface_SetConfig		* CoreSurface_SetConfig
	*/		*/
	typedef struct {		typedef struct {
	CoreSurfaceConfig config;		CoreSurfaceConfig config;
	} CoreSurfaceSetConfig;		} CoreSurfaceSetConfig;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreSurfaceSetConfigReturn;		} CoreSurfaceSetConfigReturn;
	/*		/*
	* CoreSurface_LockBuffer		* CoreSurface_Flip
	*/		*/
	typedef struct {		typedef struct {
	CoreSurfaceBufferRole role;		bool swap;
	CoreSurfaceAccessorID accessor;		} CoreSurfaceFlip;
	CoreSurfaceAccessFlags access;
	} CoreSurfaceLockBuffer;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	CoreSurfaceBufferLock lock;		} CoreSurfaceFlipReturn;
	} CoreSurfaceLockBufferReturn;
	/*		/*
	* CoreSurface_UnlockBuffer		* CoreSurface_GetPalette
	*/		*/
	typedef struct {		typedef struct {
	CoreSurfaceBufferLock lock;		} CoreSurfaceGetPalette;
	} CoreSurfaceUnlockBuffer;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	CoreSurfaceBufferLock lock;		u32 palette_id;
	} CoreSurfaceUnlockBufferReturn;		} CoreSurfaceGetPaletteReturn;
	/*		/*
	* CoreSurface_Flip		* CoreSurface_SetPalette
	*/		*/
	typedef struct {		typedef struct {
	bool swap;		u32 palette_id;
	} CoreSurfaceFlip;		} CoreSurfaceSetPalette;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreSurfaceFlipReturn;		} CoreSurfaceSetPaletteReturn;
	/*		/*
	* CoreSurface_SetPalette		* CoreSurface_PreLockBuffer
	*/		*/
	typedef struct {		typedef struct {
	u32 palette_id;		u32 buffer_index;
	} CoreSurfaceSetPalette;		CoreSurfaceAccessorID accessor;
			CoreSurfaceAccessFlags access;
			} CoreSurfacePreLockBuffer;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreSurfaceSetPaletteReturn;		u32 allocation_index;
			} CoreSurfacePreLockBufferReturn;
			/*
			* CoreSurface_PreReadBuffer
			*/
			typedef struct {
			u32 buffer_index;
			DFBRectangle rect;
			} CoreSurfacePreReadBuffer;
			typedef struct {
			DFBResult result;
			u32 allocation_index;
			} CoreSurfacePreReadBufferReturn;
			/*
			* CoreSurface_PreWriteBuffer
			*/
			typedef struct {
			u32 buffer_index;
			DFBRectangle rect;
			} CoreSurfacePreWriteBuffer;
			typedef struct {
			DFBResult result;
			u32 allocation_index;
			} CoreSurfacePreWriteBufferReturn;
	class ISurface : public Interface		class ISurface : public Interface
	{		{
	public:		public:
	ISurface( CoreDFB *core )		ISurface( CoreDFB *core )
	:		:
	Interface( core )		Interface( core )
	{		{
	}		}
	public:		public:
	virtual DFBResult SetConfig(		virtual DFBResult SetConfig(
	const CoreSurfaceConfig *config		const CoreSurfaceConfig *config
	) = 0;		) = 0;
	virtual DFBResult LockBuffer(
	CoreSurfaceBufferRole role,
	CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,
	CoreSurfaceBufferLock *ret_lock
	) = 0;
	virtual DFBResult UnlockBuffer(
	CoreSurfaceBufferLock *lock
	) = 0;
	virtual DFBResult Flip(		virtual DFBResult Flip(
	bool swap		bool swap
	) = 0;		) = 0;
			virtual DFBResult GetPalette(
			CorePalette **ret_palette
			) = 0;
	virtual DFBResult SetPalette(		virtual DFBResult SetPalette(
	CorePalette *palette		CorePalette *palette
	) = 0;		) = 0;
			virtual DFBResult PreLockBuffer(
			u32 buffer_index
			,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags access,
			u32 *ret_allocati
			on_index
			) = 0;
			virtual DFBResult PreReadBuffer(
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index
			) = 0;
			virtual DFBResult PreWriteBuffer(
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index
			) = 0;
	};		};
	class ISurface_Real : public ISurface		class ISurface_Real : public ISurface
	{		{
	private:		private:
	CoreSurface *obj;		CoreSurface *obj;
	public:		public:
	ISurface_Real( CoreDFB *core, CoreSurface *obj )		ISurface_Real( CoreDFB *core, CoreSurface *obj )
	:		:
	ISurface( core ),		ISurface( core ),
	obj( obj )		obj( obj )
	{		{
	}		}
	public:		public:
	virtual DFBResult SetConfig(		virtual DFBResult SetConfig(
	const CoreSurfaceConfig *config		const CoreSurfaceConfig *config
	);		);
	virtual DFBResult LockBuffer(
	CoreSurfaceBufferRole role,
	CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,
	CoreSurfaceBufferLock *ret_lock
	);
	virtual DFBResult UnlockBuffer(
	CoreSurfaceBufferLock *lock
	);
	virtual DFBResult Flip(		virtual DFBResult Flip(
	bool swap		bool swap
	);		);
			virtual DFBResult GetPalette(
			CorePalette **ret_palette
			);
	virtual DFBResult SetPalette(		virtual DFBResult SetPalette(
	CorePalette *palette		CorePalette *palette
	);		);
			virtual DFBResult PreLockBuffer(
			u32 buffer_index
			,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags access,
			u32 *ret_allocati
			on_index
			);
			virtual DFBResult PreReadBuffer(
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index
			);
			virtual DFBResult PreWriteBuffer(
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index
			);
	};		};
	class ISurface_Requestor : public ISurface		class ISurface_Requestor : public ISurface
	{		{
	private:		private:
	CoreSurface *obj;		CoreSurface *obj;
	public:		public:
	ISurface_Requestor( CoreDFB *core, CoreSurface *obj )		ISurface_Requestor( CoreDFB *core, CoreSurface *obj )
	:		:
	ISurface( core ),		ISurface( core ),
	obj( obj )		obj( obj )
	{		{
	}		}
	public:		public:
	virtual DFBResult SetConfig(		virtual DFBResult SetConfig(
	const CoreSurfaceConfig *config		const CoreSurfaceConfig *config
	);		);
	virtual DFBResult LockBuffer(
	CoreSurfaceBufferRole role,
	CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,
	CoreSurfaceBufferLock *ret_lock
	);
	virtual DFBResult UnlockBuffer(
	CoreSurfaceBufferLock *lock
	);
	virtual DFBResult Flip(		virtual DFBResult Flip(
	bool swap		bool swap
	);		);
			virtual DFBResult GetPalette(
			CorePalette **ret_palette
			);
	virtual DFBResult SetPalette(		virtual DFBResult SetPalette(
	CorePalette *palette		CorePalette *palette
	);		);
			virtual DFBResult PreLockBuffer(
			u32 buffer_index
			,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags access,
			u32 *ret_allocati
			on_index
			);
			virtual DFBResult PreReadBuffer(
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index
			);
			virtual DFBResult PreWriteBuffer(
			u32 buffer_index
			,
			const DFBRectangle *rect,
			u32 *ret_allocati
			on_index
			);
	};		};
	class CoreSurfaceDispatch		class CoreSurfaceDispatch
	{		{
	public:		public:
	CoreSurfaceDispatch( CoreDFB *core, ISurface *real )		CoreSurfaceDispatch( CoreDFB *core, ISurface *real )
	:		:
	core( core ),		core( core ),
	real( real )		real( real )
End of changes. 25 change blocks.
	68 lines changed or deleted		168 lines changed or added

	CoreWindow.h		CoreWindow.h
	skipping to change at line 62		skipping to change at line 62
	const DFBRegion *update);		const DFBRegion *update);
	DFBResult CoreWindow_Restack(		DFBResult CoreWindow_Restack(
	CoreWindow *obj,		CoreWindow *obj,
	CoreWindow *relative,		CoreWindow *relative,
	int relation);		int relation);
	DFBResult CoreWindow_SetConfig(		DFBResult CoreWindow_SetConfig(
	CoreWindow *obj,		CoreWindow *obj,
	const CoreWindowConfig *config,		const CoreWindowConfig *config,
			const DFBInputDeviceKeySymbol *keys,
			u32 num_keys,
			CoreWindow *parent,
	CoreWindowConfigFlags flags);		CoreWindowConfigFlags flags);
	DFBResult CoreWindow_Bind(		DFBResult CoreWindow_Bind(
	CoreWindow *obj,		CoreWindow *obj,
	CoreWindow *source,		CoreWindow *source,
	int x,		int x,
	int y);		int y);
	DFBResult CoreWindow_Unbind(		DFBResult CoreWindow_Unbind(
	CoreWindow *obj,		CoreWindow *obj,
	skipping to change at line 161		skipping to change at line 164
	DFBResult CoreWindow_SetKeySelection(		DFBResult CoreWindow_SetKeySelection(
	CoreWindow *obj,		CoreWindow *obj,
	DFBWindowKeySelection selection,		DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys);		u32 num_keys);
	DFBResult CoreWindow_SetRotation(		DFBResult CoreWindow_SetRotation(
	CoreWindow *obj,		CoreWindow *obj,
	int rotation);		int rotation);
			DFBResult CoreWindow_GetSurface(
			CoreWindow *obj,
			CoreSurface **ret_surface)
			;
	void *CoreWindow_Init_Dispatch(		void *CoreWindow_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreWindow *obj,		CoreWindow *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreWindow_Deinit_Dispatch(		void CoreWindow_Deinit_Dispatch(
	void *dispatch		void *dispatch
	);		);
	skipping to change at line 205		skipping to change at line 212
	CoreWindow_ChangeEvents = 16,		CoreWindow_ChangeEvents = 16,
	CoreWindow_ChangeOptions = 17,		CoreWindow_ChangeOptions = 17,
	CoreWindow_SetColor = 18,		CoreWindow_SetColor = 18,
	CoreWindow_SetColorKey = 19,		CoreWindow_SetColorKey = 19,
	CoreWindow_SetOpaque = 20,		CoreWindow_SetOpaque = 20,
	CoreWindow_SetOpacity = 21,		CoreWindow_SetOpacity = 21,
	CoreWindow_SetStacking = 22,		CoreWindow_SetStacking = 22,
	CoreWindow_SetBounds = 23,		CoreWindow_SetBounds = 23,
	CoreWindow_SetKeySelection = 24,		CoreWindow_SetKeySelection = 24,
	CoreWindow_SetRotation = 25,		CoreWindow_SetRotation = 25,
			CoreWindow_GetSurface = 26,
	} CoreWindowCall;		} CoreWindowCall;
	/*		/*
	* CoreWindow_Repaint		* CoreWindow_Repaint
	*/		*/
	typedef struct {		typedef struct {
	DFBRegion left;		DFBRegion left;
	DFBRegion right;		DFBRegion right;
	DFBSurfaceFlipFlags flags;		DFBSurfaceFlipFlags flags;
	} CoreWindowRepaint;		} CoreWindowRepaint;
	skipping to change at line 250		skipping to change at line 258
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreWindowRestackReturn;		} CoreWindowRestackReturn;
	/*		/*
	* CoreWindow_SetConfig		* CoreWindow_SetConfig
	*/		*/
	typedef struct {		typedef struct {
	CoreWindowConfig config;		CoreWindowConfig config;
			u32 num_keys;
			bool parent_set;
			u32 parent_id;
	CoreWindowConfigFlags flags;		CoreWindowConfigFlags flags;
			bool keys_set;
			/* 'num_keys' DFBInputDeviceKeySymbol follow (keys) */
	} CoreWindowSetConfig;		} CoreWindowSetConfig;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreWindowSetConfigReturn;		} CoreWindowSetConfigReturn;
	/*		/*
	* CoreWindow_Bind		* CoreWindow_Bind
	*/		*/
	typedef struct {		typedef struct {
	skipping to change at line 500		skipping to change at line 513
	* CoreWindow_SetRotation		* CoreWindow_SetRotation
	*/		*/
	typedef struct {		typedef struct {
	int rotation;		int rotation;
	} CoreWindowSetRotation;		} CoreWindowSetRotation;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreWindowSetRotationReturn;		} CoreWindowSetRotationReturn;
			/*
			* CoreWindow_GetSurface
			*/
			typedef struct {
			} CoreWindowGetSurface;
			typedef struct {
			DFBResult result;
			u32 surface_id;
			} CoreWindowGetSurfaceReturn;
	class IWindow : public Interface		class IWindow : public Interface
	{		{
	public:		public:
	IWindow( CoreDFB *core )		IWindow( CoreDFB *core )
	:		:
	Interface( core )		Interface( core )
	{		{
	}		}
	public:		public:
	skipping to change at line 527		skipping to change at line 551
	const DFBRegion *update		const DFBRegion *update
	) = 0;		) = 0;
	virtual DFBResult Restack(		virtual DFBResult Restack(
	CoreWindow *relative,		CoreWindow *relative,
	int relation		int relation
	) = 0;		) = 0;
	virtual DFBResult SetConfig(		virtual DFBResult SetConfig(
	const CoreWindowConfig *config,		const CoreWindowConfig *config,
			const DFBInputDeviceKeySymbol *keys,
			u32 num_keys,
			CoreWindow *parent,
	CoreWindowConfigFlags flags		CoreWindowConfigFlags flags
	) = 0;		) = 0;
	virtual DFBResult Bind(		virtual DFBResult Bind(
	CoreWindow *source,		CoreWindow *source,
	int x,		int x,
	int y		int y
	) = 0;		) = 0;
	virtual DFBResult Unbind(		virtual DFBResult Unbind(
	skipping to change at line 627		skipping to change at line 654
	virtual DFBResult SetKeySelection(		virtual DFBResult SetKeySelection(
	DFBWindowKeySelection selection,		DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys		u32 num_keys
	) = 0;		) = 0;
	virtual DFBResult SetRotation(		virtual DFBResult SetRotation(
	int rotation		int rotation
	) = 0;		) = 0;
			virtual DFBResult GetSurface(
			CoreSurface **ret_surface
			) = 0;
	};		};
	class IWindow_Real : public IWindow		class IWindow_Real : public IWindow
	{		{
	private:		private:
	CoreWindow *obj;		CoreWindow *obj;
	public:		public:
	IWindow_Real( CoreDFB *core, CoreWindow *obj )		IWindow_Real( CoreDFB *core, CoreWindow *obj )
	:		:
	skipping to change at line 660		skipping to change at line 691
	const DFBRegion *update		const DFBRegion *update
	);		);
	virtual DFBResult Restack(		virtual DFBResult Restack(
	CoreWindow *relative,		CoreWindow *relative,
	int relation		int relation
	);		);
	virtual DFBResult SetConfig(		virtual DFBResult SetConfig(
	const CoreWindowConfig *config,		const CoreWindowConfig *config,
			const DFBInputDeviceKeySymbol *keys,
			u32 num_keys,
			CoreWindow *parent,
	CoreWindowConfigFlags flags		CoreWindowConfigFlags flags
	);		);
	virtual DFBResult Bind(		virtual DFBResult Bind(
	CoreWindow *source,		CoreWindow *source,
	int x,		int x,
	int y		int y
	);		);
	virtual DFBResult Unbind(		virtual DFBResult Unbind(
	skipping to change at line 760		skipping to change at line 794
	virtual DFBResult SetKeySelection(		virtual DFBResult SetKeySelection(
	DFBWindowKeySelection selection,		DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys		u32 num_keys
	);		);
	virtual DFBResult SetRotation(		virtual DFBResult SetRotation(
	int rotation		int rotation
	);		);
			virtual DFBResult GetSurface(
			CoreSurface **ret_surface
			);
	};		};
	class IWindow_Requestor : public IWindow		class IWindow_Requestor : public IWindow
	{		{
	private:		private:
	CoreWindow *obj;		CoreWindow *obj;
	public:		public:
	IWindow_Requestor( CoreDFB *core, CoreWindow *obj )		IWindow_Requestor( CoreDFB *core, CoreWindow *obj )
	:		:
	skipping to change at line 793		skipping to change at line 831
	const DFBRegion *update		const DFBRegion *update
	);		);
	virtual DFBResult Restack(		virtual DFBResult Restack(
	CoreWindow *relative,		CoreWindow *relative,
	int relation		int relation
	);		);
	virtual DFBResult SetConfig(		virtual DFBResult SetConfig(
	const CoreWindowConfig *config,		const CoreWindowConfig *config,
			const DFBInputDeviceKeySymbol *keys,
			u32 num_keys,
			CoreWindow *parent,
	CoreWindowConfigFlags flags		CoreWindowConfigFlags flags
	);		);
	virtual DFBResult Bind(		virtual DFBResult Bind(
	CoreWindow *source,		CoreWindow *source,
	int x,		int x,
	int y		int y
	);		);
	virtual DFBResult Unbind(		virtual DFBResult Unbind(
	skipping to change at line 893		skipping to change at line 934
	virtual DFBResult SetKeySelection(		virtual DFBResult SetKeySelection(
	DFBWindowKeySelection selection,		DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys		u32 num_keys
	);		);
	virtual DFBResult SetRotation(		virtual DFBResult SetRotation(
	int rotation		int rotation
	);		);
			virtual DFBResult GetSurface(
			CoreSurface **ret_surface
			);
	};		};
	class CoreWindowDispatch		class CoreWindowDispatch
	{		{
	public:		public:
	CoreWindowDispatch( CoreDFB *core, IWindow *real )		CoreWindowDispatch( CoreDFB *core, IWindow *real )
	:		:
	core( core ),		core( core ),
	real( real )		real( real )
End of changes. 12 change blocks.
	0 lines changed or deleted		46 lines changed or added

	atomic.h		atomic.h
	skipping to change at line 241		skipping to change at line 241
	return result;		return result;
	}		}
	#define D_SYNC_ADD_AND_FETCH( ptr, value ) \		#define D_SYNC_ADD_AND_FETCH( ptr, value ) \
	(_D__atomic_add_return( (int) (value), (void*) (ptr) ))		(_D__atomic_add_return( (int) (value), (void*) (ptr) ))
	#endif		#endif
	#if defined(ARCH_MIPS)		#if defined(ARCH_MIPS)
	static inline int _D__atomic_cmpxchg(volatile int *ptr, int old, int new)		static inline int _D__atomic_cmpxchg(volatile int *ptr, int old, int _new)
	{		{
	unsigned long retval;		unsigned long retval;
	__asm__ __volatile__(		__asm__ __volatile__(
	" .set push \n"		" .set push \n"
	" .set noat \n"		" .set noat \n"
	" .set mips3 \n"		" .set mips3 \n"
	"1: ll %0, %2 # __cmpxchg_u32 \n"		"1: ll %0, %2 # __cmpxchg_u32 \n"
	" bne %0, %z3, 2f \n"		" bne %0, %z3, 2f \n"
	" .set mips0 \n"		" .set mips0 \n"
	" move $1, %z4 \n"		" move $1, %z4 \n"
	" .set mips3 \n"		" .set mips3 \n"
	" sc $1, %1 \n"		" sc $1, %1 \n"
	" beqz $1, 1b \n"		" beqz $1, 1b \n"
	#ifdef CONFIG_SMP		#ifdef CONFIG_SMP
	" sync \n"		" sync \n"
	#endif		#endif
	"2: \n"		"2: \n"
	" .set pop \n"		" .set pop \n"
	: "=&r" (retval), "=R" (*ptr)		: "=&r" (retval), "=R" (*ptr)
	: "R" (*ptr), "Jr" (old), "Jr" (new)		: "R" (*ptr), "Jr" (old), "Jr" (_new)
	: "memory");		: "memory");
	return retval;		return retval;
	}		}
	#define D_SYNC_BOOL_COMPARE_AND_SWAP( ptr, old_value, new_value ) \		#define D_SYNC_BOOL_COMPARE_AND_SWAP( ptr, old_value, new_value ) \
	(_D__atomic_cmpxchg( (void*) ptr, (int) old_value, (int) new_value ) = = (int) old_value)		(_D__atomic_cmpxchg( (void*) ptr, (int) old_value, (int) new_value ) = = (int) old_value)
	#define D_SYNC_FETCH_AND_CLEAR( ptr ) \		#define D_SYNC_FETCH_AND_CLEAR( ptr ) \
	({ \		({ \
End of changes. 2 change blocks.
	2 lines changed or deleted		2 lines changed or added

	call.h		call.h
	skipping to change at line 112		skipping to change at line 112
	unsigned int serial,		unsigned int serial,
	int val );		int val );
	DirectResult FUSION_API fusion_call_return3( FusionCall *call,		DirectResult FUSION_API fusion_call_return3( FusionCall *call,
	unsigned int serial,		unsigned int serial,
	void *ptr,		void *ptr,
	unsigned int length );		unsigned int length );
	DirectResult FUSION_API fusion_call_destroy( FusionCall *call );		DirectResult FUSION_API fusion_call_destroy( FusionCall *call );
			typedef enum {
			FUSION_CALL_PERMIT_NONE = 0x00000000,
			FUSION_CALL_PERMIT_EXECUTE = 0x00000001,
			FUSION_CALL_PERMIT_ALL = 0x00000001,
			} FusionCallPermissions;
			/*
			* Give permissions to another fusionee to use the call.
			*/
			DirectResult FUSION_API fusion_call_add_permissions( FusionCall
			*call,
			FusionID
			fusion_id,
			FusionCallPermissions
			permissions );
	#endif		#endif
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 78		skipping to change at line 78
	bool emergency );		bool emergency );
	void *dfb_core_get_part( CoreDFB *core,		void *dfb_core_get_part( CoreDFB *core,
	DFBCorePartID part_id );		DFBCorePartID part_id );
	#define DFB_CORE(core,PART) dfb_core_get_part( core, DFCP_##PART )		#define DFB_CORE(core,PART) dfb_core_get_part( core, DFCP_##PART )
	/*		/*
	* Object creation		* Object creation
	*/		*/
	CoreLayerContext *dfb_core_create_layer_context( CoreDFB *core );		CoreGraphicsState *dfb_core_create_graphics_state( CoreDFB *core );
	CoreLayerRegion *dfb_core_create_layer_region ( CoreDFB *core );		CoreLayerContext *dfb_core_create_layer_context ( CoreDFB *core );
	CorePalette *dfb_core_create_palette ( CoreDFB *core );		CoreLayerRegion *dfb_core_create_layer_region ( CoreDFB *core );
	CoreSurface *dfb_core_create_surface ( CoreDFB *core );		CorePalette *dfb_core_create_palette ( CoreDFB *core );
	CoreWindow *dfb_core_create_window ( CoreDFB *core );		CoreSurface *dfb_core_create_surface ( CoreDFB *core );
			CoreWindow *dfb_core_create_window ( CoreDFB *core );
	DFBResult dfb_core_get_layer_context ( CoreDFB *core,
	u32 object_
	id,
	CoreLayerContext **ret_con
	text );
	DFBResult dfb_core_get_layer_region ( CoreDFB *core,		DFBResult dfb_core_get_graphics_state ( CoreDFB *core
	u32 object_		,
	id,		u32 obje
	CoreLayerRegion **ret_reg		ct_id,
	ion );		CoreGraphicsState **ret_
			state );
	DFBResult dfb_core_get_palette ( CoreDFB *core,		DFBResult dfb_core_get_layer_context ( CoreDFB *core
	u32 object_id,		,
	CorePalette **ret_palette		u32 obje
	);		ct_id,
			CoreLayerContext **ret_
			context );
	DFBResult dfb_core_get_surface ( CoreDFB *core,		DFBResult dfb_core_get_layer_region ( CoreDFB *core
	u32 object_id,		,
	CoreSurface **ret_surface		u32 obje
	);		ct_id,
			CoreLayerRegion **ret_
			region );
	DFBResult dfb_core_get_window ( CoreDFB *core,		DFBResult dfb_core_get_palette ( CoreDFB *core
	u32 object_id,		,
	CoreWindow **ret_window );		u32 obje
			ct_id,
			CorePalette **ret_
			palette );
	DFBResult dfb_core_create_graphics_state( CoreDFB *core,		DFBResult dfb_core_get_surface ( CoreDFB *core
	CoreGraphicsState **ret_s		,
	tate );		u32 obje
			ct_id,
			CoreSurface **ret_
			surface );
	DFBResult dfb_core_get_graphics_state ( CoreDFB *core,		DFBResult dfb_core_get_window ( CoreDFB *core
	u32 objec		,
	t_id,		u32 obje
	CoreGraphicsState **ret_s		ct_id,
	tate );		CoreWindow **ret_
			window );
	/*		/*
	* Debug		* Debug
	*/		*/
	DirectResult dfb_core_enum_surfaces ( CoreDFB *core,		DirectResult dfb_core_enum_surfaces ( CoreDFB *core,
	FusionObjectCallback callback,		FusionObjectCallback callback,
	void *ctx );		void *ctx );
	DirectResult dfb_core_enum_layer_contexts( CoreDFB *core,		DirectResult dfb_core_enum_layer_contexts( CoreDFB *core,
	FusionObjectCallback callback,		FusionObjectCallback callback,
	void *ctx );		void *ctx );
	skipping to change at line 190		skipping to change at line 188
	CoreCleanup *cleanup );		CoreCleanup *cleanup );
	DFBFontManager *dfb_core_font_manager( CoreDFB *core );		DFBFontManager *dfb_core_font_manager( CoreDFB *core );
	struct __DFB_CoreDFBShared {		struct __DFB_CoreDFBShared {
	int magic;		int magic;
	FusionSkirmish lock;		FusionSkirmish lock;
	bool active;		bool active;
			FusionObjectPool *graphics_state_pool;
	FusionObjectPool *layer_context_pool;		FusionObjectPool *layer_context_pool;
	FusionObjectPool *layer_region_pool;		FusionObjectPool *layer_region_pool;
	FusionObjectPool *palette_pool;		FusionObjectPool *palette_pool;
	FusionObjectPool *state_pool;
	FusionObjectPool *surface_pool;		FusionObjectPool *surface_pool;
	FusionObjectPool *window_pool;		FusionObjectPool *window_pool;
	FusionSHMPoolShared *shmpool;		FusionSHMPoolShared *shmpool;
	FusionSHMPoolShared *shmpool_data; /* for raw data, e.g. surface buffe rs */		FusionSHMPoolShared *shmpool_data; /* for raw data, e.g. surface buffe rs */
	FusionCall call;		FusionCall call;
	};		};
	struct __DFB_CoreDFB {		struct __DFB_CoreDFB {
End of changes. 9 change blocks.
	36 lines changed or deleted		43 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 (5)		#define DIRECTFB_MINOR_VERSION (5)
	#define DIRECTFB_MICRO_VERSION (1)		#define DIRECTFB_MICRO_VERSION (2)
	#define DIRECTFB_BINARY_AGE (1)		#define DIRECTFB_BINARY_AGE (2)
	#define DIRECTFB_INTERFACE_AGE (1)		#define DIRECTFB_INTERFACE_AGE (2)
	#endif /* __DIRECTFB_VERSION_H__ */		#endif /* __DIRECTFB_VERSION_H__ */
End of changes. 1 change blocks.
	3 lines changed or deleted		3 lines changed or added

	fusion.h		fusion.h
	skipping to change at line 141		skipping to change at line 141
	*/		*/
	DirectResult FUSION_API fusion_kill( FusionWorld *world,		DirectResult FUSION_API fusion_kill( FusionWorld *world,
	FusionID fusion_id,		FusionID fusion_id,
	int signal,		int signal,
	int timeout_ms );		int timeout_ms );
	/* Check if a pointer points to the shared memory. */		/* Check if a pointer points to the shared memory. */
	bool FUSION_API fusion_is_shared( FusionWorld *world,		bool FUSION_API fusion_is_shared( FusionWorld *world,
	const void *ptr );		const void *ptr );
			const char * FUSION_API fusion_get_tmpfs( FusionWorld *world );
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		2 lines changed or added

	fusion_internal.h		fusion_internal.h
	skipping to change at line 158		skipping to change at line 158
	/*		/*
	* from reactor.c		* from reactor.c
	*/		*/
	void _fusion_reactor_free_all ( FusionWorld *world );		void _fusion_reactor_free_all ( FusionWorld *world );
	void _fusion_reactor_process_message( FusionWorld *world,		void _fusion_reactor_process_message( FusionWorld *world,
	int reactor_id,		int reactor_id,
	int channel,		int channel,
	const void *msg_data );		const void *msg_data );
	#if FUSION_BUILD_MULTI		#if FUSION_BUILD_MULTI
			# if FUSION_BUILD_KERNEL
			static __inline__ void
			fusion_entry_add_permissions( const FusionWorld *world,
			FusionType type,
			int entry_id,
			FusionID fusion_id,
			... )
			{
			FusionEntryPermissions permissions;
			va_list args;
			int arg;
			permissions.type = type;
			permissions.id = entry_id;
			permissions.fusion_id = fusion_id;
			permissions.permissions = 0;
			va_start( args, fusion_id );
			while ((arg = va_arg( args, int )) != 0)
			FUSION_ENTRY_PERMISSIONS_ADD( permissions.permissions, arg );
			va_end( args );
			while (ioctl( world->fusion_fd, FUSION_ENTRY_ADD_PERMISSIONS, &permiss
			ions ) < 0) {
			if (errno != EINTR) {
			D_PERROR( "Fusion: FUSION_ENTRY_ADD_PERMISSIONS( type %d, id
			%d ) failed!\n", type, entry_id );
			break;
			}
			}
			}
			# endif
			#endif
			#if FUSION_BUILD_MULTI
	/*		/*
	* from call.c		* from call.c
	*/		*/
	void _fusion_call_process ( FusionWorld *world,		void _fusion_call_process ( FusionWorld *world,
	int call_id,		int call_id,
	FusionCallMessage *call,		FusionCallMessage *call,
	void *ptr );		void *ptr );
	void _fusion_call_process3( FusionWorld *world,		void _fusion_call_process3( FusionWorld *world,
	int call_id,		int call_id,
	FusionCallMessage3 *msg,		FusionCallMessage3 *msg,
End of changes. 1 change blocks.
	0 lines changed or deleted		37 lines changed or added

	object.h		object.h
	skipping to change at line 67		skipping to change at line 67
	FusionObjectID id;		FusionObjectID id;
	FusionObjectState state;		FusionObjectState state;
	FusionRef ref;		FusionRef ref;
	FusionReactor *reactor;		FusionReactor *reactor;
	FusionWorldShared *shared;		FusionWorldShared *shared;
	FusionHash *properties;		FusionHash *properties;
			FusionID owner;
	};		};
	typedef bool (*FusionObjectCallback)( FusionObjectPool *pool,		typedef bool (*FusionObjectCallback)( FusionObjectPool *pool,
	FusionObject *object,		FusionObject *object,
	void *ctx );		void *ctx );
	FusionObjectPool FUSION_API *fusion_object_pool_create ( const char *name,		FusionObjectPool FUSION_API *fusion_object_pool_create ( const char *name,
	int object_size,		int object_size,
	int message_size,		int message_size,
	FusionObjec tDestructor destructor,		FusionObjec tDestructor destructor,
End of changes. 1 change blocks.
	0 lines changed or deleted		2 lines changed or added

	reactor.h		reactor.h
	skipping to change at line 192		skipping to change at line 192
	*/		*/
	DirectResult FUSION_API fusion_reactor_set_name ( FusionReact or *reactor,		DirectResult FUSION_API fusion_reactor_set_name ( FusionReact or *reactor,
	const char *name );		const char *name );
	/*		/*
	* Specify whether local message handlers (reactions) should be called dire ctly.		* Specify whether local message handlers (reactions) should be called dire ctly.
	*/		*/
	DirectResult FUSION_API fusion_reactor_direct ( FusionReactor *reactor,		DirectResult FUSION_API fusion_reactor_direct ( FusionReactor *reactor,
	bool direct );		bool direct );
			typedef enum {
			FUSION_REACTOR_PERMIT_NONE = 0x00000000,
			FUSION_REACTOR_PERMIT_ATTACH_DETACH = 0x00000001,
			FUSION_REACTOR_PERMIT_DISPATCH = 0x00000002,
			FUSION_REACTOR_PERMIT_ALL = 0x00000003,
			} FusionReactorPermissions;
			/*
			* Give permissions to another fusionee to use the reactor.
			*/
			DirectResult FUSION_API fusion_reactor_add_permissions( FusionReactor
			*reactor,
			FusionID
			fusion_id,
			FusionReactorPerm
			issions permissions );
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		19 lines changed or added

	ref.h		ref.h
	skipping to change at line 143		skipping to change at line 143
	DirectResult FUSION_API fusion_ref_inherit (FusionRef *ref,		DirectResult FUSION_API fusion_ref_inherit (FusionRef *ref,
	FusionRef *from);		FusionRef *from);
	/*		/*
	* Deinitialize.		* Deinitialize.
	* Can be called after successful zero_lock or zero_trylock		* Can be called after successful zero_lock or zero_trylock
	* so that waiting fusion_ref_up calls return with DR_DESTROYED.		* so that waiting fusion_ref_up calls return with DR_DESTROYED.
	*/		*/
	DirectResult FUSION_API fusion_ref_destroy (FusionRef *ref);		DirectResult FUSION_API fusion_ref_destroy (FusionRef *ref);
			typedef enum {
			FUSION_REF_PERMIT_NONE = 0x00000000,
			FUSION_REF_PERMIT_REF_UNREF_LOCAL = 0x00000001,
			FUSION_REF_PERMIT_REF_UNREF_GLOBAL = 0x00000002,
			FUSION_REF_PERMIT_ZERO_LOCK_UNLOCK = 0x00000004,
			FUSION_REF_PERMIT_WATCH = 0x00000008,
			FUSION_REF_PERMIT_INHERIT = 0x00000010,
			FUSION_REF_PERMIT_DESTROY = 0x00000020,
			FUSION_REF_PERMIT_CATCH = 0x00000040,
			FUSION_REF_PERMIT_THROW = 0x00000080,
			FUSION_REF_PERMIT_ALL = 0x000000FF,
			} FusionRefPermissions;
			/*
			* Give permissions to another fusionee to use the reference.
			*/
			DirectResult FUSION_API fusion_ref_add_permissions( FusionRef *
			ref,
			FusionID
			fusion_id,
			FusionRefPermissions
			permissions );
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		25 lines changed or added

	shm_internal.h		shm_internal.h
	skipping to change at line 85		skipping to change at line 85
	int pool_id; /* The pool's ID within the world. */		int pool_id; /* The pool's ID within the world. */
	void *addr_base; /* Virtual starting address of shar ed memory. */		void *addr_base; /* Virtual starting address of shar ed memory. */
	FusionSkirmish lock; /* Lock for this pool. */		FusionSkirmish lock; /* Lock for this pool. */
	shmalloc_heap *heap; /* The actual heap information port ed from libc5. */		shmalloc_heap *heap; /* The actual heap information port ed from libc5. */
	char *name; /* Name of the pool (allocated in t he pool). */		char *name; /* Name of the pool (allocated in t he pool). */
	DirectLink *allocs; /* Used for debugging. */		DirectLink *allocs; /* Used for debugging. */
	bool slave_write;
	};		};
	/*		/*
	* Local SHM data.		* Local SHM data.
	*/		*/
	struct __Fusion_FusionSHM {		struct __Fusion_FusionSHM {
	int magic;		int magic;
	FusionWorld *world; /* Back pointer to local world data . */		FusionWorld *world; /* Back pointer to local world data . */
End of changes. 1 change blocks.
	2 lines changed or deleted		0 lines changed or added

	surface_buffer.h		surface_buffer.h
	skipping to change at line 228		skipping to change at line 228
	DFBResult dfb_surface_buffer_write ( CoreSurfaceBuffer *buffer,		DFBResult dfb_surface_buffer_write ( CoreSurfaceBuffer *buffer,
	const void *source,		const void *source,
	int pitch,		int pitch,
	const DFBRectangle *rect );		const DFBRectangle *rect );
	DFBResult dfb_surface_buffer_dump ( CoreSurfaceBuffer *buffer,		DFBResult dfb_surface_buffer_dump ( CoreSurfaceBuffer *buffer,
	const char *directory,		const char *directory,
	const char *prefix );		const char *prefix );
			CoreSurfaceAllocation *
			dfb_surface_buffer_find_allocation( CoreSurfaceBuffer *buffer,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags flags,
			bool lock );
	static inline int		static inline int
	dfb_surface_buffer_index( CoreSurfaceBuffer *buffer )		dfb_surface_buffer_index( CoreSurfaceBuffer *buffer )
	{		{
	int index;		int index;
	CoreSurface *surface;		CoreSurface *surface;
	D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );		D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
	surface = buffer->surface;		surface = buffer->surface;
	D_MAGIC_ASSERT( surface, CoreSurface );		D_MAGIC_ASSERT( surface, CoreSurface );
End of changes. 1 change blocks.
	0 lines changed or deleted		6 lines changed or added

	surface_pool.h		surface_pool.h
	skipping to change at line 45		skipping to change at line 45
	#include <core/surface.h>		#include <core/surface.h>
	#include <core/surface_buffer.h>		#include <core/surface_buffer.h>
	typedef enum {		typedef enum {
	CSPCAPS_NONE = 0x00000000,		CSPCAPS_NONE = 0x00000000,
	CSPCAPS_PHYSICAL = 0x00000001, /* pool provides physical address t o buffer */		CSPCAPS_PHYSICAL = 0x00000001, /* pool provides physical address t o buffer */
	CSPCAPS_VIRTUAL = 0x00000002, /* pool provides virtual address to buffer */		CSPCAPS_VIRTUAL = 0x00000002, /* pool provides virtual address to buffer */
	CSPCAPS_ALL = 0x00000003		CSPCAPS_READ = 0x00000004, /* pool provides Read() function (s
			et automatically) */
			CSPCAPS_WRITE = 0x00000008, /* pool provides Write() function (
			set automatically) */
			CSPCAPS_ALL = 0x0000000F
	} CoreSurfacePoolCapabilities;		} CoreSurfacePoolCapabilities;
	typedef enum {		typedef enum {
	CSPP_DEFAULT,		CSPP_DEFAULT,
	CSPP_PREFERED,		CSPP_PREFERED,
	CSPP_ULTIMATE		CSPP_ULTIMATE
	} CoreSurfacePoolPriority;		} CoreSurfacePoolPriority;
	/*		/*
	* Increase this number when changes result in binary incompatibility!		* Increase this number when changes result in binary incompatibility!
End of changes. 1 change blocks.
	1 lines changed or deleted		6 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/