CoreDFB.h		CoreDFB.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreDFB__H___		#ifndef ___CoreDFB__H___
	#define ___CoreDFB__H___		#define ___CoreDFB__H___
	#include "CoreDFB_includes.h"		#include <core/CoreDFB_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreDFB		* CoreDFB
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
			DFBResult CoreDFB_Register(
			CoreDFB *obj
			);
	DFBResult CoreDFB_CreateSurface(		DFBResult CoreDFB_CreateSurface(
	CoreDFB *obj,		CoreDFB *obj,
	const CoreSurfaceConfig *config,		const CoreSurfaceConfig *config,
	CoreSurfaceTypeFlags type,		CoreSurfaceTypeFlags type,
	u64 resource_id,		u64 resource_id,
	CorePalette *palette,		CorePalette *palette,
	CoreSurface **ret_surface) ;		CoreSurface **ret_surface) ;
	DFBResult CoreDFB_CreatePalette(		DFBResult CoreDFB_CreatePalette(
	CoreDFB *obj,		CoreDFB *obj,
	skipping to change at line 65		skipping to change at line 69
	CorePalette **ret_palette) ;		CorePalette **ret_palette) ;
	DFBResult CoreDFB_CreateState(		DFBResult CoreDFB_CreateState(
	CoreDFB *obj,		CoreDFB *obj,
	CoreGraphicsState **ret_state);		CoreGraphicsState **ret_state);
	DFBResult CoreDFB_WaitIdle(		DFBResult CoreDFB_WaitIdle(
	CoreDFB *obj		CoreDFB *obj
	);		);
	void *CoreDFB_Init_Dispatch(		void CoreDFB_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreDFB *obj,		CoreDFB *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreDFB_Deinit_Dispatch(		void CoreDFB_Deinit_Dispatch(
	void *dispatch		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreDFB Calls		* CoreDFB Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreDFB_CreateSurface = 1,		_CoreDFB_Register = 1,
	CoreDFB_CreatePalette = 2,		_CoreDFB_CreateSurface = 2,
	CoreDFB_CreateState = 3,		_CoreDFB_CreatePalette = 3,
	CoreDFB_WaitIdle = 4,		_CoreDFB_CreateState = 4,
			_CoreDFB_WaitIdle = 5,
	} CoreDFBCall;		} CoreDFBCall;
	/*		/*
			* CoreDFB_Register
			*/
			typedef struct {
			} CoreDFBRegister;
			typedef struct {
			DFBResult result;
			} CoreDFBRegisterReturn;
			/*
	* CoreDFB_CreateSurface		* CoreDFB_CreateSurface
	*/		*/
	typedef struct {		typedef struct {
	CoreSurfaceConfig config;		CoreSurfaceConfig config;
	CoreSurfaceTypeFlags type;		CoreSurfaceTypeFlags type;
	u64 resource_id;		u64 resource_id;
	bool palette_set;		bool palette_set;
	u32 palette_id;		u32 palette_id;
	} CoreDFBCreateSurface;		} CoreDFBCreateSurface;
	skipping to change at line 139		skipping to change at line 153
	/*		/*
	* CoreDFB_WaitIdle		* CoreDFB_WaitIdle
	*/		*/
	typedef struct {		typedef struct {
	} CoreDFBWaitIdle;		} CoreDFBWaitIdle;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreDFBWaitIdleReturn;		} CoreDFBWaitIdleReturn;
	class ICore : public Interface		DFBResult ICore_Real__Register( CoreDFB *obj
	{		);
	public:
	ICore( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult CreateSurface(
	const CoreSurfaceConfig *config,
	CoreSurfaceTypeFlags type,
	u64 resource_id,
	CorePalette *palette,
	CoreSurface **ret_surface
	) = 0;
	virtual DFBResult CreatePalette(
	u32 size,
	CorePalette **ret_palette
	) = 0;
	virtual DFBResult CreateState(
	CoreGraphicsState **ret_state
	) = 0;
	virtual DFBResult WaitIdle(
	) = 0;
	};
	class ICore_Real : public ICore
	{
	private:
	CoreDFB *obj;
	public:
	ICore_Real( CoreDFB *core, CoreDFB *obj )
	:
	ICore( core ),
	obj( obj )
	{
	}
	public:		DFBResult ICore_Real__CreateSurface( CoreDFB *obj,
	virtual DFBResult CreateSurface(
	const CoreSurfaceConfig *config,		const CoreSurfaceConfig *config,
	CoreSurfaceTypeFlags type,		CoreSurfaceTypeFlags type,
	u64 resource_id,		u64 resource_id,
	CorePalette *palette,		CorePalette *palette,
	CoreSurface **ret_surface		CoreSurface **ret_surface
	);		);
	virtual DFBResult CreatePalette(		DFBResult ICore_Real__CreatePalette( CoreDFB *obj,
	u32 size,		u32 size,
	CorePalette **ret_palette		CorePalette **ret_palette
	);		);
	virtual DFBResult CreateState(
	CoreGraphicsState **ret_state
	);
	virtual DFBResult WaitIdle(
	);
	};		DFBResult ICore_Real__CreateState( CoreDFB *obj,
			CoreGraphicsState **ret_state );
	class ICore_Requestor : public ICore		DFBResult ICore_Real__WaitIdle( CoreDFB *obj
	{		);
	private:
	CoreDFB *obj;
	public:		DFBResult ICore_Requestor__Register( CoreDFB *obj
	ICore_Requestor( CoreDFB *core, CoreDFB *obj )		);
	:
	ICore( core ),
	obj( obj )
	{
	}
	public:		DFBResult ICore_Requestor__CreateSurface( CoreDFB *obj,
	virtual DFBResult CreateSurface(
	const CoreSurfaceConfig *config,		const CoreSurfaceConfig *config,
	CoreSurfaceTypeFlags type,		CoreSurfaceTypeFlags type,
	u64 resource_id,		u64 resource_id,
	CorePalette *palette,		CorePalette *palette,
	CoreSurface **ret_surface		CoreSurface **ret_surface
	);		);
	virtual DFBResult CreatePalette(		DFBResult ICore_Requestor__CreatePalette( CoreDFB *obj,
	u32 size,		u32 size,
	CorePalette **ret_palette		CorePalette **ret_palette
	);		);
	virtual DFBResult CreateState(
	CoreGraphicsState **ret_state
	);
	virtual DFBResult WaitIdle(
	);
	};
	class CoreDFBDispatch
	{
	public:
	CoreDFBDispatch( CoreDFB *core, ICore *real )
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,
	int method,
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:		DFBResult ICore_Requestor__CreateState( CoreDFB *obj,
	CoreDFB *core;		CoreGraphicsState **ret_state );
	ICore *real;
	};
	}		DFBResult ICore_Requestor__WaitIdle( CoreDFB *obj
			);
	#endif		DFBResult CoreDFBDispatch__Dispatch( CoreDFB *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 22 change blocks.
	123 lines changed or deleted		55 lines changed or added

	CoreDFB_includes.h		CoreDFB_includes.h
	skipping to change at line 20		skipping to change at line 20
	#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/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/screens.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
	CoreDFB_Call( CoreDFB *core,		CoreDFB_Call( CoreDFB *core,
	FusionCallExecFlags flags,		FusionCallExecFlags flags,
	int call_arg,		int call_arg,
	void *ptr,		void *ptr,
	skipping to change at line 365		skipping to change at line 366
	(FusionRefPermissions)(FUSION_REF_PERMIT_R EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );		(FusionRefPermissions)(FUSION_REF_PERMIT_R EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
	fusion_call_add_permissions( &palette->call, catcher, FUSION_CALL_PERM IT_EXECUTE );		fusion_call_add_permissions( &palette->call, catcher, FUSION_CALL_PERM IT_EXECUTE );
	if (!palette->object.owner)		if (!palette->object.owner)
	palette->object.owner = catcher;		palette->object.owner = catcher;
	return fusion_ref_throw( &palette->object.ref, catcher );		return fusion_ref_throw( &palette->object.ref, catcher );
	}		}
	static __inline__ u32		static __inline__ u32
			CoreScreen_GetID( const CoreScreen *screen )
			{
			return dfb_screen_id( screen );
			}
			static __inline__ DirectResult
			CoreScreen_Lookup( CoreDFB *core,
			u32 object_id,
			FusionID caller,
			CoreScreen **ret_screen )
			{
			if (object_id >= (u32) dfb_screens_num())
			return DR_IDNOTFOUND;
			*ret_screen = dfb_screens_at( object_id );
			return DR_OK;
			}
			static __inline__ DirectResult
			CoreScreen_Unref( CoreScreen *screen )
			{
			return DR_OK;
			}
			static __inline__ DirectResult
			CoreScreen_Catch( CoreDFB *core,
			u32 object_id,
			CoreScreen **ret_screen )
			{
			if (object_id >= (u32) dfb_screens_num())
			return DR_IDNOTFOUND;
			*ret_screen = dfb_screens_at( object_id );
			return DR_OK;
			}
			static __inline__ DirectResult
			CoreScreen_Throw( CoreScreen *screen,
			FusionID catcher,
			u32 *ret_object_id )
			{
			*ret_object_id = dfb_screen_id( screen );
			return DR_OK;
			}
			static __inline__ u32
	CoreSurface_GetID( const CoreSurface *surface )		CoreSurface_GetID( const CoreSurface *surface )
	{		{
	return surface->object.id;		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,		FusionID caller,
	CoreSurface **ret_surface )		CoreSurface **ret_surface )
End of changes. 2 change blocks.
	0 lines changed or deleted		50 lines changed or added

	CoreGraphicsState.h		CoreGraphicsState.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreGraphicsState__H___		#ifndef ___CoreGraphicsState__H___
	#define ___CoreGraphicsState__H___		#define ___CoreGraphicsState__H___
	#include "CoreGraphicsState_includes.h"		#include <core/CoreGraphicsState_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreGraphicsState		* CoreGraphicsState
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	skipping to change at line 177		skipping to change at line 177
	const DFBPoint *points1,		const DFBPoint *points1,
	const DFBPoint *points2,		const DFBPoint *points2,
	u32 num);		u32 num);
	DFBResult CoreGraphicsState_TextureTriangles(		DFBResult CoreGraphicsState_TextureTriangles(
	CoreGraphicsState *obj,		CoreGraphicsState *obj,
	const DFBVertex *vertices,		const DFBVertex *vertices,
	u32 num,		u32 num,
	DFBTriangleFormation formation);		DFBTriangleFormation formation);
	void *CoreGraphicsState_Init_Dispatch(		void CoreGraphicsState_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreGraphicsState *obj,		CoreGraphicsState *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreGraphicsState_Deinit_Dispatch(		void CoreGraphicsState_Deinit_Dispatch(
	void *dispatch		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreGraphicsState Calls		* CoreGraphicsState Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreGraphicsState_SetDrawingFlags = 1,		_CoreGraphicsState_SetDrawingFlags = 1,
	CoreGraphicsState_SetBlittingFlags = 2,		_CoreGraphicsState_SetBlittingFlags = 2,
	CoreGraphicsState_SetClip = 3,		_CoreGraphicsState_SetClip = 3,
	CoreGraphicsState_SetColor = 4,		_CoreGraphicsState_SetColor = 4,
	CoreGraphicsState_SetSrcBlend = 5,		_CoreGraphicsState_SetSrcBlend = 5,
	CoreGraphicsState_SetDstBlend = 6,		_CoreGraphicsState_SetDstBlend = 6,
	CoreGraphicsState_SetSrcColorKey = 7,		_CoreGraphicsState_SetSrcColorKey = 7,
	CoreGraphicsState_SetDstColorKey = 8,		_CoreGraphicsState_SetDstColorKey = 8,
	CoreGraphicsState_SetDestination = 9,		_CoreGraphicsState_SetDestination = 9,
	CoreGraphicsState_SetSource = 10,		_CoreGraphicsState_SetSource = 10,
	CoreGraphicsState_SetSourceMask = 11,		_CoreGraphicsState_SetSourceMask = 11,
	CoreGraphicsState_SetSourceMaskVals = 12,		_CoreGraphicsState_SetSourceMaskVals = 12,
	CoreGraphicsState_SetIndexTranslation = 13,		_CoreGraphicsState_SetIndexTranslation = 13,
	CoreGraphicsState_SetColorKey = 14,		_CoreGraphicsState_SetColorKey = 14,
	CoreGraphicsState_SetRenderOptions = 15,		_CoreGraphicsState_SetRenderOptions = 15,
	CoreGraphicsState_SetMatrix = 16,		_CoreGraphicsState_SetMatrix = 16,
	CoreGraphicsState_SetSource2 = 17,		_CoreGraphicsState_SetSource2 = 17,
	CoreGraphicsState_DrawRectangles = 18,		_CoreGraphicsState_DrawRectangles = 18,
	CoreGraphicsState_DrawLines = 19,		_CoreGraphicsState_DrawLines = 19,
	CoreGraphicsState_FillRectangles = 20,		_CoreGraphicsState_FillRectangles = 20,
	CoreGraphicsState_FillTriangles = 21,		_CoreGraphicsState_FillTriangles = 21,
	CoreGraphicsState_FillTrapezoids = 22,		_CoreGraphicsState_FillTrapezoids = 22,
	CoreGraphicsState_FillSpans = 23,		_CoreGraphicsState_FillSpans = 23,
	CoreGraphicsState_Blit = 24,		_CoreGraphicsState_Blit = 24,
	CoreGraphicsState_Blit2 = 25,		_CoreGraphicsState_Blit2 = 25,
	CoreGraphicsState_StretchBlit = 26,		_CoreGraphicsState_StretchBlit = 26,
	CoreGraphicsState_TileBlit = 27,		_CoreGraphicsState_TileBlit = 27,
	CoreGraphicsState_TextureTriangles = 28,		_CoreGraphicsState_TextureTriangles = 28,
	} CoreGraphicsStateCall;		} CoreGraphicsStateCall;
	/*		/*
	* CoreGraphicsState_SetDrawingFlags		* CoreGraphicsState_SetDrawingFlags
	*/		*/
	typedef struct {		typedef struct {
	DFBSurfaceDrawingFlags flags;		DFBSurfaceDrawingFlags flags;
	} CoreGraphicsStateSetDrawingFlags;		} CoreGraphicsStateSetDrawingFlags;
	typedef struct {		typedef struct {
	skipping to change at line 555		skipping to change at line 554
	typedef struct {		typedef struct {
	u32 num;		u32 num;
	DFBTriangleFormation formation;		DFBTriangleFormation formation;
	/* 'num' DFBVertex follow (vertices) */		/* 'num' DFBVertex follow (vertices) */
	} CoreGraphicsStateTextureTriangles;		} CoreGraphicsStateTextureTriangles;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreGraphicsStateTextureTrianglesReturn;		} CoreGraphicsStateTextureTrianglesReturn;
	class IGraphicsState : public Interface		DFBResult IGraphicsState_Real__SetDrawingFlags( CoreGraphicsState *obj,
	{		DFBSurfaceDrawingFlags flags );
	public:
	IGraphicsState( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult SetDrawingFlags(
	DFBSurfaceDrawingFlags flags
	) = 0;
	virtual DFBResult SetBlittingFlags(
	DFBSurfaceBlittingFlags flags
	) = 0;
	virtual DFBResult SetClip(
	const DFBRegion *region
	) = 0;
	virtual DFBResult SetColor(
	const DFBColor *color
	) = 0;
	virtual DFBResult SetSrcBlend(
	DFBSurfaceBlendFunction function
	) = 0;
	virtual DFBResult SetDstBlend(
	DFBSurfaceBlendFunction function
	) = 0;
	virtual DFBResult SetSrcColorKey(
	u32 key
	) = 0;
	virtual DFBResult SetDstColorKey(
	u32 key
	) = 0;
	virtual DFBResult SetDestination(
	CoreSurface *surface
	) = 0;
	virtual DFBResult SetSource(
	CoreSurface *surface
	) = 0;
	virtual DFBResult SetSourceMask(
	CoreSurface *surface
	) = 0;
	virtual DFBResult SetSourceMaskVals(
	const DFBPoint *offset,
	DFBSurfaceMaskFlags flags
	) = 0;
	virtual DFBResult SetIndexTranslation(
	const s32 *indices,
	u32 num
	) = 0;
	virtual DFBResult SetColorKey(
	const DFBColorKey *key
	) = 0;
	virtual DFBResult SetRenderOptions(
	DFBSurfaceRenderOptions options
	) = 0;
	virtual DFBResult SetMatrix(
	const s32 *values
	) = 0;
	virtual DFBResult SetSource2(
	CoreSurface *surface
	) = 0;
	virtual DFBResult DrawRectangles(
	const DFBRectangle *rects,
	u32 num
	) = 0;
	virtual DFBResult DrawLines(
	const DFBRegion *lines,
	u32 num
	) = 0;
	virtual DFBResult FillRectangles(
	const DFBRectangle *rects,
	u32 num
	) = 0;
	virtual DFBResult FillTriangles(
	const DFBTriangle *triangles,
	u32 num
	) = 0;
	virtual DFBResult FillTrapezoids(
	const DFBTrapezoid *trapezoids,
	u32 num
	) = 0;
	virtual DFBResult FillSpans(
	s32 y,
	const DFBSpan *spans,
	u32 num
	) = 0;
	virtual DFBResult Blit(
	const DFBRectangle *rects,
	const DFBPoint *points,
	u32 num
	) = 0;
	virtual DFBResult Blit2(
	const DFBRectangle *rects,
	const DFBPoint *points1,
	const DFBPoint *points2,
	u32 num
	) = 0;
	virtual DFBResult StretchBlit(
	const DFBRectangle *srects,
	const DFBRectangle *drects,
	u32 num
	) = 0;
	virtual DFBResult TileBlit(
	const DFBRectangle *rects,
	const DFBPoint *points1,
	const DFBPoint *points2,
	u32 num
	) = 0;
	virtual DFBResult TextureTriangles(
	const DFBVertex *vertices,
	u32 num,
	DFBTriangleFormation formation
	) = 0;
	};
	class IGraphicsState_Real : public IGraphicsState
	{
	private:
	CoreGraphicsState *obj;
	public:
	IGraphicsState_Real( CoreDFB *core, CoreGraphicsState *obj )
	:
	IGraphicsState( core ),
	obj( obj )
	{
	}
	public:
	virtual DFBResult SetDrawingFlags(
	DFBSurfaceDrawingFlags flags
	);
	virtual DFBResult SetBlittingFlags(		DFBResult IGraphicsState_Real__SetBlittingFlags( CoreGraphicsState *obj,
	DFBSurfaceBlittingFlags flags		DFBSurfaceBlittingFlags flags );
	);
	virtual DFBResult SetClip(		DFBResult IGraphicsState_Real__SetClip( CoreGraphicsState *obj,
	const DFBRegion *region		const DFBRegion *region );
	);
	virtual DFBResult SetColor(		DFBResult IGraphicsState_Real__SetColor( CoreGraphicsState *obj,
	const DFBColor *color		const DFBColor *color );
	);
	virtual DFBResult SetSrcBlend(		DFBResult IGraphicsState_Real__SetSrcBlend( CoreGraphicsState *obj,
	DFBSurfaceBlendFunction function		DFBSurfaceBlendFunction function );
	);
	virtual DFBResult SetDstBlend(		DFBResult IGraphicsState_Real__SetDstBlend( CoreGraphicsState *obj,
	DFBSurfaceBlendFunction function		DFBSurfaceBlendFunction function );
	);
	virtual DFBResult SetSrcColorKey(		DFBResult IGraphicsState_Real__SetSrcColorKey( CoreGraphicsState *obj,
	u32 key		u32 key );
	);
	virtual DFBResult SetDstColorKey(		DFBResult IGraphicsState_Real__SetDstColorKey( CoreGraphicsState *obj,
	u32 key		u32 key );
	);
	virtual DFBResult SetDestination(		DFBResult IGraphicsState_Real__SetDestination( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult SetSource(		DFBResult IGraphicsState_Real__SetSource( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult SetSourceMask(		DFBResult IGraphicsState_Real__SetSourceMask( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult SetSourceMaskVals(		DFBResult IGraphicsState_Real__SetSourceMaskVals( CoreGraphicsState *obj,
	const DFBPoint *offset,		const DFBPoint *offset,
	DFBSurfaceMaskFlags flags		DFBSurfaceMaskFlags flags );
	);
	virtual DFBResult SetIndexTranslation(		DFBResult IGraphicsState_Real__SetIndexTranslation( CoreGraphicsState *obj,
	const s32 *indices,		const s32 *indices,
	u32 num		u32 num );
	);
	virtual DFBResult SetColorKey(		DFBResult IGraphicsState_Real__SetColorKey( CoreGraphicsState *obj,
	const DFBColorKey *key		const DFBColorKey *key );
	);
	virtual DFBResult SetRenderOptions(		DFBResult IGraphicsState_Real__SetRenderOptions( CoreGraphicsState *obj,
	DFBSurfaceRenderOptions options		DFBSurfaceRenderOptions options );
	);
	virtual DFBResult SetMatrix(		DFBResult IGraphicsState_Real__SetMatrix( CoreGraphicsState *obj,
	const s32 *values		const s32 *values );
	);
	virtual DFBResult SetSource2(		DFBResult IGraphicsState_Real__SetSource2( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult DrawRectangles(		DFBResult IGraphicsState_Real__DrawRectangles( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	u32 num		u32 num );
	);
	virtual DFBResult DrawLines(		DFBResult IGraphicsState_Real__DrawLines( CoreGraphicsState *obj,
	const DFBRegion *lines,		const DFBRegion *lines,
	u32 num		u32 num );
	);
	virtual DFBResult FillRectangles(		DFBResult IGraphicsState_Real__FillRectangles( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	u32 num		u32 num );
	);
	virtual DFBResult FillTriangles(		DFBResult IGraphicsState_Real__FillTriangles( CoreGraphicsState *obj,
	const DFBTriangle *triangles,		const DFBTriangle *triangles,
	u32 num		u32 num );
	);
	virtual DFBResult FillTrapezoids(		DFBResult IGraphicsState_Real__FillTrapezoids( CoreGraphicsState *obj,
	const DFBTrapezoid *trapezoids,		const DFBTrapezoid *trapezoids,
	u32 num		u32 num );
	);
	virtual DFBResult FillSpans(		DFBResult IGraphicsState_Real__FillSpans( CoreGraphicsState *obj,
	s32 y,		s32 y,
	const DFBSpan *spans,		const DFBSpan *spans,
	u32 num		u32 num );
	);
	virtual DFBResult Blit(		DFBResult IGraphicsState_Real__Blit( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	const DFBPoint *points,		const DFBPoint *points,
	u32 num		u32 num );
	);
	virtual DFBResult Blit2(		DFBResult IGraphicsState_Real__Blit2( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	const DFBPoint *points1,		const DFBPoint *points1,
	const DFBPoint *points2,		const DFBPoint *points2,
	u32 num		u32 num );
	);
	virtual DFBResult StretchBlit(		DFBResult IGraphicsState_Real__StretchBlit( CoreGraphicsState *obj,
	const DFBRectangle *srects,		const DFBRectangle *srects,
	const DFBRectangle *drects,		const DFBRectangle *drects,
	u32 num		u32 num );
	);
	virtual DFBResult TileBlit(		DFBResult IGraphicsState_Real__TileBlit( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	const DFBPoint *points1,		const DFBPoint *points1,
	const DFBPoint *points2,		const DFBPoint *points2,
	u32 num		u32 num );
	);
	virtual DFBResult TextureTriangles(		DFBResult IGraphicsState_Real__TextureTriangles( CoreGraphicsState *obj,
	const DFBVertex *vertices,		const DFBVertex *vertices,
	u32 num,		u32 num,
	DFBTriangleFormation formation		DFBTriangleFormation formation );
	);
	};
	class IGraphicsState_Requestor : public IGraphicsState
	{
	private:
	CoreGraphicsState *obj;
	public:
	IGraphicsState_Requestor( CoreDFB *core, CoreGraphicsState *obj )
	:
	IGraphicsState( core ),
	obj( obj )
	{
	}
	public:		DFBResult IGraphicsState_Requestor__SetDrawingFlags( CoreGraphicsState *obj
	virtual DFBResult SetDrawingFlags(		,
	DFBSurfaceDrawingFlags flags		DFBSurfaceDrawingFlags flags );
	);
	virtual DFBResult SetBlittingFlags(		DFBResult IGraphicsState_Requestor__SetBlittingFlags( CoreGraphicsState *ob
	DFBSurfaceBlittingFlags flags		j,
	);		DFBSurfaceBlittingFlags flags );
	virtual DFBResult SetClip(		DFBResult IGraphicsState_Requestor__SetClip( CoreGraphicsState *obj,
	const DFBRegion *region		const DFBRegion *region );
	);
	virtual DFBResult SetColor(		DFBResult IGraphicsState_Requestor__SetColor( CoreGraphicsState *obj,
	const DFBColor *color		const DFBColor *color );
	);
	virtual DFBResult SetSrcBlend(		DFBResult IGraphicsState_Requestor__SetSrcBlend( CoreGraphicsState *obj,
	DFBSurfaceBlendFunction function		DFBSurfaceBlendFunction function );
	);
	virtual DFBResult SetDstBlend(		DFBResult IGraphicsState_Requestor__SetDstBlend( CoreGraphicsState *obj,
	DFBSurfaceBlendFunction function		DFBSurfaceBlendFunction function );
	);
	virtual DFBResult SetSrcColorKey(		DFBResult IGraphicsState_Requestor__SetSrcColorKey( CoreGraphicsState *obj,
	u32 key		u32 key );
	);
	virtual DFBResult SetDstColorKey(		DFBResult IGraphicsState_Requestor__SetDstColorKey( CoreGraphicsState *obj,
	u32 key		u32 key );
	);
	virtual DFBResult SetDestination(		DFBResult IGraphicsState_Requestor__SetDestination( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult SetSource(		DFBResult IGraphicsState_Requestor__SetSource( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult SetSourceMask(		DFBResult IGraphicsState_Requestor__SetSourceMask( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult SetSourceMaskVals(		DFBResult IGraphicsState_Requestor__SetSourceMaskVals( CoreGraphicsState *o bj,
	const DFBPoint *offset,		const DFBPoint *offset,
	DFBSurfaceMaskFlags flags		DFBSurfaceMaskFlags flags );
	);
	virtual DFBResult SetIndexTranslation(		DFBResult IGraphicsState_Requestor__SetIndexTranslation( CoreGraphicsState *obj,
	const s32 *indices,		const s32 *indices,
	u32 num		u32 num );
	);
	virtual DFBResult SetColorKey(		DFBResult IGraphicsState_Requestor__SetColorKey( CoreGraphicsState *obj,
	const DFBColorKey *key		const DFBColorKey *key );
	);
	virtual DFBResult SetRenderOptions(		DFBResult IGraphicsState_Requestor__SetRenderOptions( CoreGraphicsState *ob
	DFBSurfaceRenderOptions options		j,
	);		DFBSurfaceRenderOptions options );
	virtual DFBResult SetMatrix(		DFBResult IGraphicsState_Requestor__SetMatrix( CoreGraphicsState *obj,
	const s32 *values		const s32 *values );
	);
	virtual DFBResult SetSource2(		DFBResult IGraphicsState_Requestor__SetSource2( CoreGraphicsState *obj,
	CoreSurface *surface		CoreSurface *surface );
	);
	virtual DFBResult DrawRectangles(		DFBResult IGraphicsState_Requestor__DrawRectangles( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	u32 num		u32 num );
	);
	virtual DFBResult DrawLines(		DFBResult IGraphicsState_Requestor__DrawLines( CoreGraphicsState *obj,
	const DFBRegion *lines,		const DFBRegion *lines,
	u32 num		u32 num );
	);
	virtual DFBResult FillRectangles(		DFBResult IGraphicsState_Requestor__FillRectangles( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	u32 num		u32 num );
	);
	virtual DFBResult FillTriangles(		DFBResult IGraphicsState_Requestor__FillTriangles( CoreGraphicsState *obj,
	const DFBTriangle *triangles,		const DFBTriangle *triangles,
	u32 num		u32 num );
	);
	virtual DFBResult FillTrapezoids(		DFBResult IGraphicsState_Requestor__FillTrapezoids( CoreGraphicsState *obj,
	const DFBTrapezoid *trapezoids,		const DFBTrapezoid *trapezoids,
	u32 num		u32 num );
	);
	virtual DFBResult FillSpans(		DFBResult IGraphicsState_Requestor__FillSpans( CoreGraphicsState *obj,
	s32 y,		s32 y,
	const DFBSpan *spans,		const DFBSpan *spans,
	u32 num		u32 num );
	);
	virtual DFBResult Blit(		DFBResult IGraphicsState_Requestor__Blit( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	const DFBPoint *points,		const DFBPoint *points,
	u32 num		u32 num );
	);
	virtual DFBResult Blit2(		DFBResult IGraphicsState_Requestor__Blit2( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	const DFBPoint *points1,		const DFBPoint *points1,
	const DFBPoint *points2,		const DFBPoint *points2,
	u32 num		u32 num );
	);
	virtual DFBResult StretchBlit(		DFBResult IGraphicsState_Requestor__StretchBlit( CoreGraphicsState *obj,
	const DFBRectangle *srects,		const DFBRectangle *srects,
	const DFBRectangle *drects,		const DFBRectangle *drects,
	u32 num		u32 num );
	);
	virtual DFBResult TileBlit(		DFBResult IGraphicsState_Requestor__TileBlit( CoreGraphicsState *obj,
	const DFBRectangle *rects,		const DFBRectangle *rects,
	const DFBPoint *points1,		const DFBPoint *points1,
	const DFBPoint *points2,		const DFBPoint *points2,
	u32 num		u32 num );
	);
	virtual DFBResult TextureTriangles(		DFBResult IGraphicsState_Requestor__TextureTriangles( CoreGraphicsState *ob j,
	const DFBVertex *vertices,		const DFBVertex *vertices,
	u32 num,		u32 num,
	DFBTriangleFormation formation		DFBTriangleFormation formation );
	);
	};
	class CoreGraphicsStateDispatch
	{
	public:
	CoreGraphicsStateDispatch( CoreDFB *core, IGraphicsState *real )
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,
	int method,
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:
	CoreDFB *core;
	IGraphicsState *real;
	};
	}
	#endif		DFBResult CoreGraphicsStateDispatch__Dispatch( CoreGraphicsState *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 88 change blocks.
	405 lines changed or deleted		155 lines changed or added

	CoreLayer.h		CoreLayer.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreLayer__H___		#ifndef ___CoreLayer__H___
	#define ___CoreLayer__H___		#define ___CoreLayer__H___
	#include "CoreLayer_includes.h"		#include <core/CoreLayer_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreLayer		* CoreLayer
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	DFBResult CoreLayer_CreateContext(		DFBResult CoreLayer_CreateContext(
	CoreLayer *obj,		CoreLayer *obj,
	CoreLayerContext **ret_context) ;		CoreLayerContext **ret_context) ;
			DFBResult CoreLayer_GetPrimaryContext(
			CoreLayer *obj,
			bool activate,
			CoreLayerContext **ret_context)
			;
	DFBResult CoreLayer_ActivateContext(		DFBResult CoreLayer_ActivateContext(
	CoreLayer *obj,		CoreLayer *obj,
	CoreLayerContext *context);		CoreLayerContext *context);
	DFBResult CoreLayer_GetPrimaryContext(		DFBResult CoreLayer_GetCurrentOutputField(
	CoreLayer *obj,		CoreLayer *obj,
	bool activate,		s32 *ret_field);
	CoreLayerContext **ret_context)
	;
	void *CoreLayer_Init_Dispatch(		DFBResult CoreLayer_SetLevel(
			CoreLayer *obj,
			s32 level);
			DFBResult CoreLayer_WaitVSync(
			CoreLayer *obj
			);
			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		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreLayer Calls		* CoreLayer Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreLayer_CreateContext = 1,		_CoreLayer_CreateContext = 1,
	CoreLayer_ActivateContext = 2,		_CoreLayer_GetPrimaryContext = 2,
	CoreLayer_GetPrimaryContext = 3,		_CoreLayer_ActivateContext = 3,
			_CoreLayer_GetCurrentOutputField = 4,
			_CoreLayer_SetLevel = 5,
			_CoreLayer_WaitVSync = 6,
	} CoreLayerCall;		} CoreLayerCall;
	/*		/*
	* CoreLayer_CreateContext		* CoreLayer_CreateContext
	*/		*/
	typedef struct {		typedef struct {
	} CoreLayerCreateContext;		} CoreLayerCreateContext;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 context_id;		u32 context_id;
	} CoreLayerCreateContextReturn;		} CoreLayerCreateContextReturn;
	/*		/*
			* CoreLayer_GetPrimaryContext
			*/
			typedef struct {
			bool activate;
			} CoreLayerGetPrimaryContext;
			typedef struct {
			DFBResult result;
			u32 context_id;
			} CoreLayerGetPrimaryContextReturn;
			/*
	* 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		* CoreLayer_GetCurrentOutputField
	*/		*/
	typedef struct {		typedef struct {
	bool activate;		} CoreLayerGetCurrentOutputField;
	} CoreLayerGetPrimaryContext;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 context_id;		s32 field;
	} CoreLayerGetPrimaryContextReturn;		} CoreLayerGetCurrentOutputFieldReturn;
	class ILayer : public Interface
	{
	public:
	ILayer( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult CreateContext(
	CoreLayerContext **ret_context
	) = 0;
	virtual DFBResult ActivateContext(
	CoreLayerContext *context
	) = 0;
	virtual DFBResult GetPrimaryContext(
	bool activate,
	CoreLayerContext **ret_context
	) = 0;
	};		/*
			* CoreLayer_SetLevel
			*/
			typedef struct {
			s32 level;
			} CoreLayerSetLevel;
	class ILayer_Real : public ILayer		typedef struct {
	{		DFBResult result;
	private:		} CoreLayerSetLevelReturn;
	CoreLayer *obj;
	public:		/*
	ILayer_Real( CoreDFB *core, CoreLayer *obj )		* CoreLayer_WaitVSync
	:		*/
	ILayer( core ),		typedef struct {
	obj( obj )		} CoreLayerWaitVSync;
	{
	}
	public:		typedef struct {
	virtual DFBResult CreateContext(		DFBResult result;
	CoreLayerContext **ret_context		} CoreLayerWaitVSyncReturn;
	);
	virtual DFBResult ActivateContext(		DFBResult ILayer_Real__CreateContext( CoreLayer *obj,
	CoreLayerContext *context		CoreLayerContext **ret_context
	);		);
	virtual DFBResult GetPrimaryContext(		DFBResult ILayer_Real__GetPrimaryContext( CoreLayer *obj,
	bool activate,		bool activate,
	CoreLayerContext **ret_context		CoreLayerContext **ret_context
	);		);
	};		DFBResult ILayer_Real__ActivateContext( CoreLayer *obj,
			CoreLayerContext *context );
	class ILayer_Requestor : public ILayer		DFBResult ILayer_Real__GetCurrentOutputField( CoreLayer *obj,
	{		s32 *ret_field );
	private:
	CoreLayer *obj;
	public:		DFBResult ILayer_Real__SetLevel( CoreLayer *obj,
	ILayer_Requestor( CoreDFB *core, CoreLayer *obj )		s32 level );
	:
	ILayer( core ),
	obj( obj )
	{
	}
	public:		DFBResult ILayer_Real__WaitVSync( CoreLayer *obj
	virtual DFBResult CreateContext(		);
	CoreLayerContext **ret_context
	);
	virtual DFBResult ActivateContext(		DFBResult ILayer_Requestor__CreateContext( CoreLayer *obj,
	CoreLayerContext *context		CoreLayerContext **ret_context
	);		);
	virtual DFBResult GetPrimaryContext(		DFBResult ILayer_Requestor__GetPrimaryContext( CoreLayer *obj,
	bool activate,		bool activate,
	CoreLayerContext **ret_context		CoreLayerContext **ret_context
	);		);
	};
	class CoreLayerDispatch
	{
	public:		DFBResult ILayer_Requestor__ActivateContext( CoreLayer *obj,
	CoreLayerDispatch( CoreDFB *core, ILayer *real )		CoreLayerContext *context );
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,		DFBResult ILayer_Requestor__GetCurrentOutputField( CoreLayer *obj,
	int method,		s32 *ret_field );
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:		DFBResult ILayer_Requestor__SetLevel( CoreLayer *obj,
	CoreDFB *core;		s32 level );
	ILayer *real;
	};
	}		DFBResult ILayer_Requestor__WaitVSync( CoreLayer *obj
			);
	#endif		DFBResult CoreLayerDispatch__Dispatch( CoreLayer *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 31 change blocks.
	109 lines changed or deleted		95 lines changed or added

	CoreLayerContext.h		CoreLayerContext.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreLayerContext__H___		#ifndef ___CoreLayerContext__H___
	#define ___CoreLayerContext__H___		#define ___CoreLayerContext__H___
	#include "CoreLayerContext_includes.h"		#include <core/CoreLayerContext_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreLayerContext		* CoreLayerContext
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
			DFBResult CoreLayerContext_GetPrimaryRegion(
			CoreLayerContext *obj,
			bool create,
			CoreLayerRegion **ret_region);
			DFBResult CoreLayerContext_TestConfiguration(
			CoreLayerContext *obj,
			const DFBDisplayLayerConfig *config,
			DFBDisplayLayerConfigFlags *ret_failed);
			DFBResult CoreLayerContext_SetConfiguration(
			CoreLayerContext *obj,
			const DFBDisplayLayerConfig *config);
			DFBResult CoreLayerContext_SetSrcColorKey(
			CoreLayerContext *obj,
			const DFBColorKey *key);
			DFBResult CoreLayerContext_SetDstColorKey(
			CoreLayerContext *obj,
			const DFBColorKey *key);
			DFBResult CoreLayerContext_SetSourceRectangle(
			CoreLayerContext *obj,
			const DFBRectangle *rectangle);
			DFBResult CoreLayerContext_SetScreenLocation(
			CoreLayerContext *obj,
			const DFBLocation *location);
			DFBResult CoreLayerContext_SetScreenRectangle(
			CoreLayerContext *obj,
			const DFBRectangle *rectangle);
			DFBResult CoreLayerContext_SetScreenPosition(
			CoreLayerContext *obj,
			const DFBPoint *position);
			DFBResult CoreLayerContext_SetOpacity(
			CoreLayerContext *obj,
			u8 opacity);
			DFBResult CoreLayerContext_SetRotation(
			CoreLayerContext *obj,
			s32 rotation);
			DFBResult CoreLayerContext_SetColorAdjustment(
			CoreLayerContext *obj,
			const DFBColorAdjustment *adjustment);
			DFBResult CoreLayerContext_SetFieldParity(
			CoreLayerContext *obj,
			u32 field);
			DFBResult CoreLayerContext_SetClipRegions(
			CoreLayerContext *obj,
			const DFBRegion *regions,
			u32 num,
			bool positive);
	DFBResult CoreLayerContext_CreateWindow(		DFBResult CoreLayerContext_CreateWindow(
	CoreLayerContext *obj,		CoreLayerContext *obj,
	const DFBWindowDescription *description,		const DFBWindowDescription *description,
	CoreWindow *parent,		CoreWindow *parent,
	CoreWindow *toplevel,		CoreWindow *toplevel,
	CoreWindow **ret_window);		CoreWindow **ret_window);
	DFBResult CoreLayerContext_SetConfiguration(		DFBResult CoreLayerContext_FindWindow(
	CoreLayerContext *obj,
	const DFBDisplayLayerConfig *config);
	DFBResult CoreLayerContext_GetPrimaryRegion(
	CoreLayerContext *obj,		CoreLayerContext *obj,
	bool create,		DFBWindowID window_id,
	CoreLayerRegion **ret_region);		CoreWindow **ret_window);
	void *CoreLayerContext_Init_Dispatch(		void CoreLayerContext_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreLayerContext *obj,		CoreLayerContext *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreLayerContext_Deinit_Dispatch(		void CoreLayerContext_Deinit_Dispatch(
	void *dispatch		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreLayerContext Calls		* CoreLayerContext Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreLayerContext_CreateWindow = 1,		_CoreLayerContext_GetPrimaryRegion = 1,
	CoreLayerContext_SetConfiguration = 2,		_CoreLayerContext_TestConfiguration = 2,
	CoreLayerContext_GetPrimaryRegion = 3,		_CoreLayerContext_SetConfiguration = 3,
			_CoreLayerContext_SetSrcColorKey = 4,
			_CoreLayerContext_SetDstColorKey = 5,
			_CoreLayerContext_SetSourceRectangle = 6,
			_CoreLayerContext_SetScreenLocation = 7,
			_CoreLayerContext_SetScreenRectangle = 8,
			_CoreLayerContext_SetScreenPosition = 9,
			_CoreLayerContext_SetOpacity = 10,
			_CoreLayerContext_SetRotation = 11,
			_CoreLayerContext_SetColorAdjustment = 12,
			_CoreLayerContext_SetFieldParity = 13,
			_CoreLayerContext_SetClipRegions = 14,
			_CoreLayerContext_CreateWindow = 15,
			_CoreLayerContext_FindWindow = 16,
	} CoreLayerContextCall;		} CoreLayerContextCall;
	/*		/*
	* CoreLayerContext_CreateWindow		* CoreLayerContext_GetPrimaryRegion
	*/		*/
	typedef struct {		typedef struct {
	DFBWindowDescription description;		bool create;
	bool parent_set;		} CoreLayerContextGetPrimaryRegion;
	u32 parent_id;
	bool toplevel_set;
	u32 toplevel_id;
	} CoreLayerContextCreateWindow;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 window_id;		u32 region_id;
	} CoreLayerContextCreateWindowReturn;		} CoreLayerContextGetPrimaryRegionReturn;
			/*
			* CoreLayerContext_TestConfiguration
			*/
			typedef struct {
			DFBDisplayLayerConfig config;
			} CoreLayerContextTestConfiguration;
			typedef struct {
			DFBResult result;
			DFBDisplayLayerConfigFlags failed;
			} CoreLayerContextTestConfigurationReturn;
	/*		/*
	* CoreLayerContext_SetConfiguration		* CoreLayerContext_SetConfiguration
	*/		*/
	typedef struct {		typedef struct {
	DFBDisplayLayerConfig config;		DFBDisplayLayerConfig config;
	} CoreLayerContextSetConfiguration;		} CoreLayerContextSetConfiguration;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreLayerContextSetConfigurationReturn;		} CoreLayerContextSetConfigurationReturn;
	/*		/*
	* CoreLayerContext_GetPrimaryRegion		* CoreLayerContext_SetSrcColorKey
	*/		*/
	typedef struct {		typedef struct {
	bool create;		DFBColorKey key;
	} CoreLayerContextGetPrimaryRegion;		} CoreLayerContextSetSrcColorKey;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 region_id;		} CoreLayerContextSetSrcColorKeyReturn;
	} CoreLayerContextGetPrimaryRegionReturn;
	class ILayerContext : public Interface		/*
	{		* CoreLayerContext_SetDstColorKey
	public:		*/
	ILayerContext( CoreDFB *core )		typedef struct {
	:		DFBColorKey key;
	Interface( core )		} CoreLayerContextSetDstColorKey;
	{
	}
	public:		typedef struct {
	virtual DFBResult CreateWindow(		DFBResult result;
	const DFBWindowDescription *description,		} CoreLayerContextSetDstColorKeyReturn;
	CoreWindow *parent,
	CoreWindow *toplevel,
	CoreWindow **ret_window
	) = 0;
	virtual DFBResult SetConfiguration(		/*
	const DFBDisplayLayerConfig *config		* CoreLayerContext_SetSourceRectangle
	) = 0;		*/
			typedef struct {
			DFBRectangle rectangle;
			} CoreLayerContextSetSourceRectangle;
	virtual DFBResult GetPrimaryRegion(		typedef struct {
	bool create,		DFBResult result;
	CoreLayerRegion **ret_region		} CoreLayerContextSetSourceRectangleReturn;
	) = 0;
	};		/*
			* CoreLayerContext_SetScreenLocation
			*/
			typedef struct {
			DFBLocation location;
			} CoreLayerContextSetScreenLocation;
	class ILayerContext_Real : public ILayerContext		typedef struct {
	{		DFBResult result;
	private:		} CoreLayerContextSetScreenLocationReturn;
	CoreLayerContext *obj;
	public:		/*
	ILayerContext_Real( CoreDFB *core, CoreLayerContext *obj )		* CoreLayerContext_SetScreenRectangle
	:		*/
	ILayerContext( core ),		typedef struct {
	obj( obj )		DFBRectangle rectangle;
	{		} CoreLayerContextSetScreenRectangle;
	}
	public:		typedef struct {
	virtual DFBResult CreateWindow(		DFBResult result;
	const DFBWindowDescription *description,		} CoreLayerContextSetScreenRectangleReturn;
	CoreWindow *parent,
	CoreWindow *toplevel,
	CoreWindow **ret_window
	);
	virtual DFBResult SetConfiguration(		/*
	const DFBDisplayLayerConfig *config		* CoreLayerContext_SetScreenPosition
	);		*/
			typedef struct {
			DFBPoint position;
			} CoreLayerContextSetScreenPosition;
	virtual DFBResult GetPrimaryRegion(		typedef struct {
			DFBResult result;
			} CoreLayerContextSetScreenPositionReturn;
			/*
			* CoreLayerContext_SetOpacity
			*/
			typedef struct {
			u8 opacity;
			} CoreLayerContextSetOpacity;
			typedef struct {
			DFBResult result;
			} CoreLayerContextSetOpacityReturn;
			/*
			* CoreLayerContext_SetRotation
			*/
			typedef struct {
			s32 rotation;
			} CoreLayerContextSetRotation;
			typedef struct {
			DFBResult result;
			} CoreLayerContextSetRotationReturn;
			/*
			* CoreLayerContext_SetColorAdjustment
			*/
			typedef struct {
			DFBColorAdjustment adjustment;
			} CoreLayerContextSetColorAdjustment;
			typedef struct {
			DFBResult result;
			} CoreLayerContextSetColorAdjustmentReturn;
			/*
			* CoreLayerContext_SetFieldParity
			*/
			typedef struct {
			u32 field;
			} CoreLayerContextSetFieldParity;
			typedef struct {
			DFBResult result;
			} CoreLayerContextSetFieldParityReturn;
			/*
			* CoreLayerContext_SetClipRegions
			*/
			typedef struct {
			u32 num;
			bool positive;
			/* 'num' DFBRegion follow (regions) */
			} CoreLayerContextSetClipRegions;
			typedef struct {
			DFBResult result;
			} CoreLayerContextSetClipRegionsReturn;
			/*
			* CoreLayerContext_CreateWindow
			*/
			typedef struct {
			DFBWindowDescription description;
			bool parent_set;
			u32 parent_id;
			bool toplevel_set;
			u32 toplevel_id;
			} CoreLayerContextCreateWindow;
			typedef struct {
			DFBResult result;
			u32 window_id;
			} CoreLayerContextCreateWindowReturn;
			/*
			* CoreLayerContext_FindWindow
			*/
			typedef struct {
			DFBWindowID window_id;
			} CoreLayerContextFindWindow;
			typedef struct {
			DFBResult result;
			u32 window_id;
			} CoreLayerContextFindWindowReturn;
			DFBResult ILayerContext_Real__GetPrimaryRegion( CoreLayerContext *obj,
	bool create,		bool create,
	CoreLayerRegion **ret_region		CoreLayerRegion **ret_region )
	);		;
	};		DFBResult ILayerContext_Real__TestConfiguration( CoreLayerContext *obj,
			const DFBDisplayLayerConfig *config,
			DFBDisplayLayerConfigFlags *ret_failed )
			;
	class ILayerContext_Requestor : public ILayerContext		DFBResult ILayerContext_Real__SetConfiguration( CoreLayerContext *obj,
	{		const DFBDisplayLayerConfig *config );
	private:
	CoreLayerContext *obj;
	public:		DFBResult ILayerContext_Real__SetSrcColorKey( CoreLayerContext *obj,
	ILayerContext_Requestor( CoreDFB *core, CoreLayerContext *obj )		const DFBColorKey *key );
	:
	ILayerContext( core ),
	obj( obj )
	{
	}
	public:		DFBResult ILayerContext_Real__SetDstColorKey( CoreLayerContext *obj,
	virtual DFBResult CreateWindow(		const DFBColorKey *key );
			DFBResult ILayerContext_Real__SetSourceRectangle( CoreLayerContext *obj,
			const DFBRectangle *rectangle );
			DFBResult ILayerContext_Real__SetScreenLocation( CoreLayerContext *obj,
			const DFBLocation *location );
			DFBResult ILayerContext_Real__SetScreenRectangle( CoreLayerContext *obj,
			const DFBRectangle *rectangle );
			DFBResult ILayerContext_Real__SetScreenPosition( CoreLayerContext *obj,
			const DFBPoint *position );
			DFBResult ILayerContext_Real__SetOpacity( CoreLayerContext *obj,
			u8 opacity );
			DFBResult ILayerContext_Real__SetRotation( CoreLayerContext *obj,
			s32 rotation );
			DFBResult ILayerContext_Real__SetColorAdjustment( CoreLayerContext *obj,
			const DFBColorAdjustment *adjustment )
			;
			DFBResult ILayerContext_Real__SetFieldParity( CoreLayerContext *obj,
			u32 field );
			DFBResult ILayerContext_Real__SetClipRegions( CoreLayerContext *obj,
			const DFBRegion *regions,
			u32 num,
			bool positive );
			DFBResult ILayerContext_Real__CreateWindow( CoreLayerContext *obj,
	const DFBWindowDescription *description,		const DFBWindowDescription *description,
	CoreWindow *parent,		CoreWindow *parent,
	CoreWindow *toplevel,		CoreWindow *toplevel,
	CoreWindow **ret_window		CoreWindow **ret_window )
	);		;
	virtual DFBResult SetConfiguration(		DFBResult ILayerContext_Real__FindWindow( CoreLayerContext *obj,
	const DFBDisplayLayerConfig *config		DFBWindowID window_id,
	);		CoreWindow **ret_window )
			;
	virtual DFBResult GetPrimaryRegion(		DFBResult ILayerContext_Requestor__GetPrimaryRegion( CoreLayerContext *obj,
	bool create,		bool create,
	CoreLayerRegion **ret_region		CoreLayerRegion **ret_region )
	);		;
	};		DFBResult ILayerContext_Requestor__TestConfiguration( CoreLayerContext *obj
			,
			const DFBDisplayLayerConfig *config,
			DFBDisplayLayerConfigFlags *ret_failed )
			;
	class CoreLayerContextDispatch		DFBResult ILayerContext_Requestor__SetConfiguration( CoreLayerContext *obj,
	{		const DFBDisplayLayerConfig *config );
	public:		DFBResult ILayerContext_Requestor__SetSrcColorKey( CoreLayerContext *obj,
	CoreLayerContextDispatch( CoreDFB *core, ILayerContext *real )		const DFBColorKey *key );
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,		DFBResult ILayerContext_Requestor__SetDstColorKey( CoreLayerContext *obj,
	int method,		const DFBColorKey *key );
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:		DFBResult ILayerContext_Requestor__SetSourceRectangle( CoreLayerContext *ob
	CoreDFB *core;		j,
	ILayerContext *real;		const DFBRectangle *rectangle );
	};
	}		DFBResult ILayerContext_Requestor__SetScreenLocation( CoreLayerContext *obj
			,
			const DFBLocation *location );
	#endif		DFBResult ILayerContext_Requestor__SetScreenRectangle( CoreLayerContext *ob
			j,
			const DFBRectangle *rectangle );
			DFBResult ILayerContext_Requestor__SetScreenPosition( CoreLayerContext *obj
			,
			const DFBPoint *position );
			DFBResult ILayerContext_Requestor__SetOpacity( CoreLayerContext *obj,
			u8 opacity );
			DFBResult ILayerContext_Requestor__SetRotation( CoreLayerContext *obj,
			s32 rotation );
			DFBResult ILayerContext_Requestor__SetColorAdjustment( CoreLayerContext *ob
			j,
			const DFBColorAdjustment *adjustment )
			;
			DFBResult ILayerContext_Requestor__SetFieldParity( CoreLayerContext *obj,
			u32 field );
			DFBResult ILayerContext_Requestor__SetClipRegions( CoreLayerContext *obj,
			const DFBRegion *regions,
			u32 num,
			bool positive );
			DFBResult ILayerContext_Requestor__CreateWindow( CoreLayerContext *obj,
			const DFBWindowDescription *description,
			CoreWindow *parent,
			CoreWindow *toplevel,
			CoreWindow **ret_window )
			;
			DFBResult ILayerContext_Requestor__FindWindow( CoreLayerContext *obj,
			DFBWindowID window_id,
			CoreWindow **ret_window )
			;
			DFBResult CoreLayerContextDispatch__Dispatch( CoreLayerContext *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 40 change blocks.
	121 lines changed or deleted		353 lines changed or added

	CoreLayerRegion.h		CoreLayerRegion.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreLayerRegion__H___		#ifndef ___CoreLayerRegion__H___
	#define ___CoreLayerRegion__H___		#define ___CoreLayerRegion__H___
	#include "CoreLayerRegion_includes.h"		#include <core/CoreLayerRegion_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreLayerRegion		* CoreLayerRegion
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
			DFBResult CoreLayerRegion_GetSurface(
			CoreLayerRegion *obj,
			CoreSurface **ret_surface)
			;
	DFBResult CoreLayerRegion_FlipUpdate(		DFBResult CoreLayerRegion_FlipUpdate(
	CoreLayerRegion *obj,		CoreLayerRegion *obj,
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags);		DFBSurfaceFlipFlags flags);
	DFBResult CoreLayerRegion_GetSurface(		void CoreLayerRegion_Init_Dispatch(
	CoreLayerRegion *obj,
	CoreSurface **ret_surface)
	;
	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		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreLayerRegion Calls		* CoreLayerRegion Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreLayerRegion_FlipUpdate = 1,		_CoreLayerRegion_GetSurface = 1,
	CoreLayerRegion_GetSurface = 2,		_CoreLayerRegion_FlipUpdate = 2,
	} CoreLayerRegionCall;		} CoreLayerRegionCall;
	/*		/*
	* CoreLayerRegion_FlipUpdate		* CoreLayerRegion_GetSurface
	*/		*/
	typedef struct {		typedef struct {
	bool update_set;		} CoreLayerRegionGetSurface;
	DFBRegion update;
	DFBSurfaceFlipFlags flags;
	} CoreLayerRegionFlipUpdate;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreLayerRegionFlipUpdateReturn;		u32 surface_id;
			} CoreLayerRegionGetSurfaceReturn;
	/*		/*
	* CoreLayerRegion_GetSurface		* CoreLayerRegion_FlipUpdate
	*/		*/
	typedef struct {		typedef struct {
	} CoreLayerRegionGetSurface;		bool update_set;
			DFBRegion update;
			DFBSurfaceFlipFlags flags;
			} CoreLayerRegionFlipUpdate;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 surface_id;		} CoreLayerRegionFlipUpdateReturn;
	} CoreLayerRegionGetSurfaceReturn;
	class ILayerRegion : public Interface
	{
	public:
	ILayerRegion( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult FlipUpdate(
	const DFBRegion *update,
	DFBSurfaceFlipFlags flags
	) = 0;
	virtual DFBResult GetSurface(
	CoreSurface **ret_surface
	) = 0;
	};
	class ILayerRegion_Real : public ILayerRegion
	{
	private:
	CoreLayerRegion *obj;
	public:		DFBResult ILayerRegion_Real__GetSurface( CoreLayerRegion *obj,
	ILayerRegion_Real( CoreDFB *core, CoreLayerRegion *obj )		CoreSurface **ret_surface
	:		);
	ILayerRegion( core ),
	obj( obj )
	{
	}
	public:		DFBResult ILayerRegion_Real__FlipUpdate( CoreLayerRegion *obj,
	virtual DFBResult FlipUpdate(
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags );
	);
	virtual DFBResult GetSurface(
	CoreSurface **ret_surface
	);
	};
	class ILayerRegion_Requestor : public ILayerRegion
	{
	private:
	CoreLayerRegion *obj;
	public:		DFBResult ILayerRegion_Requestor__GetSurface( CoreLayerRegion *obj,
	ILayerRegion_Requestor( CoreDFB *core, CoreLayerRegion *obj )		CoreSurface **ret_surface
	:		);
	ILayerRegion( core ),
	obj( obj )
	{
	}
	public:		DFBResult ILayerRegion_Requestor__FlipUpdate( CoreLayerRegion *obj,
	virtual DFBResult FlipUpdate(
	const DFBRegion *update,		const DFBRegion *update,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags );
	);
	virtual DFBResult GetSurface(
	CoreSurface **ret_surface
	);
	};
	class CoreLayerRegionDispatch
	{
	public:
	CoreLayerRegionDispatch( CoreDFB *core, ILayerRegion *real )
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,
	int method,
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:
	CoreDFB *core;
	ILayerRegion *real;
	};
	}
	#endif		DFBResult CoreLayerRegionDispatch__Dispatch( CoreLayerRegion *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 19 change blocks.
	114 lines changed or deleted		39 lines changed or added

	CorePalette.h		CorePalette.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CorePalette__H___		#ifndef ___CorePalette__H___
	#define ___CorePalette__H___		#define ___CorePalette__H___
	#include "CorePalette_includes.h"		#include <core/CorePalette_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CorePalette		* CorePalette
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	skipping to change at line 56		skipping to change at line 56
	const DFBColor *colors,		const DFBColor *colors,
	u32 num,		u32 num,
	u32 offset);		u32 offset);
	DFBResult CorePalette_SetEntriesYUV(		DFBResult CorePalette_SetEntriesYUV(
	CorePalette *obj,		CorePalette *obj,
	const DFBColorYUV *colors,		const DFBColorYUV *colors,
	u32 num,		u32 num,
	u32 offset);		u32 offset);
	void *CorePalette_Init_Dispatch(		void CorePalette_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CorePalette *obj,		CorePalette *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CorePalette_Deinit_Dispatch(		void CorePalette_Deinit_Dispatch(
	void *dispatch		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CorePalette Calls		* CorePalette Calls
	*/		*/
	typedef enum {		typedef enum {
	CorePalette_SetEntries = 1,		_CorePalette_SetEntries = 1,
	CorePalette_SetEntriesYUV = 2,		_CorePalette_SetEntriesYUV = 2,
	} CorePaletteCall;		} CorePaletteCall;
	/*		/*
	* CorePalette_SetEntries		* CorePalette_SetEntries
	*/		*/
	typedef struct {		typedef struct {
	u32 num;		u32 num;
	u32 offset;		u32 offset;
	/* 'num' DFBColor follow (colors) */		/* 'num' DFBColor follow (colors) */
	} CorePaletteSetEntries;		} CorePaletteSetEntries;
	skipping to change at line 105		skipping to change at line 104
	typedef struct {		typedef struct {
	u32 num;		u32 num;
	u32 offset;		u32 offset;
	/* 'num' DFBColorYUV follow (colors) */		/* 'num' DFBColorYUV follow (colors) */
	} CorePaletteSetEntriesYUV;		} CorePaletteSetEntriesYUV;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CorePaletteSetEntriesYUVReturn;		} CorePaletteSetEntriesYUVReturn;
	class IPalette : public Interface		DFBResult IPalette_Real__SetEntries( CorePalette *obj,
	{
	public:
	IPalette( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult SetEntries(
	const DFBColor *colors,
	u32 num,
	u32 offset
	) = 0;
	virtual DFBResult SetEntriesYUV(
	const DFBColorYUV *colors,
	u32 num,
	u32 offset
	) = 0;
	};
	class IPalette_Real : public IPalette
	{
	private:
	CorePalette *obj;
	public:
	IPalette_Real( CoreDFB *core, CorePalette *obj )
	:
	IPalette( core ),
	obj( obj )
	{
	}
	public:
	virtual DFBResult SetEntries(
	const DFBColor *colors,		const DFBColor *colors,
	u32 num,		u32 num,
	u32 offset		u32 offset );
	);
	virtual DFBResult SetEntriesYUV(		DFBResult IPalette_Real__SetEntriesYUV( CorePalette *obj,
	const DFBColorYUV *colors,		const DFBColorYUV *colors,
	u32 num,		u32 num,
	u32 offset		u32 offset );
	);
	};
	class IPalette_Requestor : public IPalette
	{
	private:
	CorePalette *obj;
	public:
	IPalette_Requestor( CoreDFB *core, CorePalette *obj )
	:
	IPalette( core ),
	obj( obj )
	{
	}
	public:		DFBResult IPalette_Requestor__SetEntries( CorePalette *obj,
	virtual DFBResult SetEntries(
	const DFBColor *colors,		const DFBColor *colors,
	u32 num,		u32 num,
	u32 offset		u32 offset );
	);
	virtual DFBResult SetEntriesYUV(		DFBResult IPalette_Requestor__SetEntriesYUV( CorePalette *obj,
	const DFBColorYUV *colors,		const DFBColorYUV *colors,
	u32 num,		u32 num,
	u32 offset		u32 offset );
	);
	};
	class CorePaletteDispatch
	{
	public:
	CorePaletteDispatch( CoreDFB *core, IPalette *real )
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,
	int method,
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:
	CoreDFB *core;
	IPalette *real;
	};
	}
	#endif		DFBResult CorePaletteDispatch__Dispatch( CorePalette *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 14 change blocks.
	102 lines changed or deleted		22 lines changed or added

	CoreSurface.h		CoreSurface.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreSurface__H___		#ifndef ___CoreSurface__H___
	#define ___CoreSurface__H___		#define ___CoreSurface__H___
	#include "CoreSurface_includes.h"		#include <core/CoreSurface_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreSurface		* CoreSurface
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	skipping to change at line 60		skipping to change at line 60
	bool swap);		bool swap);
	DFBResult CoreSurface_GetPalette(		DFBResult CoreSurface_GetPalette(
	CoreSurface *obj,		CoreSurface *obj,
	CorePalette **ret_palette) ;		CorePalette **ret_palette) ;
	DFBResult CoreSurface_SetPalette(		DFBResult CoreSurface_SetPalette(
	CoreSurface *obj,		CoreSurface *obj,
	CorePalette *palette);		CorePalette *palette);
			DFBResult CoreSurface_SetAlphaRamp(
			CoreSurface *obj,
			u8 a0,
			u8 a1,
			u8 a2,
			u8 a3);
			DFBResult CoreSurface_SetField(
			CoreSurface *obj,
			s32 field);
	DFBResult CoreSurface_PreLockBuffer(		DFBResult CoreSurface_PreLockBuffer(
	CoreSurface *obj,		CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	CoreSurfaceAccessorID accessor,		CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,		CoreSurfaceAccessFlags access,
	u32 *ret_allocati on_index);		u32 *ret_allocati on_index);
	DFBResult CoreSurface_PreReadBuffer(		DFBResult CoreSurface_PreReadBuffer(
	CoreSurface *obj,		CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	const DFBRectangle *rect,		const DFBRectangle *rect,
	u32 *ret_allocati on_index);		u32 *ret_allocati on_index);
	DFBResult CoreSurface_PreWriteBuffer(		DFBResult CoreSurface_PreWriteBuffer(
	CoreSurface *obj,		CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	const DFBRectangle *rect,		const DFBRectangle *rect,
	u32 *ret_allocati on_index);		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		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreSurface Calls		* CoreSurface Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreSurface_SetConfig = 1,		_CoreSurface_SetConfig = 1,
	CoreSurface_Flip = 2,		_CoreSurface_Flip = 2,
	CoreSurface_GetPalette = 3,		_CoreSurface_GetPalette = 3,
	CoreSurface_SetPalette = 4,		_CoreSurface_SetPalette = 4,
	CoreSurface_PreLockBuffer = 5,		_CoreSurface_SetAlphaRamp = 5,
	CoreSurface_PreReadBuffer = 6,		_CoreSurface_SetField = 6,
	CoreSurface_PreWriteBuffer = 7,		_CoreSurface_PreLockBuffer = 7,
			_CoreSurface_PreReadBuffer = 8,
			_CoreSurface_PreWriteBuffer = 9,
	} CoreSurfaceCall;		} CoreSurfaceCall;
	/*		/*
	* CoreSurface_SetConfig		* CoreSurface_SetConfig
	*/		*/
	typedef struct {		typedef struct {
	CoreSurfaceConfig config;		CoreSurfaceConfig config;
	} CoreSurfaceSetConfig;		} CoreSurfaceSetConfig;
	typedef struct {		typedef struct {
	skipping to change at line 152		skipping to change at line 164
	*/		*/
	typedef struct {		typedef struct {
	u32 palette_id;		u32 palette_id;
	} CoreSurfaceSetPalette;		} CoreSurfaceSetPalette;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreSurfaceSetPaletteReturn;		} CoreSurfaceSetPaletteReturn;
	/*		/*
			* CoreSurface_SetAlphaRamp
			*/
			typedef struct {
			u8 a0;
			u8 a1;
			u8 a2;
			u8 a3;
			} CoreSurfaceSetAlphaRamp;
			typedef struct {
			DFBResult result;
			} CoreSurfaceSetAlphaRampReturn;
			/*
			* CoreSurface_SetField
			*/
			typedef struct {
			s32 field;
			} CoreSurfaceSetField;
			typedef struct {
			DFBResult result;
			} CoreSurfaceSetFieldReturn;
			/*
	* CoreSurface_PreLockBuffer		* CoreSurface_PreLockBuffer
	*/		*/
	typedef struct {		typedef struct {
	u32 buffer_index;		u32 buffer_index;
	CoreSurfaceAccessorID accessor;		CoreSurfaceAccessorID accessor;
	CoreSurfaceAccessFlags access;		CoreSurfaceAccessFlags access;
	} CoreSurfacePreLockBuffer;		} CoreSurfacePreLockBuffer;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	skipping to change at line 191		skipping to change at line 228
	typedef struct {		typedef struct {
	u32 buffer_index;		u32 buffer_index;
	DFBRectangle rect;		DFBRectangle rect;
	} CoreSurfacePreWriteBuffer;		} CoreSurfacePreWriteBuffer;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 allocation_index;		u32 allocation_index;
	} CoreSurfacePreWriteBufferReturn;		} CoreSurfacePreWriteBufferReturn;
	class ISurface : public Interface		DFBResult ISurface_Real__SetConfig( CoreSurface *obj,
	{		const CoreSurfaceConfig *config );
	public:
	ISurface( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult SetConfig(
	const CoreSurfaceConfig *config
	) = 0;
	virtual DFBResult Flip(
	bool swap
	) = 0;
	virtual DFBResult GetPalette(
	CorePalette **ret_palette
	) = 0;
	virtual DFBResult SetPalette(
	CorePalette *palette
	) = 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
	{
	private:
	CoreSurface *obj;
	public:		DFBResult ISurface_Real__Flip( CoreSurface *obj,
	ISurface_Real( CoreDFB *core, CoreSurface *obj )		bool swap );
	:
	ISurface( core ),
	obj( obj )
	{
	}
	public:		DFBResult ISurface_Real__GetPalette( CoreSurface *obj,
	virtual DFBResult SetConfig(		CorePalette **ret_palette
	const CoreSurfaceConfig *config		);
	);
	virtual DFBResult Flip(		DFBResult ISurface_Real__SetPalette( CoreSurface *obj,
	bool swap		CorePalette *palette );
	);
	virtual DFBResult GetPalette(		DFBResult ISurface_Real__SetAlphaRamp( CoreSurface *obj,
	CorePalette **ret_palette		u8 a0,
	);		u8 a1,
			u8 a2,
			u8 a3 );
	virtual DFBResult SetPalette(		DFBResult ISurface_Real__SetField( CoreSurface *obj,
	CorePalette *palette		s32 field );
	);
	virtual DFBResult PreLockBuffer(		DFBResult ISurface_Real__PreLockBuffer( CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	CoreSurfaceAccessorID accessor,		CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,		CoreSurfaceAccessFlags access,
	u32 *ret_allocati		u32 *ret_allocati
	on_index		on_index );
	);
	virtual DFBResult PreReadBuffer(		DFBResult ISurface_Real__PreReadBuffer( CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	const DFBRectangle *rect,		const DFBRectangle *rect,
	u32 *ret_allocati		u32 *ret_allocati
	on_index		on_index );
	);
	virtual DFBResult PreWriteBuffer(		DFBResult ISurface_Real__PreWriteBuffer( CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	const DFBRectangle *rect,		const DFBRectangle *rect,
	u32 *ret_allocati		u32 *ret_allocati
	on_index		on_index );
	);
	};
	class ISurface_Requestor : public ISurface		DFBResult ISurface_Requestor__SetConfig( CoreSurface *obj,
	{		const CoreSurfaceConfig *config );
	private:
	CoreSurface *obj;
	public:		DFBResult ISurface_Requestor__Flip( CoreSurface *obj,
	ISurface_Requestor( CoreDFB *core, CoreSurface *obj )		bool swap );
	:
	ISurface( core ),
	obj( obj )
	{
	}
	public:		DFBResult ISurface_Requestor__GetPalette( CoreSurface *obj,
	virtual DFBResult SetConfig(		CorePalette **ret_palette
	const CoreSurfaceConfig *config		);
	);
	virtual DFBResult Flip(		DFBResult ISurface_Requestor__SetPalette( CoreSurface *obj,
	bool swap		CorePalette *palette );
	);
	virtual DFBResult GetPalette(		DFBResult ISurface_Requestor__SetAlphaRamp( CoreSurface *obj,
	CorePalette **ret_palette		u8 a0,
	);		u8 a1,
			u8 a2,
			u8 a3 );
	virtual DFBResult SetPalette(		DFBResult ISurface_Requestor__SetField( CoreSurface *obj,
	CorePalette *palette		s32 field );
	);
	virtual DFBResult PreLockBuffer(		DFBResult ISurface_Requestor__PreLockBuffer( CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	CoreSurfaceAccessorID accessor,		CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,		CoreSurfaceAccessFlags access,
	u32 *ret_allocati		u32 *ret_allocati
	on_index		on_index );
	);
	virtual DFBResult PreReadBuffer(		DFBResult ISurface_Requestor__PreReadBuffer( CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	const DFBRectangle *rect,		const DFBRectangle *rect,
	u32 *ret_allocati		u32 *ret_allocati
	on_index		on_index );
	);
	virtual DFBResult PreWriteBuffer(		DFBResult ISurface_Requestor__PreWriteBuffer( CoreSurface *obj,
	u32 buffer_index ,		u32 buffer_index ,
	const DFBRectangle *rect,		const DFBRectangle *rect,
	u32 *ret_allocati		u32 *ret_allocati
	on_index		on_index );
	);
	};
	class CoreSurfaceDispatch
	{
	public:
	CoreSurfaceDispatch( CoreDFB *core, ISurface *real )
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,
	int method,
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:
	CoreDFB *core;
	ISurface *real;
	};
	}
	#endif		DFBResult CoreSurfaceDispatch__Dispatch( CoreSurface *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 32 change blocks.
	168 lines changed or deleted		107 lines changed or added

	CoreWindow.h		CoreWindow.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreWindow__H___		#ifndef ___CoreWindow__H___
	#define ___CoreWindow__H___		#define ___CoreWindow__H___
	#include "CoreWindow_includes.h"		#include <core/CoreWindow_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreWindow		* CoreWindow
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	skipping to change at line 168		skipping to change at line 168
	u32 num_keys);		u32 num_keys);
	DFBResult CoreWindow_SetRotation(		DFBResult CoreWindow_SetRotation(
	CoreWindow *obj,		CoreWindow *obj,
	int rotation);		int rotation);
	DFBResult CoreWindow_GetSurface(		DFBResult CoreWindow_GetSurface(
	CoreWindow *obj,		CoreWindow *obj,
	CoreSurface **ret_surface) ;		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		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreWindow Calls		* CoreWindow Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreWindow_Repaint = 1,		_CoreWindow_Repaint = 1,
	CoreWindow_BeginUpdates = 2,		_CoreWindow_BeginUpdates = 2,
	CoreWindow_Restack = 3,		_CoreWindow_Restack = 3,
	CoreWindow_SetConfig = 4,		_CoreWindow_SetConfig = 4,
	CoreWindow_Bind = 5,		_CoreWindow_Bind = 5,
	CoreWindow_Unbind = 6,		_CoreWindow_Unbind = 6,
	CoreWindow_RequestFocus = 7,		_CoreWindow_RequestFocus = 7,
	CoreWindow_ChangeGrab = 8,		_CoreWindow_ChangeGrab = 8,
	CoreWindow_GrabKey = 9,		_CoreWindow_GrabKey = 9,
	CoreWindow_UngrabKey = 10,		_CoreWindow_UngrabKey = 10,
	CoreWindow_Move = 11,		_CoreWindow_Move = 11,
	CoreWindow_MoveTo = 12,		_CoreWindow_MoveTo = 12,
	CoreWindow_Resize = 13,		_CoreWindow_Resize = 13,
	CoreWindow_Destroy = 14,		_CoreWindow_Destroy = 14,
	CoreWindow_SetCursorPosition = 15,		_CoreWindow_SetCursorPosition = 15,
	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,		_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 524		skipping to change at line 523
	* CoreWindow_GetSurface		* CoreWindow_GetSurface
	*/		*/
	typedef struct {		typedef struct {
	} CoreWindowGetSurface;		} CoreWindowGetSurface;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	u32 surface_id;		u32 surface_id;
	} CoreWindowGetSurfaceReturn;		} CoreWindowGetSurfaceReturn;
	class IWindow : public Interface		DFBResult IWindow_Real__Repaint( CoreWindow *obj,
	{
	public:
	IWindow( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult Repaint(
	const DFBRegion *left,
	const DFBRegion *right,
	DFBSurfaceFlipFlags flags
	) = 0;
	virtual DFBResult BeginUpdates(
	const DFBRegion *update
	) = 0;
	virtual DFBResult Restack(
	CoreWindow *relative,
	int relation
	) = 0;
	virtual DFBResult SetConfig(
	const CoreWindowConfig *config,
	const DFBInputDeviceKeySymbol *keys,
	u32 num_keys,
	CoreWindow *parent,
	CoreWindowConfigFlags flags
	) = 0;
	virtual DFBResult Bind(
	CoreWindow *source,
	int x,
	int y
	) = 0;
	virtual DFBResult Unbind(
	CoreWindow *source
	) = 0;
	virtual DFBResult RequestFocus(
	) = 0;
	virtual DFBResult ChangeGrab(
	CoreWMGrabTarget target,
	bool grab
	) = 0;
	virtual DFBResult GrabKey(
	DFBInputDeviceKeySymbol symbol,
	DFBInputDeviceModifierMask modifiers
	) = 0;
	virtual DFBResult UngrabKey(
	DFBInputDeviceKeySymbol symbol,
	DFBInputDeviceModifierMask modifiers
	) = 0;
	virtual DFBResult Move(
	int dx,
	int dy
	) = 0;
	virtual DFBResult MoveTo(
	int x,
	int y
	) = 0;
	virtual DFBResult Resize(
	int width,
	int height
	) = 0;
	virtual DFBResult Destroy(
	) = 0;
	virtual DFBResult SetCursorPosition(
	int x,
	int y
	) = 0;
	virtual DFBResult ChangeEvents(
	DFBWindowEventType disable,
	DFBWindowEventType enable
	) = 0;
	virtual DFBResult ChangeOptions(
	DFBWindowOptions disable,
	DFBWindowOptions enable
	) = 0;
	virtual DFBResult SetColor(
	const DFBColor *color
	) = 0;
	virtual DFBResult SetColorKey(
	u32 key
	) = 0;
	virtual DFBResult SetOpaque(
	const DFBRegion *opaque
	) = 0;
	virtual DFBResult SetOpacity(
	u8 opacity
	) = 0;
	virtual DFBResult SetStacking(
	DFBWindowStackingClass stacking
	) = 0;
	virtual DFBResult SetBounds(
	const DFBRectangle *bounds
	) = 0;
	virtual DFBResult SetKeySelection(
	DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,
	u32 num_keys
	) = 0;
	virtual DFBResult SetRotation(
	int rotation
	) = 0;
	virtual DFBResult GetSurface(
	CoreSurface **ret_surface
	) = 0;
	};
	class IWindow_Real : public IWindow
	{
	private:
	CoreWindow *obj;
	public:
	IWindow_Real( CoreDFB *core, CoreWindow *obj )
	:
	IWindow( core ),
	obj( obj )
	{
	}
	public:
	virtual DFBResult Repaint(
	const DFBRegion *left,		const DFBRegion *left,
	const DFBRegion *right,		const DFBRegion *right,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags );
	);
	virtual DFBResult BeginUpdates(		DFBResult IWindow_Real__BeginUpdates( CoreWindow *obj,
	const DFBRegion *update		const DFBRegion *update );
	);
	virtual DFBResult Restack(		DFBResult IWindow_Real__Restack( CoreWindow *obj,
	CoreWindow *relative,		CoreWindow *relative,
	int relation		int relation );
	);
	virtual DFBResult SetConfig(		DFBResult IWindow_Real__SetConfig( CoreWindow *obj,
	const CoreWindowConfig *config,		const CoreWindowConfig *config,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys,		u32 num_keys,
	CoreWindow *parent,		CoreWindow *parent,
	CoreWindowConfigFlags flags		CoreWindowConfigFlags flags );
	);
	virtual DFBResult Bind(		DFBResult IWindow_Real__Bind( CoreWindow *obj,
	CoreWindow *source,		CoreWindow *source,
	int x,		int x,
	int y		int y );
	);
	virtual DFBResult Unbind(
	CoreWindow *source
	);
	virtual DFBResult RequestFocus(		DFBResult IWindow_Real__Unbind( CoreWindow *obj,
			CoreWindow *source );
	);		DFBResult IWindow_Real__RequestFocus( CoreWindow *obj
			);
	virtual DFBResult ChangeGrab(		DFBResult IWindow_Real__ChangeGrab( CoreWindow *obj,
	CoreWMGrabTarget target,		CoreWMGrabTarget target,
	bool grab		bool grab );
	);
	virtual DFBResult GrabKey(		DFBResult IWindow_Real__GrabKey( CoreWindow *obj,
	DFBInputDeviceKeySymbol symbol,		DFBInputDeviceKeySymbol symbol,
	DFBInputDeviceModifierMask modifiers		DFBInputDeviceModifierMask modifiers );
	);
	virtual DFBResult UngrabKey(		DFBResult IWindow_Real__UngrabKey( CoreWindow *obj,
	DFBInputDeviceKeySymbol symbol,		DFBInputDeviceKeySymbol symbol,
	DFBInputDeviceModifierMask modifiers		DFBInputDeviceModifierMask modifiers );
	);
	virtual DFBResult Move(		DFBResult IWindow_Real__Move( CoreWindow *obj,
	int dx,		int dx,
	int dy		int dy );
	);
	virtual DFBResult MoveTo(		DFBResult IWindow_Real__MoveTo( CoreWindow *obj,
	int x,		int x,
	int y		int y );
	);
	virtual DFBResult Resize(		DFBResult IWindow_Real__Resize( CoreWindow *obj,
	int width,		int width,
	int height		int height );
	);
	virtual DFBResult Destroy(
	);		DFBResult IWindow_Real__Destroy( CoreWindow *obj
			);
	virtual DFBResult SetCursorPosition(		DFBResult IWindow_Real__SetCursorPosition( CoreWindow *obj,
	int x,		int x,
	int y		int y );
	);
	virtual DFBResult ChangeEvents(		DFBResult IWindow_Real__ChangeEvents( CoreWindow *obj,
	DFBWindowEventType disable,		DFBWindowEventType disable,
	DFBWindowEventType enable		DFBWindowEventType enable );
	);
	virtual DFBResult ChangeOptions(		DFBResult IWindow_Real__ChangeOptions( CoreWindow *obj,
	DFBWindowOptions disable,		DFBWindowOptions disable,
	DFBWindowOptions enable		DFBWindowOptions enable );
	);
	virtual DFBResult SetColor(		DFBResult IWindow_Real__SetColor( CoreWindow *obj,
	const DFBColor *color		const DFBColor *color );
	);
	virtual DFBResult SetColorKey(		DFBResult IWindow_Real__SetColorKey( CoreWindow *obj,
	u32 key		u32 key );
	);
	virtual DFBResult SetOpaque(		DFBResult IWindow_Real__SetOpaque( CoreWindow *obj,
	const DFBRegion *opaque		const DFBRegion *opaque );
	);
	virtual DFBResult SetOpacity(		DFBResult IWindow_Real__SetOpacity( CoreWindow *obj,
	u8 opacity		u8 opacity );
	);
	virtual DFBResult SetStacking(		DFBResult IWindow_Real__SetStacking( CoreWindow *obj,
	DFBWindowStackingClass stacking		DFBWindowStackingClass stacking );
	);
	virtual DFBResult SetBounds(		DFBResult IWindow_Real__SetBounds( CoreWindow *obj,
	const DFBRectangle *bounds		const DFBRectangle *bounds );
	);
	virtual DFBResult SetKeySelection(		DFBResult IWindow_Real__SetKeySelection( CoreWindow *obj,
	DFBWindowKeySelection selection,		DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys		u32 num_keys );
	);
	virtual DFBResult SetRotation(
	int rotation
	);
	virtual DFBResult GetSurface(
	CoreSurface **ret_surface
	);
	};
	class IWindow_Requestor : public IWindow		DFBResult IWindow_Real__SetRotation( CoreWindow *obj,
	{		int rotation );
	private:
	CoreWindow *obj;
	public:		DFBResult IWindow_Real__GetSurface( CoreWindow *obj,
	IWindow_Requestor( CoreDFB *core, CoreWindow *obj )		CoreSurface **ret_surface
	:		);
	IWindow( core ),
	obj( obj )
	{
	}
	public:		DFBResult IWindow_Requestor__Repaint( CoreWindow *obj,
	virtual DFBResult Repaint(
	const DFBRegion *left,		const DFBRegion *left,
	const DFBRegion *right,		const DFBRegion *right,
	DFBSurfaceFlipFlags flags		DFBSurfaceFlipFlags flags );
	);
	virtual DFBResult BeginUpdates(		DFBResult IWindow_Requestor__BeginUpdates( CoreWindow *obj,
	const DFBRegion *update		const DFBRegion *update );
	);
	virtual DFBResult Restack(		DFBResult IWindow_Requestor__Restack( CoreWindow *obj,
	CoreWindow *relative,		CoreWindow *relative,
	int relation		int relation );
	);
	virtual DFBResult SetConfig(		DFBResult IWindow_Requestor__SetConfig( CoreWindow *obj,
	const CoreWindowConfig *config,		const CoreWindowConfig *config,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys,		u32 num_keys,
	CoreWindow *parent,		CoreWindow *parent,
	CoreWindowConfigFlags flags		CoreWindowConfigFlags flags );
	);
	virtual DFBResult Bind(		DFBResult IWindow_Requestor__Bind( CoreWindow *obj,
	CoreWindow *source,		CoreWindow *source,
	int x,		int x,
	int y		int y );
	);
	virtual DFBResult Unbind(
	CoreWindow *source
	);
	virtual DFBResult RequestFocus(		DFBResult IWindow_Requestor__Unbind( CoreWindow *obj,
			CoreWindow *source );
	);		DFBResult IWindow_Requestor__RequestFocus( CoreWindow *obj
			);
	virtual DFBResult ChangeGrab(		DFBResult IWindow_Requestor__ChangeGrab( CoreWindow *obj,
	CoreWMGrabTarget target,		CoreWMGrabTarget target,
	bool grab		bool grab );
	);
	virtual DFBResult GrabKey(		DFBResult IWindow_Requestor__GrabKey( CoreWindow *obj,
	DFBInputDeviceKeySymbol symbol,		DFBInputDeviceKeySymbol symbol,
	DFBInputDeviceModifierMask modifiers		DFBInputDeviceModifierMask modifiers );
	);
	virtual DFBResult UngrabKey(		DFBResult IWindow_Requestor__UngrabKey( CoreWindow *obj,
	DFBInputDeviceKeySymbol symbol,		DFBInputDeviceKeySymbol symbol,
	DFBInputDeviceModifierMask modifiers		DFBInputDeviceModifierMask modifiers );
	);
	virtual DFBResult Move(		DFBResult IWindow_Requestor__Move( CoreWindow *obj,
	int dx,		int dx,
	int dy		int dy );
	);
	virtual DFBResult MoveTo(		DFBResult IWindow_Requestor__MoveTo( CoreWindow *obj,
	int x,		int x,
	int y		int y );
	);
	virtual DFBResult Resize(		DFBResult IWindow_Requestor__Resize( CoreWindow *obj,
	int width,		int width,
	int height		int height );
	);
	virtual DFBResult Destroy(
	);		DFBResult IWindow_Requestor__Destroy( CoreWindow *obj
			);
	virtual DFBResult SetCursorPosition(		DFBResult IWindow_Requestor__SetCursorPosition( CoreWindow *obj,
	int x,		int x,
	int y		int y );
	);
	virtual DFBResult ChangeEvents(		DFBResult IWindow_Requestor__ChangeEvents( CoreWindow *obj,
	DFBWindowEventType disable,		DFBWindowEventType disable,
	DFBWindowEventType enable		DFBWindowEventType enable );
	);
	virtual DFBResult ChangeOptions(		DFBResult IWindow_Requestor__ChangeOptions( CoreWindow *obj,
	DFBWindowOptions disable,		DFBWindowOptions disable,
	DFBWindowOptions enable		DFBWindowOptions enable );
	);
	virtual DFBResult SetColor(		DFBResult IWindow_Requestor__SetColor( CoreWindow *obj,
	const DFBColor *color		const DFBColor *color );
	);
	virtual DFBResult SetColorKey(		DFBResult IWindow_Requestor__SetColorKey( CoreWindow *obj,
	u32 key		u32 key );
	);
	virtual DFBResult SetOpaque(		DFBResult IWindow_Requestor__SetOpaque( CoreWindow *obj,
	const DFBRegion *opaque		const DFBRegion *opaque );
	);
	virtual DFBResult SetOpacity(		DFBResult IWindow_Requestor__SetOpacity( CoreWindow *obj,
	u8 opacity		u8 opacity );
	);
	virtual DFBResult SetStacking(		DFBResult IWindow_Requestor__SetStacking( CoreWindow *obj,
	DFBWindowStackingClass stacking		DFBWindowStackingClass stacking );
	);
	virtual DFBResult SetBounds(		DFBResult IWindow_Requestor__SetBounds( CoreWindow *obj,
	const DFBRectangle *bounds		const DFBRectangle *bounds );
	);
	virtual DFBResult SetKeySelection(		DFBResult IWindow_Requestor__SetKeySelection( CoreWindow *obj,
	DFBWindowKeySelection selection,		DFBWindowKeySelection selection,
	const DFBInputDeviceKeySymbol *keys,		const DFBInputDeviceKeySymbol *keys,
	u32 num_keys		u32 num_keys );
	);
	virtual DFBResult SetRotation(
	int rotation
	);
	virtual DFBResult GetSurface(
	CoreSurface **ret_surface
	);
	};
	class CoreWindowDispatch
	{
	public:
	CoreWindowDispatch( CoreDFB *core, IWindow *real )
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,
	int method,
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:		DFBResult IWindow_Requestor__SetRotation( CoreWindow *obj,
	CoreDFB *core;		int rotation );
	IWindow *real;
	};
	}		DFBResult IWindow_Requestor__GetSurface( CoreWindow *obj,
			CoreSurface **ret_surface
			);
	#endif		DFBResult CoreWindowDispatch__Dispatch( CoreWindow *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 86 change blocks.
	382 lines changed or deleted		144 lines changed or added

	CoreWindowStack.h		CoreWindowStack.h
	skipping to change at line 32		skipping to change at line 32
	You should have received a copy of the GNU Lesser General Public		You should have received a copy of the GNU Lesser General Public
	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 ___CoreWindowStack__H___		#ifndef ___CoreWindowStack__H___
	#define ___CoreWindowStack__H___		#define ___CoreWindowStack__H___
	#include "CoreWindowStack_includes.h"		#include <core/CoreWindowStack_includes.h>
	/************************************************************************** ********************************************		/************************************************************************** ********************************************
	* CoreWindowStack		* CoreWindowStack
	*/		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	#include <core/Interface.h>		#include <core/Interface.h>
	extern "C" {		extern "C" {
	#endif		#endif
	skipping to change at line 91		skipping to change at line 91
	CoreSurface *image);		CoreSurface *image);
	DFBResult CoreWindowStack_BackgroundSetColor(		DFBResult CoreWindowStack_BackgroundSetColor(
	CoreWindowStack *obj,		CoreWindowStack *obj,
	const DFBColor *color);		const DFBColor *color);
	DFBResult CoreWindowStack_BackgroundSetColorIndex(		DFBResult CoreWindowStack_BackgroundSetColorIndex(
	CoreWindowStack *obj,		CoreWindowStack *obj,
	s32 index);		s32 index);
	void *CoreWindowStack_Init_Dispatch(		void CoreWindowStack_Init_Dispatch(
	CoreDFB *core,		CoreDFB *core,
	CoreWindowStack *obj,		CoreWindowStack *obj,
	FusionCall *call		FusionCall *call
	);		);
	void CoreWindowStack_Deinit_Dispatch(		void CoreWindowStack_Deinit_Dispatch(
	void *dispatch		FusionCall *call
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
			#endif
	namespace DirectFB {
	/*		/*
	* CoreWindowStack Calls		* CoreWindowStack Calls
	*/		*/
	typedef enum {		typedef enum {
	CoreWindowStack_RepaintAll = 1,		_CoreWindowStack_RepaintAll = 1,
	CoreWindowStack_CursorEnable = 2,		_CoreWindowStack_CursorEnable = 2,
	CoreWindowStack_CursorSetShape = 3,		_CoreWindowStack_CursorSetShape = 3,
	CoreWindowStack_CursorSetOpacity = 4,		_CoreWindowStack_CursorSetOpacity = 4,
	CoreWindowStack_CursorSetAcceleration = 5,		_CoreWindowStack_CursorSetAcceleration = 5,
	CoreWindowStack_CursorWarp = 6,		_CoreWindowStack_CursorWarp = 6,
	CoreWindowStack_CursorGetPosition = 7,		_CoreWindowStack_CursorGetPosition = 7,
	CoreWindowStack_BackgroundSetMode = 8,		_CoreWindowStack_BackgroundSetMode = 8,
	CoreWindowStack_BackgroundSetImage = 9,		_CoreWindowStack_BackgroundSetImage = 9,
	CoreWindowStack_BackgroundSetColor = 10,		_CoreWindowStack_BackgroundSetColor = 10,
	CoreWindowStack_BackgroundSetColorIndex = 11,		_CoreWindowStack_BackgroundSetColorIndex = 11,
	} CoreWindowStackCall;		} CoreWindowStackCall;
	/*		/*
	* CoreWindowStack_RepaintAll		* CoreWindowStack_RepaintAll
	*/		*/
	typedef struct {		typedef struct {
	} CoreWindowStackRepaintAll;		} CoreWindowStackRepaintAll;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	skipping to change at line 246		skipping to change at line 245
	* CoreWindowStack_BackgroundSetColorIndex		* CoreWindowStack_BackgroundSetColorIndex
	*/		*/
	typedef struct {		typedef struct {
	s32 index;		s32 index;
	} CoreWindowStackBackgroundSetColorIndex;		} CoreWindowStackBackgroundSetColorIndex;
	typedef struct {		typedef struct {
	DFBResult result;		DFBResult result;
	} CoreWindowStackBackgroundSetColorIndexReturn;		} CoreWindowStackBackgroundSetColorIndexReturn;
	class IWindowStack : public Interface		DFBResult IWindowStack_Real__RepaintAll( CoreWindowStack *obj
	{		);
	public:
	IWindowStack( CoreDFB *core )
	:
	Interface( core )
	{
	}
	public:
	virtual DFBResult RepaintAll(
	) = 0;
	virtual DFBResult CursorEnable(
	bool enable
	) = 0;
	virtual DFBResult CursorSetShape(
	CoreSurface *shape,
	const DFBPoint *hotspot
	) = 0;
	virtual DFBResult CursorSetOpacity(
	u8 opacity
	) = 0;
	virtual DFBResult CursorSetAcceleration(
	u32 numerator,
	u32 denominator,
	u32 threshold
	) = 0;
	virtual DFBResult CursorWarp(
	const DFBPoint *position
	) = 0;
	virtual DFBResult CursorGetPosition(
	DFBPoint *ret_position
	) = 0;
	virtual DFBResult BackgroundSetMode(
	DFBDisplayLayerBackgroundMode mode
	) = 0;
	virtual DFBResult BackgroundSetImage(
	CoreSurface *image
	) = 0;
	virtual DFBResult BackgroundSetColor(
	const DFBColor *color
	) = 0;
	virtual DFBResult BackgroundSetColorIndex(
	s32 index
	) = 0;
	};
	class IWindowStack_Real : public IWindowStack
	{
	private:
	CoreWindowStack *obj;
	public:
	IWindowStack_Real( CoreDFB *core, CoreWindowStack *obj )
	:
	IWindowStack( core ),
	obj( obj )
	{
	}
	public:
	virtual DFBResult RepaintAll(
	);
	virtual DFBResult CursorEnable(		DFBResult IWindowStack_Real__CursorEnable( CoreWindowStack *obj,
	bool enable		bool enable );
	);
	virtual DFBResult CursorSetShape(		DFBResult IWindowStack_Real__CursorSetShape( CoreWindowStack *obj,
	CoreSurface *shape,		CoreSurface *shape,
	const DFBPoint *hotspot		const DFBPoint *hotspot );
	);
	virtual DFBResult CursorSetOpacity(		DFBResult IWindowStack_Real__CursorSetOpacity( CoreWindowStack *obj,
	u8 opacity		u8 opacity );
	);
	virtual DFBResult CursorSetAcceleration(		DFBResult IWindowStack_Real__CursorSetAcceleration( CoreWindowStack *obj,
	u32 numerator,		u32 numerator,
	u32 denominator,		u32 denominator,
	u32 threshold		u32 threshold );
	);
	virtual DFBResult CursorWarp(
	const DFBPoint *position
	);
	virtual DFBResult CursorGetPosition(
	DFBPoint *ret_position
	);
	virtual DFBResult BackgroundSetMode(
	DFBDisplayLayerBackgroundMode mode
	);
	virtual DFBResult BackgroundSetImage(
	CoreSurface *image
	);
	virtual DFBResult BackgroundSetColor(		DFBResult IWindowStack_Real__CursorWarp( CoreWindowStack *obj,
	const DFBColor *color		const DFBPoint *position );
	);
	virtual DFBResult BackgroundSetColorIndex(		DFBResult IWindowStack_Real__CursorGetPosition( CoreWindowStack *obj,
	s32 index		DFBPoint *ret_position
	);		);
	};		DFBResult IWindowStack_Real__BackgroundSetMode( CoreWindowStack *obj,
			DFBDisplayLayerBackgroundMode mode );
	class IWindowStack_Requestor : public IWindowStack		DFBResult IWindowStack_Real__BackgroundSetImage( CoreWindowStack *obj,
	{		CoreSurface *image );
	private:
	CoreWindowStack *obj;
	public:		DFBResult IWindowStack_Real__BackgroundSetColor( CoreWindowStack *obj,
	IWindowStack_Requestor( CoreDFB *core, CoreWindowStack *obj )		const DFBColor *color );
	:
	IWindowStack( core ),
	obj( obj )
	{
	}
	public:		DFBResult IWindowStack_Real__BackgroundSetColorIndex( CoreWindowStack *obj,
	virtual DFBResult RepaintAll(		s32 index );
	);		DFBResult IWindowStack_Requestor__RepaintAll( CoreWindowStack *obj
			);
	virtual DFBResult CursorEnable(		DFBResult IWindowStack_Requestor__CursorEnable( CoreWindowStack *obj,
	bool enable		bool enable );
	);
	virtual DFBResult CursorSetShape(		DFBResult IWindowStack_Requestor__CursorSetShape( CoreWindowStack *obj,
	CoreSurface *shape,		CoreSurface *shape,
	const DFBPoint *hotspot		const DFBPoint *hotspot );
	);
	virtual DFBResult CursorSetOpacity(		DFBResult IWindowStack_Requestor__CursorSetOpacity( CoreWindowStack *obj,
	u8 opacity		u8 opacity );
	);
	virtual DFBResult CursorSetAcceleration(		DFBResult IWindowStack_Requestor__CursorSetAcceleration( CoreWindowStack *o bj,
	u32 numerator,		u32 numerator,
	u32 denominator,		u32 denominator,
	u32 threshold		u32 threshold );
	);
	virtual DFBResult CursorWarp(
	const DFBPoint *position
	);
	virtual DFBResult CursorGetPosition(
	DFBPoint *ret_position
	);
	virtual DFBResult BackgroundSetMode(
	DFBDisplayLayerBackgroundMode mode
	);
	virtual DFBResult BackgroundSetImage(
	CoreSurface *image
	);
	virtual DFBResult BackgroundSetColor(
	const DFBColor *color
	);
	virtual DFBResult BackgroundSetColorIndex(
	s32 index
	);
	};		DFBResult IWindowStack_Requestor__CursorWarp( CoreWindowStack *obj,
			const DFBPoint *position );
	class CoreWindowStackDispatch		DFBResult IWindowStack_Requestor__CursorGetPosition( CoreWindowStack *obj,
	{		DFBPoint *ret_position
			);
	public:		DFBResult IWindowStack_Requestor__BackgroundSetMode( CoreWindowStack *obj,
	CoreWindowStackDispatch( CoreDFB *core, IWindowStack *real )		DFBDisplayLayerBackgroundMode mode );
	:
	core( core ),
	real( real )
	{
	}
	virtual DFBResult Dispatch( FusionID caller,		DFBResult IWindowStack_Requestor__BackgroundSetImage( CoreWindowStack *obj,
	int method,		CoreSurface *image );
	void *ptr,
	unsigned int length,
	void *ret_ptr,
	unsigned int ret_size,
	unsigned int *ret_length );
	private:		DFBResult IWindowStack_Requestor__BackgroundSetColor( CoreWindowStack *obj,
	CoreDFB *core;		const DFBColor *color );
	IWindowStack *real;
	};
	}		DFBResult IWindowStack_Requestor__BackgroundSetColorIndex( CoreWindowStack
			*obj,
			s32 index );
	#endif		DFBResult CoreWindowStackDispatch__Dispatch( CoreWindowStack *obj,
			FusionID caller,
			int method,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 32 change blocks.
	200 lines changed or deleted		70 lines changed or added

	conf.h		conf.h
	skipping to change at line 254		skipping to change at line 254
	bool software_trace;		bool software_trace;
	unsigned int max_axis_rate;		unsigned int max_axis_rate;
	bool cursor_automation;		bool cursor_automation;
	int max_font_rows;		int max_font_rows;
	int max_font_row_width;		int max_font_row_width;
	bool core_sighandler;		bool core_sighandler;
			char *resource_manager;
	} 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. 1 change blocks.
	0 lines changed or deleted		2 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"
			#include <core/surface.h>
	#define DIRECTFB_CORE_ABI 46		#define DIRECTFB_CORE_ABI 46
	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,
	skipping to change at line 83		skipping to change at line 85
	#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
	*/		*/
	CoreGraphicsState *dfb_core_create_graphics_state( CoreDFB *core );		CoreGraphicsState *dfb_core_create_graphics_state( CoreDFB *core );
	CoreLayerContext *dfb_core_create_layer_context ( CoreDFB *core );		CoreLayerContext *dfb_core_create_layer_context ( CoreDFB *core );
	CoreLayerRegion *dfb_core_create_layer_region ( CoreDFB *core );		CoreLayerRegion *dfb_core_create_layer_region ( CoreDFB *core );
	CorePalette *dfb_core_create_palette ( CoreDFB *core );		CorePalette *dfb_core_create_palette ( CoreDFB *core );
	CoreSurface *dfb_core_create_surface ( CoreDFB *core );		CoreSurface *dfb_core_create_surface ( CoreDFB *core );
			CoreSurfaceBuffer *dfb_core_create_surface_buffer( CoreDFB *core );
	CoreWindow *dfb_core_create_window ( CoreDFB *core );		CoreWindow *dfb_core_create_window ( CoreDFB *core );
	DFBResult dfb_core_get_graphics_state ( CoreDFB *core ,		DFBResult dfb_core_get_graphics_state ( CoreDFB *core ,
	u32 obje ct_id,		u32 obje ct_id,
	CoreGraphicsState **ret_ state );		CoreGraphicsState **ret_ state );
	DFBResult dfb_core_get_layer_context ( CoreDFB *core ,		DFBResult dfb_core_get_layer_context ( CoreDFB *core ,
	u32 obje ct_id,		u32 obje ct_id,
	CoreLayerContext **ret_ context );		CoreLayerContext **ret_ context );
	skipping to change at line 105		skipping to change at line 108
	CoreLayerRegion **ret_ region );		CoreLayerRegion **ret_ region );
	DFBResult dfb_core_get_palette ( CoreDFB *core ,		DFBResult dfb_core_get_palette ( CoreDFB *core ,
	u32 obje ct_id,		u32 obje ct_id,
	CorePalette **ret_ palette );		CorePalette **ret_ palette );
	DFBResult dfb_core_get_surface ( CoreDFB *core ,		DFBResult dfb_core_get_surface ( CoreDFB *core ,
	u32 obje ct_id,		u32 obje ct_id,
	CoreSurface **ret_ surface );		CoreSurface **ret_ surface );
			DFBResult dfb_core_get_surface_buffer ( CoreDFB *core
			,
			u32 obje
			ct_id,
			CoreSurfaceBuffer **ret_
			surface );
	DFBResult dfb_core_get_window ( CoreDFB *core ,		DFBResult dfb_core_get_window ( CoreDFB *core ,
	u32 obje ct_id,		u32 obje ct_id,
	CoreWindow **ret_ window );		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 );
	skipping to change at line 180		skipping to change at line 187
	bool emergency );		bool emergency );
	/*		/*
	* Removes a function from the cleanup stack.		* Removes a function from the cleanup stack.
	*/		*/
	void dfb_core_cleanup_remove( CoreDFB *core,		void dfb_core_cleanup_remove( CoreDFB *core,
	CoreCleanup *cleanup );		CoreCleanup *cleanup );
	DFBFontManager *dfb_core_font_manager( CoreDFB *core );		DFBFontManager *dfb_core_font_manager( CoreDFB *core );
			DECLARE_INTERFACE( ICoreResourceManager );
			DECLARE_INTERFACE( ICoreResourceClient );
	struct __DFB_CoreDFBShared {		struct __DFB_CoreDFBShared {
	int magic;		int magic;
	FusionSkirmish lock;		FusionSkirmish lock;
	bool active;		bool active;
	FusionObjectPool *graphics_state_pool;		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 *surface_pool;		FusionObjectPool *surface_pool;
			FusionObjectPool *surface_buffer_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 {
	int magic;		int magic;
	skipping to change at line 223		skipping to change at line 234
	DirectLink *cleanups;		DirectLink *cleanups;
	DirectThreadInitHandler *init_handler;		DirectThreadInitHandler *init_handler;
	DirectSignalHandler *signal_handler;		DirectSignalHandler *signal_handler;
	DirectCleanupHandler *cleanup_handler;		DirectCleanupHandler *cleanup_handler;
	DFBFontManager *font_manager;		DFBFontManager *font_manager;
			struct {
			ICoreResourceManager *manager;
			DirectHash *clients;
			} resource;
	};		};
	extern CoreDFB *core_dfb; // FIXME		extern CoreDFB *core_dfb; // FIXME
			void Core_TLS__init( void );
			void Core_TLS__deinit( void );
			/*
			* Identity management
			*
			* Incoming dispatch pushes ID of caller
			*/
			void Core_PushIdentity( FusionID caller );
			void Core_PopIdentity ( void );
			FusionID Core_GetIdentity ( void );
			/*
			* Resource management
			*
			* Quotas etc can be implemented.
			*
			* Run time option 'resource-manager' is needed.
			*/
			DFBResult Core_Resource_CheckSurface ( const CoreSurfaceConfig *confi
			g,
			CoreSurfaceTypeFlags type,
			u64 resou
			rce_id,
			CorePalette *palet
			te );
			DFBResult Core_Resource_CheckSurfaceUpdate( CoreSurface *surfa
			ce,
			const CoreSurfaceConfig *confi
			g );
			DFBResult Core_Resource_AddSurface ( CoreSurface *surfa
			ce );
			DFBResult Core_Resource_RemoveSurface ( CoreSurface *surfa
			ce );
			DFBResult Core_Resource_UpdateSurface ( CoreSurface *surfa
			ce,
			const CoreSurfaceConfig *confi
			g );
			/*
			* Resource manager main interface
			*
			* Implementation can be loaded via 'resource-manager' option.
			*/
			DEFINE_INTERFACE( ICoreResourceManager,
			DFBResult (*CreateClient) ( ICoreResourceManager *thiz,
			FusionID identity,
			ICoreResourceClient **ret_client
			);
			);
			/*
			* Per slave resource accounting
			*/
			DEFINE_INTERFACE( ICoreResourceClient,
			DFBResult (*CheckSurface) ( ICoreResourceClient *thiz,
			const CoreSurfaceConfig *config,
			CoreSurfaceTypeFlags type,
			u64 resource_i
			d,
			CorePalette *palette );
			DFBResult (*CheckSurfaceUpdate) ( ICoreResourceClient *thiz,
			CoreSurface *surface,
			const CoreSurfaceConfig *config );
			DFBResult (*AddSurface) ( ICoreResourceClient *thiz,
			CoreSurface *surface );
			DFBResult (*RemoveSurface) ( ICoreResourceClient *thiz,
			CoreSurface *surface );
			DFBResult (*UpdateSurface) ( ICoreResourceClient *thiz,
			CoreSurface *surface,
			const CoreSurfaceConfig *config );
			);
			/*
			* Client instance management
			*/
			ICoreResourceClient *Core_Resource_GetClient ( FusionID identity );
			DFBResult Core_Resource_AddClient ( FusionID identity );
			void Core_Resource_DisposeClient( FusionID identity );
	#endif		#endif
End of changes. 7 change blocks.
	0 lines changed or deleted		116 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 (4)		#define DIRECTFB_MINOR_VERSION (4)
	#define DIRECTFB_MICRO_VERSION (14)		#define DIRECTFB_MICRO_VERSION (15)
	#define DIRECTFB_BINARY_AGE (9)		#define DIRECTFB_BINARY_AGE (9)
	#define DIRECTFB_INTERFACE_AGE (9)		#define DIRECTFB_INTERFACE_AGE (9)
	#endif /* __DIRECTFB_VERSION_H__ */		#endif /* __DIRECTFB_VERSION_H__ */
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	fusion.h		fusion.h
	skipping to change at line 55		skipping to change at line 55
	} FusionForkAction;		} FusionForkAction;
	typedef enum {		typedef enum {
	FFS_PREPARE,		FFS_PREPARE,
	FFS_PARENT,		FFS_PARENT,
	FFS_CHILD		FFS_CHILD
	} FusionForkState;		} FusionForkState;
	typedef void (*FusionForkCallback) ( FusionForkAction action, FusionForkSta te state );		typedef void (*FusionForkCallback) ( FusionForkAction action, FusionForkSta te state );
			typedef void (*FusionLeaveCallback)( FusionWorld *world,
			FusionID fusion_id,
			void *ctx );
	/*		/*
	* Enters a fusion world by joining or creating it.		* Enters a fusion world by joining or creating it.
	*		*
	* If <b>world_index</b> is negative, the next free index is used to create a new world.		* If <b>world_index</b> is negative, the next free index is used to create a new world.
	* Otherwise the world with the specified index is joined or created.		* Otherwise the world with the specified index is joined or created.
	*/		*/
	DirectResult fusion_enter( int world_index,		DirectResult fusion_enter( int world_index,
	int abi_version,		int abi_version,
	FusionEnterRole role,		FusionEnterRole role,
	FusionWorld **ret_world );		FusionWorld **ret_world );
	skipping to change at line 95		skipping to change at line 99
	*/		*/
	FusionForkAction fusion_world_get_fork_action( FusionWorld *world );		FusionForkAction fusion_world_get_fork_action( FusionWorld *world );
	/*		/*
	* Registers a callback called upon fork().		* Registers a callback called upon fork().
	*/		*/
	void fusion_world_set_fork_callback( FusionWorld *world,		void fusion_world_set_fork_callback( FusionWorld *world,
	FusionForkCallback callback );		FusionForkCallback callback );
	/*		/*
			* Registers a callback called when a slave exits.
			*/
			void fusion_world_set_leave_callback( FusionWorld *world,
			FusionLeaveCallback callback,
			void *ctx );
			/*
	* Return the index of the specified world.		* Return the index of the specified world.
	*/		*/
	int fusion_world_index( const FusionWorld *world );		int fusion_world_index( const FusionWorld *world );
	/*		/*
	* Return the own Fusion ID within the specified world.		* Return the own Fusion ID within the specified world.
	*/		*/
	FusionID fusion_id( const FusionWorld *world );		FusionID fusion_id( const FusionWorld *world );
	/*		/*
	skipping to change at line 143		skipping to change at line 154
	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_is_shared( FusionWorld *world,		bool fusion_is_shared( FusionWorld *world,
	const void *ptr );		const void *ptr );
	const char *fusion_get_tmpfs( FusionWorld *world );		const char *fusion_get_tmpfs( FusionWorld *world );
			/*
			* Get the executable path of the Fusionee
			*
			* Returns DR_LIMITEXCEEDED when buf_size too small,
			* with the required number of bytes returned in ret_size.
			*/
			DirectResult fusion_get_fusionee_path( const FusionWorld *world,
			FusionID fusion_id,
			char *buf,
			size_t buf_size,
			size_t *ret_size );
	#endif		#endif
End of changes. 3 change blocks.
	0 lines changed or deleted		23 lines changed or added

	fusion_internal.h		fusion_internal.h
	skipping to change at line 119		skipping to change at line 119
	*/		*/
	DirectLink *reactor_nodes;		DirectLink *reactor_nodes;
	pthread_mutex_t reactor_nodes_lock;		pthread_mutex_t reactor_nodes_lock;
	FusionSHM shm;		FusionSHM shm;
	FusionForkAction fork_action;		FusionForkAction fork_action;
	FusionForkCallback fork_callback;		FusionForkCallback fork_callback;
	void *fusionee;		void *fusionee;
			FusionLeaveCallback leave_callback;
			void *leave_ctx;
	};		};
	/*******************************************		/*******************************************
	* Fusion internal function declarations *		* Fusion internal function declarations *
	*******************************************/		*******************************************/
	int _fusion_fd( const FusionWorldShared *shared );		int _fusion_fd( const FusionWorldShared *shared );
	FusionID _fusion_id( const FusionWorldShared *shared );		FusionID _fusion_id( const FusionWorldShared *shared );
	FusionWorld *_fusion_world( const FusionWorldShared *shared );		FusionWorld *_fusion_world( const FusionWorldShared *shared );
End of changes. 1 change blocks.
	0 lines changed or deleted		3 lines changed or added

	input.h		input.h
	skipping to change at line 162		skipping to change at line 162
	DFBInputDeviceID dfb_input_device_id ( const CoreInputDevice * device );		DFBInputDeviceID dfb_input_device_id ( const CoreInputDevice * device );
	CoreInputDevice *dfb_input_device_at ( DFBInputDeviceID id );		CoreInputDevice *dfb_input_device_at ( DFBInputDeviceID id );
	DFBInputDeviceCapabilities dfb_input_device_caps( const CoreInputDevice *de vice );		DFBInputDeviceCapabilities dfb_input_device_caps( const CoreInputDevice *de vice );
	DFBResult dfb_input_device_get_keymap_entry( CoreInputDevice *device,		DFBResult dfb_input_device_get_keymap_entry( CoreInputDevice *device,
	int keycode,		int keycode,
	DFBInputDeviceKeymapEn try *entry );		DFBInputDeviceKeymapEn try *entry );
	DFBResult dfb_input_device_set_keymap_entry( CoreInputDevice		DFBResult dfb_input_device_set_keymap_entry( CoreInputDevice
	*device,		*device,
	int		int
	keycode,		keycode,
	DFBInputDeviceKeymapEn		const DFBInputDeviceKe
	try *entry );		ymapEntry *entry );
	DFBResult dfb_input_device_load_keymap ( CoreInputDevice *device,		DFBResult dfb_input_device_load_keymap ( CoreInputDevice *device,
	char *filename );		char *filename );
	DFBResult dfb_input_device_reload_keymap ( CoreInputDevice *device );		DFBResult dfb_input_device_reload_keymap ( CoreInputDevice *device );
	void containers_attach_device( CoreInputDevice *device );		void containers_attach_device( CoreInputDevice *device );
	void containers_detach_device( CoreInputDevice *device );		void containers_detach_device( CoreInputDevice *device );
	skipping to change at line 192		skipping to change at line 192
	DFBResult dfb_input_remove_device( int device_index,		DFBResult dfb_input_remove_device( int device_index,
	void *driver_in );		void *driver_in );
	/* global reactions */		/* global reactions */
	typedef enum {		typedef enum {
	DFB_WINDOWSTACK_INPUTDEVICE_LISTENER		DFB_WINDOWSTACK_INPUTDEVICE_LISTENER
	} DFB_INPUT_GLOBALS;		} DFB_INPUT_GLOBALS;
			DirectResult CoreInputDevice_Call( CoreInputDevice *device,
			FusionCallExecFlags flags,
			int call_arg,
			void *ptr,
			unsigned int length,
			void *ret_ptr,
			unsigned int ret_size,
			unsigned int *ret_length );
	#endif		#endif
End of changes. 2 change blocks.
	6 lines changed or deleted		15 lines changed or added

	layer_context.h		layer_context.h
	skipping to change at line 146		skipping to change at line 146
	* window control		* window control
	*/		*/
	DFBResult dfb_layer_context_create_window( CoreDFB *cor e,		DFBResult dfb_layer_context_create_window( CoreDFB *cor e,
	CoreLayerContext *con text,		CoreLayerContext *con text,
	const DFBWindowDescription *des c,		const DFBWindowDescription *des c,
	CoreWindow **ret _window );		CoreWindow **ret _window );
	CoreWindow *dfb_layer_context_find_window( CoreLayerContext *con text,		CoreWindow *dfb_layer_context_find_window( CoreLayerContext *con text,
	DFBWindowID id );		DFBWindowID id );
			DFBResult dfb_layer_context_allocate_surface ( CoreLayer
			*layer,
			CoreLayerRegion
			*region,
			CoreLayerRegionConfig
			*config );
			DFBResult dfb_layer_context_reallocate_surface ( CoreLayer
			*layer,
			CoreLayerRegion
			*region,
			CoreLayerRegionConfig
			*config );
			DFBResult dfb_layer_context_deallocate_surface ( CoreLayer
			*layer,
			CoreLayerRegion
			*region );
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		19 lines changed or added

	layers_internal.h		layers_internal.h
	skipping to change at line 79		skipping to change at line 79
	CoreLayerContexts contexts;		CoreLayerContexts contexts;
	bool suspended;		bool suspended;
	FusionVector added_regions;		FusionVector added_regions;
	FusionSHMPoolShared *shmpool;		FusionSHMPoolShared *shmpool;
	FusionCall call;		FusionCall call;
			DFBSurfacePixelFormat pixelformat;
	} CoreLayerShared;		} CoreLayerShared;
	struct __DFB_CoreLayer {		struct __DFB_CoreLayer {
	CoreLayerShared *shared;		CoreLayerShared *shared;
	CoreDFB *core;		CoreDFB *core;
	CoreGraphicsDevice *device;		CoreGraphicsDevice *device;
	CoreScreen *screen;		CoreScreen *screen;
End of changes. 1 change blocks.
	0 lines changed or deleted		2 lines changed or added

	object.h		object.h
	skipping to change at line 59		skipping to change at line 59
	FOS_DEINIT		FOS_DEINIT
	} FusionObjectState;		} FusionObjectState;
	struct __Fusion_FusionObject {		struct __Fusion_FusionObject {
	DirectLink link;		DirectLink link;
	FusionObjectPool *pool;		FusionObjectPool *pool;
	int magic;		int magic;
	FusionObjectID id;		FusionObjectID id;
			FusionID identity;
	FusionObjectState state;		FusionObjectState state;
	FusionRef ref;		FusionRef ref;
	FusionReactor *reactor;		FusionReactor *reactor;
	FusionWorldShared *shared;		FusionWorldShared *shared;
	FusionHash *properties;		FusionHash *properties;
	FusionID owner;		FusionID owner;
	skipping to change at line 90		skipping to change at line 91
	const FusionWorld *world );		const FusionWorld *world );
	DirectResult fusion_object_pool_destroy( FusionObjectPool *pool,		DirectResult fusion_object_pool_destroy( FusionObjectPool *pool,
	const FusionWorld *world );		const FusionWorld *world );
	DirectResult fusion_object_pool_enum ( FusionObjectPool *pool,		DirectResult fusion_object_pool_enum ( FusionObjectPool *pool,
	FusionObjectCallback callb ack,		FusionObjectCallback callb ack,
	void *ctx ) ;		void *ctx ) ;
	FusionObject *fusion_object_create ( FusionObjectPool *pool,		FusionObject *fusion_object_create ( FusionObjectPool *pool,
	const FusionWorld *world );		const FusionWorld *world,
			FusionID identity );
	DirectResult fusion_object_get ( FusionObjectPool *pool,		DirectResult fusion_object_get ( FusionObjectPool *pool,
	FusionObjectID object_id,		FusionObjectID object_id,
	FusionObject **ret_object );		FusionObject **ret_object );
	DirectResult fusion_object_set_lock( FusionObject *object,		DirectResult fusion_object_set_lock( FusionObject *object,
	FusionSkirmish *lock );		FusionSkirmish *lock );
	DirectResult fusion_object_activate( FusionObject *object );		DirectResult fusion_object_activate( FusionObject *object );
End of changes. 2 change blocks.
	1 lines changed or deleted		3 lines changed or added

	screens.h		screens.h
	skipping to change at line 263		skipping to change at line 263
	void *driver_data,		void *driver_data,
	ScreenFuncs *funcs );		ScreenFuncs *funcs );
	/*		/*
	* Enumerate all registered screens by invoking the callback for each scree n.		* Enumerate all registered screens by invoking the callback for each scree n.
	*/		*/
	void dfb_screens_enumerate( CoreScreenCallback callback,		void dfb_screens_enumerate( CoreScreenCallback callback,
	void *ctx );		void *ctx );
	/*		/*
			* Returns the number of screens.
			*/
			unsigned int dfb_screens_num( void );
			/*
	* Returns the screen with the specified ID.		* Returns the screen with the specified ID.
	*/		*/
	CoreScreen *dfb_screens_at( DFBScreenID screen_id );		CoreScreen *dfb_screens_at( DFBScreenID screen_id );
	CoreScreen *dfb_screens_at_translated( DFBScreenID screen_id );		CoreScreen *dfb_screens_at_translated( DFBScreenID screen_id );
	/*		/*
			* Return the ID of the specified screen.
			*/
			DFBScreenID dfb_screen_id( const CoreScreen *screen );
			/*
	* Return the (translated) ID of the specified screen.		* Return the (translated) ID of the specified screen.
	*/		*/
	DFBScreenID dfb_screen_id_translated( CoreScreen *screen );		DFBScreenID dfb_screen_id_translated( const CoreScreen *screen );
	#endif		#endif
End of changes. 3 change blocks.
	1 lines changed or deleted		11 lines changed or added

	screens_internal.h		screens_internal.h
	skipping to change at line 66		skipping to change at line 66
	DFBScreenID screen_id;		DFBScreenID screen_id;
	DFBScreenDescription description;		DFBScreenDescription description;
	CoreScreenMixer *mixers;		CoreScreenMixer *mixers;
	CoreScreenEncoder *encoders;		CoreScreenEncoder *encoders;
	CoreScreenOutput *outputs;		CoreScreenOutput *outputs;
	void *screen_data;		void *screen_data;
			FusionCall call;
	} CoreScreenShared;		} CoreScreenShared;
	struct __DFB_CoreScreen {		struct __DFB_CoreScreen {
	CoreScreenShared *shared;		CoreScreenShared *shared;
	CoreDFB *core;		CoreDFB *core;
	CoreGraphicsDevice *device;		CoreGraphicsDevice *device;
	ScreenFuncs *funcs;		ScreenFuncs *funcs;
End of changes. 1 change blocks.
	0 lines changed or deleted		2 lines changed or added

	surface_buffer.h		surface_buffer.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 __CORE__SURFACE_BUFFER_H__		#ifndef __CORE__SURFACE_BUFFER_H__
	#define __CORE__SURFACE_BUFFER_H__		#define __CORE__SURFACE_BUFFER_H__
	#include <direct/debug.h>		#include <direct/debug.h>
			#include <fusion/object.h>
	#include <fusion/vector.h>		#include <fusion/vector.h>
	#include <core/surface.h>		#include <core/surface.h>
	#include <directfb.h>		#include <directfb.h>
	/*		/*
	* Configuration and State flags of a Surface Buffer		* Configuration and State flags of a Surface Buffer
	*/		*/
	typedef enum {		typedef enum {
	skipping to change at line 67		skipping to change at line 68
	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_MUCKOUT = 0x00001000, /* Indicates surface pool being in the progress of mucking out this and possibly		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. */		other allocations to have enough space for a new allocation to be made. */
	CSALF_ALL = 0x00001007 /* All of these. */		CSALF_ALL = 0x00001007 /* All of these. */
	} CoreSurfaceAllocationFlags;		} CoreSurfaceAllocationFlags;
			typedef enum {
			CSBNF_NONE = 0x00000000
			} CoreSurfaceBufferNotificationFlags;
			typedef struct {
			CoreSurfaceBufferNotificationFlags flags;
			} CoreSurfaceBufferNotification;
	/*		/*
	* 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. */
	CoreSurfaceBuffer *buffer; /* Surface Buffer owning this allocation. */		CoreSurfaceBuffer *buffer; /* Surface Buffer owning this allocation. */
	CoreSurface *surface; /* Surface owning the Buf fer of this allocation. */		CoreSurface *surface; /* Surface owning the Buf fer of this allocation. */
	skipping to change at line 182		skipping to change at line 191
	D_ASSERT( (lock)->offset == ~0 ); \		D_ASSERT( (lock)->offset == ~0 ); \
	D_ASSERT( (lock)->pitch == 0 ); \		D_ASSERT( (lock)->pitch == 0 ); \
	D_ASSERT( (lock)->handle == NULL ); \		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 {
			FusionObject object;
	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. */
	CoreSurfaceAllocation *read; /* Allocation with the last re ad access. */		CoreSurfaceAllocation *read; /* Allocation with the last re ad access. */
	CoreSurface *surface; /* Surface owning this Surface Buffer. */		CoreSurface *surface; /* Surface owning this Surface Buffer. */
	CoreSurfacePolicy policy;		CoreSurfacePolicy policy;
	CoreSurfaceBufferFlags flags; /* Configuration and State fla gs. */		CoreSurfaceBufferFlags flags; /* Configuration and State fla gs. */
	DFBSurfacePixelFormat format; /* Pixel format of buffer data . */		DFBSurfacePixelFormat format; /* Pixel format of buffer data . */
	FusionVector allocs; /* Allocations within Surface Pools. */		FusionVector allocs; /* Allocations within Surface Pools. */
	#if 1		CoreSurfaceConfig config; /* Configuration of its surfac
	unsigned int locked; /* Lock count. FIXME: Add fail		e at the time of the buffer creation */
	safe cleanup! */		CoreSurfaceTypeFlags type;
	#endif		unsigned long resource_id; /* layer id, window id, or use
			r specified */
	};		};
	DFBResult dfb_surface_buffer_new ( CoreSurface *surface,		DFBResult dfb_surface_buffer_create ( CoreDFB *core,
			CoreSurface *surface,
	CoreSurfaceBufferFlags flags,		CoreSurfaceBufferFlags flags,
	CoreSurfaceBuffer **ret_buffer ) ;		CoreSurfaceBuffer **ret_buffer ) ;
	DFBResult dfb_surface_buffer_destroy( CoreSurfaceBuffer *buffer );		DFBResult dfb_surface_buffer_decouple( CoreSurfaceBuffer *buffer );
	DFBResult dfb_surface_buffer_lock ( CoreSurfaceBuffer *buffer,		DFBResult dfb_surface_buffer_lock ( CoreSurfaceBuffer *buffer,
	CoreSurfaceAccessorID accessor,		CoreSurfaceAccessorID accessor,
	CoreSurfaceAccessFlags access,		CoreSurfaceAccessFlags access,
	CoreSurfaceBufferLock *ret_lock );		CoreSurfaceBufferLock *ret_lock );
	DFBResult dfb_surface_buffer_unlock ( CoreSurfaceBufferLock *lock );		DFBResult dfb_surface_buffer_unlock ( CoreSurfaceBufferLock *lock );
	DFBResult dfb_surface_buffer_read ( CoreSurfaceBuffer *buffer,		DFBResult dfb_surface_buffer_read ( CoreSurfaceBuffer *buffer,
	void *destination,		void *destination,
	skipping to change at line 255		skipping to change at line 267
	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;
	}		}
			static inline int
			dfb_surface_buffer_locks( CoreSurfaceBuffer *buffer )
			{
			int refs;
			fusion_ref_stat( &buffer->object.ref, &refs );
			D_ASSERT( refs > 0 );
			return refs - 1;
			}
	DFBResult dfb_surface_allocation_update( CoreSurfaceAllocation *allocation ,		DFBResult dfb_surface_allocation_update( CoreSurfaceAllocation *allocation ,
	CoreSurfaceAccessFlags access );		CoreSurfaceAccessFlags access );
			FUSION_OBJECT_METHODS( CoreSurfaceBuffer, dfb_surface_buffer );
			FusionObjectPool *dfb_surface_buffer_pool_create( const FusionWorld *world
			);
	#endif		#endif
End of changes. 8 change blocks.
	6 lines changed or deleted		36 lines changed or added

	surface_pool.h		surface_pool.h
	skipping to change at line 169		skipping to change at line 169
	int pitch,		int pitch,
	const DFBRectangle *rect );		const DFBRectangle *rect );
	/*		/*
	* Muck out		* Muck out
	*/		*/
	DFBResult (*MuckOut) ( CoreSurfacePool *pool,		DFBResult (*MuckOut) ( CoreSurfacePool *pool,
	void *pool_data,		void *pool_data,
	void *pool_local,		void *pool_local,
	CoreSurfaceBuffer *buffer );		CoreSurfaceBuffer *buffer );
			/*
			* Manage interlocks
			*/
			DFBResult (*PreLock) ( CoreSurfacePool *pool,
			void *pool_data,
			void *pool_local,
			CoreSurfaceAllocation *allocation,
			void *alloc_data,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags access );
	} 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;
	skipping to change at line 237		skipping to change at line 248
	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,		DFBResult dfb_surface_pool_displace ( CoreSurfacePool *pool,
	CoreSurfaceBuffer *buffer,		CoreSurfaceBuffer *buffer,
	CoreSurfaceAllocation **ret_allocat ion );		CoreSurfaceAllocation **ret_allocat ion );
			DFBResult dfb_surface_pool_prelock ( CoreSurfacePool *pool,
			CoreSurfaceAllocation *allocation,
			CoreSurfaceAccessorID accessor,
			CoreSurfaceAccessFlags access );
	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_read ( CoreSurfacePool *pool,		DFBResult dfb_surface_pool_read ( CoreSurfacePool *pool,
	CoreSurfaceAllocation *allocation,		CoreSurfaceAllocation *allocation,
End of changes. 2 change blocks.
	0 lines changed or deleted		16 lines changed or added

	vector.h		vector.h
	skipping to change at line 158		skipping to change at line 158
	return INT_MIN >> 2;		return INT_MIN >> 2;
	}		}
	#define fusion_vector_foreach(element, index, vector) \		#define fusion_vector_foreach(element, index, vector) \
	for ((index) = 0; \		for ((index) = 0; \
	(index) < (vector).count && (element = (vector).elements[index]); \		(index) < (vector).count && (element = (vector).elements[index]); \
	(index)++)		(index)++)
	#define fusion_vector_foreach_reverse(element, index, vector) \		#define fusion_vector_foreach_reverse(element, index, vector) \
	for ((index) = (vector).count - 1; \		for ((index) = (vector).count - 1; \
	(index) >= 0 && (element = (vector).elements[index]);		(index) >= 0 && (vector).count &&
	\		\
			(vector).elements &&
			\
			(element = (vector).elements[index]);
			\
	(index)--)		(index)--)
	#endif		#endif
End of changes. 1 change blocks.
	2 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/