CoreDFB.h   CoreDFB.h 
skipping to change at line 45 skipping to change at line 45
* CoreDFB * CoreDFB
*/ */
#ifdef __cplusplus #ifdef __cplusplus
#include <core/Interface.h> #include <core/Interface.h>
extern "C" { extern "C" {
#endif #endif
DFBResult CoreDFB_Register( DFBResult CoreDFB_Register(
CoreDFB *obj CoreDFB *obj,
); u32 slave_call);
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(
skipping to change at line 69 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
); );
DFBResult CoreDFB_CreateImageProvider(
CoreDFB *obj,
u32 buffer_call,
u32 *ret_call);
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(
FusionCall *call FusionCall *call
); );
skipping to change at line 92 skipping to change at line 97
/* /*
* CoreDFB Calls * CoreDFB Calls
*/ */
typedef enum { typedef enum {
_CoreDFB_Register = 1, _CoreDFB_Register = 1,
_CoreDFB_CreateSurface = 2, _CoreDFB_CreateSurface = 2,
_CoreDFB_CreatePalette = 3, _CoreDFB_CreatePalette = 3,
_CoreDFB_CreateState = 4, _CoreDFB_CreateState = 4,
_CoreDFB_WaitIdle = 5, _CoreDFB_WaitIdle = 5,
_CoreDFB_CreateImageProvider = 6,
} CoreDFBCall; } CoreDFBCall;
/* /*
* CoreDFB_Register * CoreDFB_Register
*/ */
typedef struct { typedef struct {
u32 slave_call;
} CoreDFBRegister; } CoreDFBRegister;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
} CoreDFBRegisterReturn; } CoreDFBRegisterReturn;
/* /*
* CoreDFB_CreateSurface * CoreDFB_CreateSurface
*/ */
typedef struct { typedef struct {
skipping to change at line 153 skipping to change at line 160
/* /*
* CoreDFB_WaitIdle * CoreDFB_WaitIdle
*/ */
typedef struct { typedef struct {
} CoreDFBWaitIdle; } CoreDFBWaitIdle;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
} CoreDFBWaitIdleReturn; } CoreDFBWaitIdleReturn;
DFBResult ICore_Real__Register( CoreDFB *obj /*
); * CoreDFB_CreateImageProvider
*/
typedef struct {
u32 buffer_call;
} CoreDFBCreateImageProvider;
typedef struct {
DFBResult result;
u32 call;
} CoreDFBCreateImageProviderReturn;
DFBResult ICore_Real__Register( CoreDFB *obj,
u32 slave_call )
;
DFBResult ICore_Real__CreateSurface( CoreDFB *obj, DFBResult ICore_Real__CreateSurface( 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 ICore_Real__CreatePalette( CoreDFB *obj, DFBResult ICore_Real__CreatePalette( CoreDFB *obj,
u32 size, u32 size,
CorePalette **ret_palette ); CorePalette **ret_palette );
DFBResult ICore_Real__CreateState( CoreDFB *obj, DFBResult ICore_Real__CreateState( CoreDFB *obj,
CoreGraphicsState **ret_state ); CoreGraphicsState **ret_state );
DFBResult ICore_Real__WaitIdle( CoreDFB *obj DFBResult ICore_Real__WaitIdle( CoreDFB *obj
); );
DFBResult ICore_Requestor__Register( CoreDFB *obj DFBResult ICore_Real__CreateImageProvider( CoreDFB *obj,
); u32 buffer_call,
u32 *ret_call );
DFBResult ICore_Requestor__Register( CoreDFB *obj,
u32 slave_call )
;
DFBResult ICore_Requestor__CreateSurface( CoreDFB *obj, DFBResult ICore_Requestor__CreateSurface( 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 ICore_Requestor__CreatePalette( CoreDFB *obj, DFBResult ICore_Requestor__CreatePalette( CoreDFB *obj,
u32 size, u32 size,
CorePalette **ret_palette ); CorePalette **ret_palette );
DFBResult ICore_Requestor__CreateState( CoreDFB *obj, DFBResult ICore_Requestor__CreateState( CoreDFB *obj,
CoreGraphicsState **ret_state ); CoreGraphicsState **ret_state );
DFBResult ICore_Requestor__WaitIdle( CoreDFB *obj DFBResult ICore_Requestor__WaitIdle( CoreDFB *obj
); );
DFBResult ICore_Requestor__CreateImageProvider( CoreDFB *obj,
u32 buffer_call,
u32 *ret_call );
DFBResult CoreDFBDispatch__Dispatch( CoreDFB *obj, DFBResult CoreDFBDispatch__Dispatch( CoreDFB *obj,
FusionID caller, FusionID caller,
int method, int method,
void *ptr, void *ptr,
unsigned int length, unsigned int length,
void *ret_ptr, void *ret_ptr,
unsigned int ret_size, unsigned int ret_size,
unsigned int *ret_length ); unsigned int *ret_length );
#endif #endif
 End of changes. 7 change blocks. 
6 lines changed or deleted 35 lines changed or added


 CoreDFB_includes.h   CoreDFB_includes.h 
/*
(c) Copyright 2001-2012 The world wide DirectFB Open Source Community (
directfb.org)
(c) Copyright 2000-2004 Convergence (integrated media) GmbH
All rights reserved.
Written by Denis Oliver Kropp <dok@directfb.org>,
Andreas Hundt <andi@fischlustig.de>,
Sven Neumann <neo@directfb.org>,
Ville Syrjälä <syrjala@sci.fi> and
Claudio Ciccani <klan@users.sf.net>.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#ifndef __CoreDFB_includes_h__ #ifndef __CoreDFB_includes_h__
#define __CoreDFB_includes_h__ #define __CoreDFB_includes_h__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <fusion/types.h> #include <fusion/types.h>
#include <fusion/lock.h> #include <fusion/lock.h>
#include <fusion/object.h> #include <fusion/object.h>
skipping to change at line 121 skipping to change at line 149
{ {
return dfb_layer_id( layer ); return dfb_layer_id( layer );
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreLayer_Lookup( CoreDFB *core, CoreLayer_Lookup( CoreDFB *core,
u32 object_id, u32 object_id,
FusionID caller, FusionID caller,
CoreLayer **ret_layer ) CoreLayer **ret_layer )
{ {
D_UNUSED_P( core );
D_UNUSED_P( caller );
if (object_id >= (u32) dfb_layer_num()) if (object_id >= (u32) dfb_layer_num())
return DR_IDNOTFOUND; return DR_IDNOTFOUND;
*ret_layer = dfb_layer_at( object_id ); *ret_layer = dfb_layer_at( object_id );
return DR_OK; return DR_OK;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreLayer_Unref( CoreLayer *layer ) CoreLayer_Unref( CoreLayer *layer )
{ {
D_UNUSED_P( layer );
return DR_OK; return DR_OK;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreLayer_Catch( CoreDFB *core, CoreLayer_Catch( CoreDFB *core,
u32 object_id, u32 object_id,
CoreLayer **ret_layer ) CoreLayer **ret_layer )
{ {
D_UNUSED_P( core );
if (object_id >= (u32) dfb_layer_num()) if (object_id >= (u32) dfb_layer_num())
return DR_IDNOTFOUND; return DR_IDNOTFOUND;
*ret_layer = dfb_layer_at( object_id ); *ret_layer = dfb_layer_at( object_id );
return DR_OK; return DR_OK;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreLayer_Throw( CoreLayer *layer, CoreLayer_Throw( CoreLayer *layer,
FusionID catcher, FusionID catcher,
u32 *ret_object_id ) u32 *ret_object_id )
{ {
D_UNUSED_P( catcher );
*ret_object_id = layer->shared->layer_id; *ret_object_id = layer->shared->layer_id;
return DR_OK; return DR_OK;
} }
static __inline__ u32 static __inline__ u32
CoreLayerContext_GetID( const CoreLayerContext *context ) CoreLayerContext_GetID( const CoreLayerContext *context )
{ {
return context->object.id; return context->object.id;
} }
skipping to change at line 377 skipping to change at line 415
{ {
return dfb_screen_id( screen ); return dfb_screen_id( screen );
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreScreen_Lookup( CoreDFB *core, CoreScreen_Lookup( CoreDFB *core,
u32 object_id, u32 object_id,
FusionID caller, FusionID caller,
CoreScreen **ret_screen ) CoreScreen **ret_screen )
{ {
D_UNUSED_P( core );
D_UNUSED_P( caller );
if (object_id >= (u32) dfb_screens_num()) if (object_id >= (u32) dfb_screens_num())
return DR_IDNOTFOUND; return DR_IDNOTFOUND;
*ret_screen = dfb_screens_at( object_id ); *ret_screen = dfb_screens_at( object_id );
return DR_OK; return DR_OK;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreScreen_Unref( CoreScreen *screen ) CoreScreen_Unref( CoreScreen *screen )
{ {
D_UNUSED_P( screen );
return DR_OK; return DR_OK;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreScreen_Catch( CoreDFB *core, CoreScreen_Catch( CoreDFB *core,
u32 object_id, u32 object_id,
CoreScreen **ret_screen ) CoreScreen **ret_screen )
{ {
D_UNUSED_P( core );
if (object_id >= (u32) dfb_screens_num()) if (object_id >= (u32) dfb_screens_num())
return DR_IDNOTFOUND; return DR_IDNOTFOUND;
*ret_screen = dfb_screens_at( object_id ); *ret_screen = dfb_screens_at( object_id );
return DR_OK; return DR_OK;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreScreen_Throw( CoreScreen *screen, CoreScreen_Throw( CoreScreen *screen,
FusionID catcher, FusionID catcher,
u32 *ret_object_id ) u32 *ret_object_id )
{ {
D_UNUSED_P( catcher );
*ret_object_id = dfb_screen_id( screen ); *ret_object_id = dfb_screen_id( screen );
return DR_OK; return DR_OK;
} }
static __inline__ u32 static __inline__ u32
CoreSurface_GetID( const CoreSurface *surface ) CoreSurface_GetID( const CoreSurface *surface )
{ {
return surface->object.id; return surface->object.id;
} }
skipping to change at line 478 skipping to change at line 527
u32 *ret_object_id ) u32 *ret_object_id )
{ {
*ret_object_id = surface->object.id; *ret_object_id = surface->object.id;
fusion_reactor_add_permissions( surface->object.reactor, catcher, fusion_reactor_add_permissions( surface->object.reactor, catcher,
(FusionReactorPermissions)(FUSION_REAC TOR_PERMIT_ATTACH_DETACH) ); (FusionReactorPermissions)(FUSION_REAC TOR_PERMIT_ATTACH_DETACH) );
fusion_ref_add_permissions( &surface->object.ref, catcher, fusion_ref_add_permissions( &surface->object.ref, catcher,
(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( &surface->call, catcher, FUSION_CALL_PERM IT_EXECUTE ); fusion_call_add_permissions( &surface->call, catcher, FUSION_CALL_PERM IT_EXECUTE );
if (!surface->object.owner) if (!surface->object.owner && !(surface->type & CSTF_LAYER))
surface->object.owner = catcher; surface->object.owner = catcher;
return fusion_ref_throw( &surface->object.ref, catcher ); return fusion_ref_throw( &surface->object.ref, catcher );
} }
static __inline__ u32 static __inline__ u32
CoreSurfaceAllocation_GetID( const CoreSurfaceAllocation *allocation )
{
return allocation->object.id;
}
static __inline__ DirectResult
CoreSurfaceAllocation_Lookup( CoreDFB *core,
u32 object_id,
FusionID caller,
CoreSurfaceAllocation **ret_allocation )
{
DFBResult ret;
CoreSurfaceAllocation *allocation;
ret = dfb_core_get_surface_allocation( core, object_id, &allocation );
if (ret)
return (DirectResult) ret;
if (allocation->object.owner && allocation->object.owner != caller) {
dfb_surface_allocation_unref( allocation );
return DR_ACCESSDENIED;
}
*ret_allocation = allocation;
return DR_OK;
}
static __inline__ DirectResult
CoreSurfaceAllocation_Unref( CoreSurfaceAllocation *allocation )
{
return (DirectResult) dfb_surface_allocation_unref( allocation );
}
static __inline__ DirectResult
CoreSurfaceAllocation_Catch( CoreDFB *core,
u32 object_id,
CoreSurfaceAllocation **ret_allocation )
{
DirectResult ret;
ret = (DirectResult) dfb_core_get_surface_allocation( core, object_id,
ret_allocation );
if (ret)
return ret;
fusion_ref_catch( &(*ret_allocation)->object.ref );
return DR_OK;
}
static __inline__ DirectResult
CoreSurfaceAllocation_Throw( CoreSurfaceAllocation *allocation,
FusionID catcher,
u32 *ret_object_id )
{
*ret_object_id = allocation->object.id;
fusion_reactor_add_permissions( allocation->object.reactor, catcher,
(FusionReactorPermissions)(FUSION_REAC
TOR_PERMIT_ATTACH_DETACH) );
fusion_ref_add_permissions( &allocation->object.ref, catcher,
(FusionRefPermissions)(FUSION_REF_PERMIT_R
EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
//fusion_call_add_permissions( &allocation->call, catcher, FUSION_CALL
_PERMIT_EXECUTE );
if (!allocation->object.owner)
allocation->object.owner = catcher;
return fusion_ref_throw( &allocation->object.ref, catcher );
}
static __inline__ u32
CoreSurfaceBuffer_GetID( const CoreSurfaceBuffer *buffer )
{
return buffer->object.id;
}
static __inline__ DirectResult
CoreSurfaceBuffer_Lookup( CoreDFB *core,
u32 object_id,
FusionID caller,
CoreSurfaceBuffer **ret_buffer )
{
DFBResult ret;
CoreSurfaceBuffer *buffer;
ret = dfb_core_get_surface_buffer( core, object_id, &buffer );
if (ret)
return (DirectResult) ret;
if (buffer->object.owner && buffer->object.owner != caller) {
dfb_surface_buffer_unref( buffer );
return DR_ACCESSDENIED;
}
*ret_buffer = buffer;
return DR_OK;
}
static __inline__ DirectResult
CoreSurfaceBuffer_Unref( CoreSurfaceBuffer *buffer )
{
return (DirectResult) dfb_surface_buffer_unref( buffer );
}
static __inline__ DirectResult
CoreSurfaceBuffer_Catch( CoreDFB *core,
u32 object_id,
CoreSurfaceBuffer **ret_buffer )
{
DirectResult ret;
ret = (DirectResult) dfb_core_get_surface_buffer( core, object_id, ret
_buffer );
if (ret)
return ret;
fusion_ref_catch( &(*ret_buffer)->object.ref );
return DR_OK;
}
static __inline__ DirectResult
CoreSurfaceBuffer_Throw( CoreSurfaceBuffer *buffer,
FusionID catcher,
u32 *ret_object_id )
{
*ret_object_id = buffer->object.id;
fusion_reactor_add_permissions( buffer->object.reactor, catcher,
(FusionReactorPermissions)(FUSION_REAC
TOR_PERMIT_ATTACH_DETACH) );
fusion_ref_add_permissions( &buffer->object.ref, catcher,
(FusionRefPermissions)(FUSION_REF_PERMIT_R
EF_UNREF_LOCAL | FUSION_REF_PERMIT_CATCH) );
//fusion_call_add_permissions( &buffer->call, catcher, FUSION_CALL_PER
MIT_EXECUTE );
if (!buffer->object.owner)
buffer->object.owner = catcher;
return fusion_ref_throw( &buffer->object.ref, catcher );
}
static __inline__ u32
CoreWindow_GetID( const CoreWindow *window ) CoreWindow_GetID( const CoreWindow *window )
{ {
return window->object.id; return window->object.id;
} }
static __inline__ DirectResult static __inline__ DirectResult
CoreWindow_Lookup( CoreDFB *core, CoreWindow_Lookup( CoreDFB *core,
u32 object_id, u32 object_id,
FusionID caller, FusionID caller,
CoreWindow **ret_window ) CoreWindow **ret_window )
 End of changes. 11 change blocks. 
1 lines changed or deleted 199 lines changed or added


 CoreLayerContext.h   CoreLayerContext.h 
skipping to change at line 116 skipping to change at line 116
const DFBWindowDescription *description, const DFBWindowDescription *description,
CoreWindow *parent, CoreWindow *parent,
CoreWindow *toplevel, CoreWindow *toplevel,
CoreWindow **ret_window); CoreWindow **ret_window);
DFBResult CoreLayerContext_FindWindow( DFBResult CoreLayerContext_FindWindow(
CoreLayerContext *obj, CoreLayerContext *obj,
DFBWindowID window_id, DFBWindowID window_id,
CoreWindow **ret_window); CoreWindow **ret_window);
DFBResult CoreLayerContext_FindWindowByResourceID(
CoreLayerContext *obj,
u64 resource_id,
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(
FusionCall *call FusionCall *call
); );
skipping to change at line 150 skipping to change at line 155
_CoreLayerContext_SetScreenLocation = 7, _CoreLayerContext_SetScreenLocation = 7,
_CoreLayerContext_SetScreenRectangle = 8, _CoreLayerContext_SetScreenRectangle = 8,
_CoreLayerContext_SetScreenPosition = 9, _CoreLayerContext_SetScreenPosition = 9,
_CoreLayerContext_SetOpacity = 10, _CoreLayerContext_SetOpacity = 10,
_CoreLayerContext_SetRotation = 11, _CoreLayerContext_SetRotation = 11,
_CoreLayerContext_SetColorAdjustment = 12, _CoreLayerContext_SetColorAdjustment = 12,
_CoreLayerContext_SetFieldParity = 13, _CoreLayerContext_SetFieldParity = 13,
_CoreLayerContext_SetClipRegions = 14, _CoreLayerContext_SetClipRegions = 14,
_CoreLayerContext_CreateWindow = 15, _CoreLayerContext_CreateWindow = 15,
_CoreLayerContext_FindWindow = 16, _CoreLayerContext_FindWindow = 16,
_CoreLayerContext_FindWindowByResourceID = 17,
} CoreLayerContextCall; } CoreLayerContextCall;
/* /*
* CoreLayerContext_GetPrimaryRegion * CoreLayerContext_GetPrimaryRegion
*/ */
typedef struct { typedef struct {
bool create; bool create;
} CoreLayerContextGetPrimaryRegion; } CoreLayerContextGetPrimaryRegion;
typedef struct { typedef struct {
skipping to change at line 338 skipping to change at line 344
*/ */
typedef struct { typedef struct {
DFBWindowID window_id; DFBWindowID window_id;
} CoreLayerContextFindWindow; } CoreLayerContextFindWindow;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
u32 window_id; u32 window_id;
} CoreLayerContextFindWindowReturn; } CoreLayerContextFindWindowReturn;
/*
* CoreLayerContext_FindWindowByResourceID
*/
typedef struct {
u64 resource_id;
} CoreLayerContextFindWindowByResourceID;
typedef struct {
DFBResult result;
u32 window_id;
} CoreLayerContextFindWindowByResourceIDReturn;
DFBResult ILayerContext_Real__GetPrimaryRegion( CoreLayerContext *obj, DFBResult ILayerContext_Real__GetPrimaryRegion( CoreLayerContext *obj,
bool create, bool create,
CoreLayerRegion **ret_region ) ; CoreLayerRegion **ret_region ) ;
DFBResult ILayerContext_Real__TestConfiguration( CoreLayerContext *obj, DFBResult ILayerContext_Real__TestConfiguration( CoreLayerContext *obj,
const DFBDisplayLayerConfig *config, const DFBDisplayLayerConfig *config,
DFBDisplayLayerConfigFlags *ret_failed ) ; DFBDisplayLayerConfigFlags *ret_failed ) ;
DFBResult ILayerContext_Real__SetConfiguration( CoreLayerContext *obj, DFBResult ILayerContext_Real__SetConfiguration( CoreLayerContext *obj,
const DFBDisplayLayerConfig *config ); const DFBDisplayLayerConfig *config );
skipping to change at line 394 skipping to change at line 412
DFBResult ILayerContext_Real__CreateWindow( CoreLayerContext *obj, 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 ) ;
DFBResult ILayerContext_Real__FindWindow( CoreLayerContext *obj, DFBResult ILayerContext_Real__FindWindow( CoreLayerContext *obj,
DFBWindowID window_id, DFBWindowID window_id,
CoreWindow **ret_window ) ; CoreWindow **ret_window ) ;
DFBResult ILayerContext_Real__FindWindowByResourceID( CoreLayerContext *obj
,
u64 resource_id,
CoreWindow **ret_window )
;
DFBResult ILayerContext_Requestor__GetPrimaryRegion( CoreLayerContext *obj, DFBResult ILayerContext_Requestor__GetPrimaryRegion( CoreLayerContext *obj,
bool create, bool create,
CoreLayerRegion **ret_region ) ; CoreLayerRegion **ret_region ) ;
DFBResult ILayerContext_Requestor__TestConfiguration( CoreLayerContext *obj , DFBResult ILayerContext_Requestor__TestConfiguration( CoreLayerContext *obj ,
const DFBDisplayLayerConfig *config, const DFBDisplayLayerConfig *config,
DFBDisplayLayerConfigFlags *ret_failed ) ; DFBDisplayLayerConfigFlags *ret_failed ) ;
DFBResult ILayerContext_Requestor__SetConfiguration( CoreLayerContext *obj, DFBResult ILayerContext_Requestor__SetConfiguration( CoreLayerContext *obj,
const DFBDisplayLayerConfig *config ); const DFBDisplayLayerConfig *config );
skipping to change at line 450 skipping to change at line 472
DFBResult ILayerContext_Requestor__CreateWindow( CoreLayerContext *obj, DFBResult ILayerContext_Requestor__CreateWindow( CoreLayerContext *obj,
const DFBWindowDescription *description, const DFBWindowDescription *description,
CoreWindow *parent, CoreWindow *parent,
CoreWindow *toplevel, CoreWindow *toplevel,
CoreWindow **ret_window ) ; CoreWindow **ret_window ) ;
DFBResult ILayerContext_Requestor__FindWindow( CoreLayerContext *obj, DFBResult ILayerContext_Requestor__FindWindow( CoreLayerContext *obj,
DFBWindowID window_id, DFBWindowID window_id,
CoreWindow **ret_window ) ; CoreWindow **ret_window ) ;
DFBResult ILayerContext_Requestor__FindWindowByResourceID( CoreLayerContext
*obj,
u64 resource_id,
CoreWindow **ret_window )
;
DFBResult CoreLayerContextDispatch__Dispatch( CoreLayerContext *obj, DFBResult CoreLayerContextDispatch__Dispatch( CoreLayerContext *obj,
FusionID caller, FusionID caller,
int method, int method,
void *ptr, void *ptr,
unsigned int length, unsigned int length,
void *ret_ptr, void *ret_ptr,
unsigned int ret_size, unsigned int ret_size,
unsigned int *ret_length ); unsigned int *ret_length );
#endif #endif
 End of changes. 5 change blocks. 
0 lines changed or deleted 30 lines changed or added


 CoreSurface.h   CoreSurface.h 
skipping to change at line 73 skipping to change at line 73
u8 a1, u8 a1,
u8 a2, u8 a2,
u8 a3); u8 a3);
DFBResult CoreSurface_SetField( DFBResult CoreSurface_SetField(
CoreSurface *obj, CoreSurface *obj,
s32 field); s32 field);
DFBResult CoreSurface_PreLockBuffer( DFBResult CoreSurface_PreLockBuffer(
CoreSurface *obj, CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
CoreSurfaceAccessorID accessor, CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
u32 *ret_allocati CoreSurfaceAllocation **ret_allocati
on_index); on);
DFBResult CoreSurface_PreLockBuffer2(
CoreSurface *obj,
CoreSurfaceBufferRole role,
CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access,
bool lock,
CoreSurfaceAllocation **ret_allocati
on);
DFBResult CoreSurface_PreReadBuffer( DFBResult CoreSurface_PreReadBuffer(
CoreSurface *obj, CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
const DFBRectangle *rect, const DFBRectangle *rect,
u32 *ret_allocati on_index); CoreSurfaceAllocation **ret_allocati on);
DFBResult CoreSurface_PreWriteBuffer( DFBResult CoreSurface_PreWriteBuffer(
CoreSurface *obj, CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
const DFBRectangle *rect, const DFBRectangle *rect,
u32 *ret_allocati on_index); CoreSurfaceAllocation **ret_allocati on);
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(
FusionCall *call FusionCall *call
); );
skipping to change at line 115 skipping to change at line 123
* 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_SetAlphaRamp = 5, _CoreSurface_SetAlphaRamp = 5,
_CoreSurface_SetField = 6, _CoreSurface_SetField = 6,
_CoreSurface_PreLockBuffer = 7, _CoreSurface_PreLockBuffer = 7,
_CoreSurface_PreReadBuffer = 8, _CoreSurface_PreLockBuffer2 = 8,
_CoreSurface_PreWriteBuffer = 9, _CoreSurface_PreReadBuffer = 9,
_CoreSurface_PreWriteBuffer = 10,
} 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 192 skipping to change at line 201
} CoreSurfaceSetField; } CoreSurfaceSetField;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
} CoreSurfaceSetFieldReturn; } CoreSurfaceSetFieldReturn;
/* /*
* CoreSurface_PreLockBuffer * CoreSurface_PreLockBuffer
*/ */
typedef struct { typedef struct {
u32 buffer_index; u32 buffer_id;
CoreSurfaceAccessorID accessor; CoreSurfaceAccessorID accessor;
CoreSurfaceAccessFlags access; CoreSurfaceAccessFlags access;
} CoreSurfacePreLockBuffer; } CoreSurfacePreLockBuffer;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
u32 allocation_index; u32 allocation_id;
} CoreSurfacePreLockBufferReturn; } CoreSurfacePreLockBufferReturn;
/* /*
* CoreSurface_PreLockBuffer2
*/
typedef struct {
CoreSurfaceBufferRole role;
CoreSurfaceAccessorID accessor;
CoreSurfaceAccessFlags access;
bool lock;
} CoreSurfacePreLockBuffer2;
typedef struct {
DFBResult result;
u32 allocation_id;
} CoreSurfacePreLockBuffer2Return;
/*
* CoreSurface_PreReadBuffer * CoreSurface_PreReadBuffer
*/ */
typedef struct { typedef struct {
u32 buffer_index; u32 buffer_id;
DFBRectangle rect; DFBRectangle rect;
} CoreSurfacePreReadBuffer; } CoreSurfacePreReadBuffer;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
u32 allocation_index; u32 allocation_id;
} CoreSurfacePreReadBufferReturn; } CoreSurfacePreReadBufferReturn;
/* /*
* CoreSurface_PreWriteBuffer * CoreSurface_PreWriteBuffer
*/ */
typedef struct { typedef struct {
u32 buffer_index; u32 buffer_id;
DFBRectangle rect; DFBRectangle rect;
} CoreSurfacePreWriteBuffer; } CoreSurfacePreWriteBuffer;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
u32 allocation_index; u32 allocation_id;
} CoreSurfacePreWriteBufferReturn; } CoreSurfacePreWriteBufferReturn;
DFBResult ISurface_Real__SetConfig( CoreSurface *obj, DFBResult ISurface_Real__SetConfig( CoreSurface *obj,
const CoreSurfaceConfig *config ); const CoreSurfaceConfig *config );
DFBResult ISurface_Real__Flip( CoreSurface *obj, DFBResult ISurface_Real__Flip( CoreSurface *obj,
bool swap ); bool swap );
DFBResult ISurface_Real__GetPalette( CoreSurface *obj, DFBResult ISurface_Real__GetPalette( CoreSurface *obj,
CorePalette **ret_palette ); CorePalette **ret_palette );
skipping to change at line 250 skipping to change at line 274
DFBResult ISurface_Real__SetAlphaRamp( CoreSurface *obj, DFBResult ISurface_Real__SetAlphaRamp( CoreSurface *obj,
u8 a0, u8 a0,
u8 a1, u8 a1,
u8 a2, u8 a2,
u8 a3 ); u8 a3 );
DFBResult ISurface_Real__SetField( CoreSurface *obj, DFBResult ISurface_Real__SetField( CoreSurface *obj,
s32 field ); s32 field );
DFBResult ISurface_Real__PreLockBuffer( CoreSurface *obj, DFBResult ISurface_Real__PreLockBuffer( CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
CoreSurfaceAccessorID accessor, CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
u32 *ret_allocati CoreSurfaceAllocation **ret_allocati
on_index ); on );
DFBResult ISurface_Real__PreLockBuffer2( CoreSurface *obj,
CoreSurfaceBufferRole role,
CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access,
bool lock,
CoreSurfaceAllocation **ret_allocati
on );
DFBResult ISurface_Real__PreReadBuffer( CoreSurface *obj, DFBResult ISurface_Real__PreReadBuffer( CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
const DFBRectangle *rect, const DFBRectangle *rect,
u32 *ret_allocati on_index ); CoreSurfaceAllocation **ret_allocati on );
DFBResult ISurface_Real__PreWriteBuffer( CoreSurface *obj, DFBResult ISurface_Real__PreWriteBuffer( CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
const DFBRectangle *rect, const DFBRectangle *rect,
u32 *ret_allocati on_index ); CoreSurfaceAllocation **ret_allocati on );
DFBResult ISurface_Requestor__SetConfig( CoreSurface *obj, DFBResult ISurface_Requestor__SetConfig( CoreSurface *obj,
const CoreSurfaceConfig *config ); const CoreSurfaceConfig *config );
DFBResult ISurface_Requestor__Flip( CoreSurface *obj, DFBResult ISurface_Requestor__Flip( CoreSurface *obj,
bool swap ); bool swap );
DFBResult ISurface_Requestor__GetPalette( CoreSurface *obj, DFBResult ISurface_Requestor__GetPalette( CoreSurface *obj,
CorePalette **ret_palette ); CorePalette **ret_palette );
skipping to change at line 287 skipping to change at line 318
DFBResult ISurface_Requestor__SetAlphaRamp( CoreSurface *obj, DFBResult ISurface_Requestor__SetAlphaRamp( CoreSurface *obj,
u8 a0, u8 a0,
u8 a1, u8 a1,
u8 a2, u8 a2,
u8 a3 ); u8 a3 );
DFBResult ISurface_Requestor__SetField( CoreSurface *obj, DFBResult ISurface_Requestor__SetField( CoreSurface *obj,
s32 field ); s32 field );
DFBResult ISurface_Requestor__PreLockBuffer( CoreSurface *obj, DFBResult ISurface_Requestor__PreLockBuffer( CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
CoreSurfaceAccessorID accessor, CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
u32 *ret_allocati CoreSurfaceAllocation **ret_allocati
on_index ); on );
DFBResult ISurface_Requestor__PreLockBuffer2( CoreSurface *obj,
CoreSurfaceBufferRole role,
CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access,
bool lock,
CoreSurfaceAllocation **ret_allocati
on );
DFBResult ISurface_Requestor__PreReadBuffer( CoreSurface *obj, DFBResult ISurface_Requestor__PreReadBuffer( CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
const DFBRectangle *rect, const DFBRectangle *rect,
u32 *ret_allocati on_index ); CoreSurfaceAllocation **ret_allocati on );
DFBResult ISurface_Requestor__PreWriteBuffer( CoreSurface *obj, DFBResult ISurface_Requestor__PreWriteBuffer( CoreSurface *obj,
u32 buffer_index , CoreSurfaceBuffer *buffer,
const DFBRectangle *rect, const DFBRectangle *rect,
u32 *ret_allocati on_index ); CoreSurfaceAllocation **ret_allocati on );
DFBResult CoreSurfaceDispatch__Dispatch( CoreSurface *obj, DFBResult CoreSurfaceDispatch__Dispatch( CoreSurface *obj,
FusionID caller, FusionID caller,
int method, int method,
void *ptr, void *ptr,
unsigned int length, unsigned int length,
void *ret_ptr, void *ret_ptr,
unsigned int ret_size, unsigned int ret_size,
unsigned int *ret_length ); unsigned int *ret_length );
 End of changes. 26 change blocks. 
29 lines changed or deleted 70 lines changed or added


 CoreWindow.h   CoreWindow.h 
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) ;
DFBResult CoreWindow_SetCursorShape(
CoreWindow *obj,
CoreSurface *shape,
const DFBPoint *hotspot);
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(
FusionCall *call FusionCall *call
); );
skipping to change at line 212 skipping to change at line 217
_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,
_CoreWindow_SetCursorShape = 27,
} 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 523 skipping to change at line 529
* 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;
/*
* CoreWindow_SetCursorShape
*/
typedef struct {
bool shape_set;
u32 shape_id;
DFBPoint hotspot;
} CoreWindowSetCursorShape;
typedef struct {
DFBResult result;
} CoreWindowSetCursorShapeReturn;
DFBResult IWindow_Real__Repaint( CoreWindow *obj, DFBResult IWindow_Real__Repaint( CoreWindow *obj,
const DFBRegion *left, const DFBRegion *left,
const DFBRegion *right, const DFBRegion *right,
DFBSurfaceFlipFlags flags ); DFBSurfaceFlipFlags flags );
DFBResult IWindow_Real__BeginUpdates( CoreWindow *obj, DFBResult IWindow_Real__BeginUpdates( CoreWindow *obj,
const DFBRegion *update ); const DFBRegion *update );
DFBResult IWindow_Real__Restack( CoreWindow *obj, DFBResult IWindow_Real__Restack( CoreWindow *obj,
CoreWindow *relative, CoreWindow *relative,
skipping to change at line 621 skipping to change at line 640
DFBWindowKeySelection selection, DFBWindowKeySelection selection,
const DFBInputDeviceKeySymbol *keys, const DFBInputDeviceKeySymbol *keys,
u32 num_keys ); u32 num_keys );
DFBResult IWindow_Real__SetRotation( CoreWindow *obj, DFBResult IWindow_Real__SetRotation( CoreWindow *obj,
int rotation ); int rotation );
DFBResult IWindow_Real__GetSurface( CoreWindow *obj, DFBResult IWindow_Real__GetSurface( CoreWindow *obj,
CoreSurface **ret_surface ); CoreSurface **ret_surface );
DFBResult IWindow_Real__SetCursorShape( CoreWindow *obj,
CoreSurface *shape,
const DFBPoint *hotspot );
DFBResult IWindow_Requestor__Repaint( CoreWindow *obj, DFBResult IWindow_Requestor__Repaint( CoreWindow *obj,
const DFBRegion *left, const DFBRegion *left,
const DFBRegion *right, const DFBRegion *right,
DFBSurfaceFlipFlags flags ); DFBSurfaceFlipFlags flags );
DFBResult IWindow_Requestor__BeginUpdates( CoreWindow *obj, DFBResult IWindow_Requestor__BeginUpdates( CoreWindow *obj,
const DFBRegion *update ); const DFBRegion *update );
DFBResult IWindow_Requestor__Restack( CoreWindow *obj, DFBResult IWindow_Requestor__Restack( CoreWindow *obj,
CoreWindow *relative, CoreWindow *relative,
skipping to change at line 719 skipping to change at line 742
DFBWindowKeySelection selection, DFBWindowKeySelection selection,
const DFBInputDeviceKeySymbol *keys, const DFBInputDeviceKeySymbol *keys,
u32 num_keys ); u32 num_keys );
DFBResult IWindow_Requestor__SetRotation( CoreWindow *obj, DFBResult IWindow_Requestor__SetRotation( CoreWindow *obj,
int rotation ); int rotation );
DFBResult IWindow_Requestor__GetSurface( CoreWindow *obj, DFBResult IWindow_Requestor__GetSurface( CoreWindow *obj,
CoreSurface **ret_surface ); CoreSurface **ret_surface );
DFBResult IWindow_Requestor__SetCursorShape( CoreWindow *obj,
CoreSurface *shape,
const DFBPoint *hotspot );
DFBResult CoreWindowDispatch__Dispatch( CoreWindow *obj, DFBResult CoreWindowDispatch__Dispatch( CoreWindow *obj,
FusionID caller, FusionID caller,
int method, int method,
void *ptr, void *ptr,
unsigned int length, unsigned int length,
void *ret_ptr, void *ret_ptr,
unsigned int ret_size, unsigned int ret_size,
unsigned int *ret_length ); unsigned int *ret_length );
#endif #endif
 End of changes. 5 change blocks. 
0 lines changed or deleted 27 lines changed or added


 CoreWindowStack.h   CoreWindowStack.h 
skipping to change at line 48 skipping to change at line 48
#ifdef __cplusplus #ifdef __cplusplus
#include <core/Interface.h> #include <core/Interface.h>
extern "C" { extern "C" {
#endif #endif
DFBResult CoreWindowStack_RepaintAll( DFBResult CoreWindowStack_RepaintAll(
CoreWindowStack *obj CoreWindowStack *obj
); );
DFBResult CoreWindowStack_GetInsets(
CoreWindowStack *obj,
CoreWindow *window,
DFBInsets *ret_insets);
DFBResult CoreWindowStack_CursorEnable( DFBResult CoreWindowStack_CursorEnable(
CoreWindowStack *obj, CoreWindowStack *obj,
bool enable); bool enable);
DFBResult CoreWindowStack_CursorSetShape( DFBResult CoreWindowStack_CursorSetShape(
CoreWindowStack *obj, CoreWindowStack *obj,
CoreSurface *shape, CoreSurface *shape,
const DFBPoint *hotspot); const DFBPoint *hotspot);
DFBResult CoreWindowStack_CursorSetOpacity( DFBResult CoreWindowStack_CursorSetOpacity(
skipping to change at line 110 skipping to change at line 115
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
/* /*
* CoreWindowStack Calls * CoreWindowStack Calls
*/ */
typedef enum { typedef enum {
_CoreWindowStack_RepaintAll = 1, _CoreWindowStack_RepaintAll = 1,
_CoreWindowStack_CursorEnable = 2, _CoreWindowStack_GetInsets = 2,
_CoreWindowStack_CursorSetShape = 3, _CoreWindowStack_CursorEnable = 3,
_CoreWindowStack_CursorSetOpacity = 4, _CoreWindowStack_CursorSetShape = 4,
_CoreWindowStack_CursorSetAcceleration = 5, _CoreWindowStack_CursorSetOpacity = 5,
_CoreWindowStack_CursorWarp = 6, _CoreWindowStack_CursorSetAcceleration = 6,
_CoreWindowStack_CursorGetPosition = 7, _CoreWindowStack_CursorWarp = 7,
_CoreWindowStack_BackgroundSetMode = 8, _CoreWindowStack_CursorGetPosition = 8,
_CoreWindowStack_BackgroundSetImage = 9, _CoreWindowStack_BackgroundSetMode = 9,
_CoreWindowStack_BackgroundSetColor = 10, _CoreWindowStack_BackgroundSetImage = 10,
_CoreWindowStack_BackgroundSetColorIndex = 11, _CoreWindowStack_BackgroundSetColor = 11,
_CoreWindowStack_BackgroundSetColorIndex = 12,
} CoreWindowStackCall; } CoreWindowStackCall;
/* /*
* CoreWindowStack_RepaintAll * CoreWindowStack_RepaintAll
*/ */
typedef struct { typedef struct {
} CoreWindowStackRepaintAll; } CoreWindowStackRepaintAll;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
} CoreWindowStackRepaintAllReturn; } CoreWindowStackRepaintAllReturn;
/* /*
* CoreWindowStack_GetInsets
*/
typedef struct {
u32 window_id;
} CoreWindowStackGetInsets;
typedef struct {
DFBResult result;
DFBInsets insets;
} CoreWindowStackGetInsetsReturn;
/*
* CoreWindowStack_CursorEnable * CoreWindowStack_CursorEnable
*/ */
typedef struct { typedef struct {
bool enable; bool enable;
} CoreWindowStackCursorEnable; } CoreWindowStackCursorEnable;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
} CoreWindowStackCursorEnableReturn; } CoreWindowStackCursorEnableReturn;
skipping to change at line 248 skipping to change at line 266
s32 index; s32 index;
} CoreWindowStackBackgroundSetColorIndex; } CoreWindowStackBackgroundSetColorIndex;
typedef struct { typedef struct {
DFBResult result; DFBResult result;
} CoreWindowStackBackgroundSetColorIndexReturn; } CoreWindowStackBackgroundSetColorIndexReturn;
DFBResult IWindowStack_Real__RepaintAll( CoreWindowStack *obj DFBResult IWindowStack_Real__RepaintAll( CoreWindowStack *obj
); );
DFBResult IWindowStack_Real__GetInsets( CoreWindowStack *obj,
CoreWindow *window,
DFBInsets *ret_insets )
;
DFBResult IWindowStack_Real__CursorEnable( CoreWindowStack *obj, DFBResult IWindowStack_Real__CursorEnable( CoreWindowStack *obj,
bool enable ); bool enable );
DFBResult IWindowStack_Real__CursorSetShape( CoreWindowStack *obj, DFBResult IWindowStack_Real__CursorSetShape( CoreWindowStack *obj,
CoreSurface *shape, CoreSurface *shape,
const DFBPoint *hotspot ); const DFBPoint *hotspot );
DFBResult IWindowStack_Real__CursorSetOpacity( CoreWindowStack *obj, DFBResult IWindowStack_Real__CursorSetOpacity( CoreWindowStack *obj,
u8 opacity ); u8 opacity );
skipping to change at line 284 skipping to change at line 306
DFBResult IWindowStack_Real__BackgroundSetColor( CoreWindowStack *obj, DFBResult IWindowStack_Real__BackgroundSetColor( CoreWindowStack *obj,
const DFBColor *color ); const DFBColor *color );
DFBResult IWindowStack_Real__BackgroundSetColorIndex( CoreWindowStack *obj, DFBResult IWindowStack_Real__BackgroundSetColorIndex( CoreWindowStack *obj,
s32 index ); s32 index );
DFBResult IWindowStack_Requestor__RepaintAll( CoreWindowStack *obj DFBResult IWindowStack_Requestor__RepaintAll( CoreWindowStack *obj
); );
DFBResult IWindowStack_Requestor__GetInsets( CoreWindowStack *obj,
CoreWindow *window,
DFBInsets *ret_insets )
;
DFBResult IWindowStack_Requestor__CursorEnable( CoreWindowStack *obj, DFBResult IWindowStack_Requestor__CursorEnable( CoreWindowStack *obj,
bool enable ); bool enable );
DFBResult IWindowStack_Requestor__CursorSetShape( CoreWindowStack *obj, DFBResult IWindowStack_Requestor__CursorSetShape( CoreWindowStack *obj,
CoreSurface *shape, CoreSurface *shape,
const DFBPoint *hotspot ); const DFBPoint *hotspot );
DFBResult IWindowStack_Requestor__CursorSetOpacity( CoreWindowStack *obj, DFBResult IWindowStack_Requestor__CursorSetOpacity( CoreWindowStack *obj,
u8 opacity ); u8 opacity );
 End of changes. 5 change blocks. 
10 lines changed or deleted 38 lines changed or added


 call.h   call.h 
skipping to change at line 75 skipping to change at line 75
DirectResult fusion_call_init ( FusionCall *call, DirectResult fusion_call_init ( FusionCall *call,
FusionCallHandler handler, FusionCallHandler handler,
void *ctx, void *ctx,
const FusionWorld *world ); const FusionWorld *world );
DirectResult fusion_call_init3 ( FusionCall *call, DirectResult fusion_call_init3 ( FusionCall *call,
FusionCallHandler3 handler3, FusionCallHandler3 handler3,
void *ctx, void *ctx,
const FusionWorld *world ); const FusionWorld *world );
DirectResult fusion_call_init_from( FusionCall *call,
int call_id,
const FusionWorld *world );
DirectResult fusion_call_execute( FusionCall *call, DirectResult fusion_call_execute( FusionCall *call,
FusionCallExecFlags flags, FusionCallExecFlags flags,
int call_arg, int call_arg,
void *call_ptr, void *call_ptr,
int *ret_val ); int *ret_val );
DirectResult fusion_call_execute2( FusionCall *call,
FusionCallExecFlags flags,
int call_arg,
void *ptr,
unsigned int length,
int *ret_val );
DirectResult fusion_call_execute3( FusionCall *call, DirectResult fusion_call_execute3( FusionCall *call,
FusionCallExecFlags flags, FusionCallExecFlags flags,
int call_arg, int call_arg,
void *ptr, void *ptr,
unsigned int length, unsigned int length,
void *ret_ptr, void *ret_ptr,
unsigned int ret_size, unsigned int ret_size,
unsigned int *ret_length ); unsigned int *ret_length );
DirectResult fusion_call_return ( FusionCall *call, DirectResult fusion_call_return ( FusionCall *call,
unsigned int serial, unsigned int serial,
int val ); int val );
DirectResult fusion_call_return3( FusionCall *call, DirectResult fusion_call_return3( FusionCall *call,
unsigned int serial, unsigned int serial,
void *ptr, void *ptr,
unsigned int length ); unsigned int length );
DirectResult fusion_call_get_owner( FusionCall *call,
FusionID *ret_fusion_id );
DirectResult fusion_call_destroy( FusionCall *call ); DirectResult fusion_call_destroy( FusionCall *call );
typedef enum { typedef enum {
FUSION_CALL_PERMIT_NONE = 0x00000000, FUSION_CALL_PERMIT_NONE = 0x00000000,
FUSION_CALL_PERMIT_EXECUTE = 0x00000001, FUSION_CALL_PERMIT_EXECUTE = 0x00000001,
FUSION_CALL_PERMIT_ALL = 0x00000001, FUSION_CALL_PERMIT_ALL = 0x00000001,
} FusionCallPermissions; } FusionCallPermissions;
 End of changes. 3 change blocks. 
0 lines changed or deleted 14 lines changed or added


 clip.h   clip.h 
skipping to change at line 69 skipping to change at line 69
* Returns a flag for each edge that wasn't cut off. * Returns a flag for each edge that wasn't cut off.
*/ */
DFBEdgeFlags dfb_clip_edges( const DFBRegion *clip, DFBRectangle *rect ); DFBEdgeFlags dfb_clip_edges( const DFBRegion *clip, DFBRectangle *rect );
static inline DFBBoolean static inline DFBBoolean
dfb_clip_needed( const DFBRegion *clip, DFBRectangle *rect ) dfb_clip_needed( const DFBRegion *clip, DFBRectangle *rect )
{ {
return ((clip->x1 > rect->x) || return ((clip->x1 > rect->x) ||
(clip->y1 > rect->y) || (clip->y1 > rect->y) ||
(clip->x2 < rect->x + rect->w - 1) || (clip->x2 < rect->x + rect->w - 1) ||
(clip->y2 < rect->y + rect->h - 1)); (clip->y2 < rect->y + rect->h - 1)) ? DFB_TRUE : DFB_FALSE;
} }
/* /*
* Simple check if triangle lies outside the clipping region. * Simple check if triangle lies outside the clipping region.
* Returns true if the triangle may be visible within the region. * Returns true if the triangle may be visible within the region.
*/ */
DFBBoolean dfb_clip_triangle_precheck( const DFBRegion *clip, DFBBoolean dfb_clip_triangle_precheck( const DFBRegion *clip,
const DFBTriangle *tri ); const DFBTriangle *tri );
/* /*
skipping to change at line 124 skipping to change at line 124
/* /*
* Clips the stretch blit request to the clipping region. * Clips the stretch blit request to the clipping region.
* This includes adjustment of source AND destination coordinates * This includes adjustment of source AND destination coordinates
* based on the scaling factor. * based on the scaling factor.
*/ */
void dfb_clip_stretchblit( const DFBRegion *clip, void dfb_clip_stretchblit( const DFBRegion *clip,
DFBRectangle *srect, DFBRectangle *srect,
DFBRectangle *drect ); DFBRectangle *drect );
/*
* Clips the blitting request to the clipping region.
* This includes adjustment of source AND destination coordinates.
*
* In contrast to dfb_clip_blit() this also honors DSBLIT_ROTATE_ and DSBLI
T_FLIP_ blittingflags.
*
* FIXME: rotation and flipping is not supported simultaniously since the s
oftware driver
* would crash in its current state.
*/
void
dfb_clip_blit_flipped_rotated( const DFBRegion *clip,
DFBRectangle *srect, DFBRectangle *drect, DF
BSurfaceBlittingFlags flags );
#endif #endif
 End of changes. 2 change blocks. 
1 lines changed or deleted 18 lines changed or added


 conf.h   conf.h 
skipping to change at line 256 skipping to change at line 256
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; char *resource_manager;
bool layers_clear;
} 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/CoreSlave_includes.h>
#include <core/surface.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,
skipping to change at line 85 skipping to change at line 87
#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 );
CoreSurfaceAllocation *dfb_core_create_surface_allocation( CoreDFB *core );
CoreSurfaceBuffer *dfb_core_create_surface_buffer( 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 108 skipping to change at line 111
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_allocation( CoreDFB
*core,
u32
object_id,
CoreSurfaceAllocation *
*ret_allocation );
DFBResult dfb_core_get_surface_buffer ( CoreDFB *core , DFBResult dfb_core_get_surface_buffer ( CoreDFB *core ,
u32 obje ct_id, u32 obje ct_id,
CoreSurfaceBuffer **ret_ surface ); 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
skipping to change at line 187 skipping to change at line 194
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( ICoreResourceManager )
DECLARE_INTERFACE( ICoreResourceClient ); DECLARE_INTERFACE( ICoreResourceClient )
struct __DFB_CoreDFBShared { struct __DFB_CoreDFBShared {
int magic; int magic;
bool secure;
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_allocation_pool;
FusionObjectPool *surface_buffer_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 {
skipping to change at line 238 skipping to change at line 248
DirectSignalHandler *signal_handler; DirectSignalHandler *signal_handler;
DirectCleanupHandler *cleanup_handler; DirectCleanupHandler *cleanup_handler;
DFBFontManager *font_manager; DFBFontManager *font_manager;
struct { struct {
ICoreResourceManager *manager; ICoreResourceManager *manager;
DirectHash *clients; DirectHash *identities;
} resource; } resource;
FusionCall async_call; // used locally for async destroy
etc.
FusionCall slave_call;
DirectLink *memory_permissions;
DirectMutex memory_permissions_lock;
}; };
typedef enum {
CMPF_READ = 0x00000001,
CMPF_WRITE = 0x00000002,
} CoreMemoryPermissionFlags;
typedef struct __CoreDFB_CoreMemoryPermission CoreMemoryPermission;
DFBResult dfb_core_memory_permissions_add ( CoreDFB *co
re,
CoreMemoryPermissionFlags fl
ags,
void *da
ta,
size_t le
ngth,
CoreMemoryPermission **re
t_permission );
DFBResult dfb_core_memory_permissions_remove( CoreDFB *co
re,
CoreMemoryPermission *pe
rmission );
DFBResult dfb_core_memory_permissions_check ( CoreDFB *co
re,
CoreMemoryPermissionFlags fl
ags,
void *da
ta,
size_t le
ngth );
extern CoreDFB *core_dfb; // FIXME extern CoreDFB *core_dfb; // FIXME
typedef void (*AsyncCallFunc)( void *ctx,
void *ctx2 );
typedef struct {
AsyncCallFunc func;
void *ctx;
void *ctx2;
} AsyncCall;
/*
* Runs a call on the Fusion Dispatch Thread
*
* Used for asynchronous destruct, i.e. when a call needs to destroy itself
*/
static __inline__ DFBResult
Core_AsyncCall( AsyncCallFunc func,
void *ctx,
void *ctx2 )
{
AsyncCall call;
call.func = func;
call.ctx = ctx;
call.ctx2 = ctx2;
return (DFBResult) fusion_call_execute2( &core_dfb->async_call, (Fusio
nCallExecFlags)(FCEF_ONEWAY | FCEF_NODIRECT), 0, &call, sizeof(call), NULL
);
}
void Core_TLS__init( void ); void Core_TLS__init( void );
void Core_TLS__deinit( void ); void Core_TLS__deinit( void );
/* /*
* Identity management * Identity management
* *
* Incoming dispatch pushes ID of caller * Incoming dispatch pushes ID of caller
*/ */
void Core_PushIdentity( FusionID caller ); void Core_PushIdentity( FusionID caller );
skipping to change at line 292 skipping to change at line 359
/* /*
* Resource manager main interface * Resource manager main interface
* *
* Implementation can be loaded via 'resource-manager' option. * Implementation can be loaded via 'resource-manager' option.
*/ */
DEFINE_INTERFACE( ICoreResourceManager, DEFINE_INTERFACE( ICoreResourceManager,
DFBResult (*CreateClient) ( ICoreResourceManager *thiz, DFBResult (*CreateClient) ( ICoreResourceManager *thiz,
FusionID identity, FusionID identity,
ICoreResourceClient **ret_client ); ICoreResourceClient **ret_client );
); )
/* /*
* Per slave resource accounting * Per slave resource accounting
*/ */
DEFINE_INTERFACE( ICoreResourceClient, DEFINE_INTERFACE( ICoreResourceClient,
DFBResult (*CheckSurface) ( ICoreResourceClient *thiz, DFBResult (*CheckSurface) ( ICoreResourceClient *thiz,
const CoreSurfaceConfig *config, const CoreSurfaceConfig *config,
CoreSurfaceTypeFlags type, CoreSurfaceTypeFlags type,
u64 resource_i d, u64 resource_i d,
skipping to change at line 318 skipping to change at line 385
DFBResult (*AddSurface) ( ICoreResourceClient *thiz, DFBResult (*AddSurface) ( ICoreResourceClient *thiz,
CoreSurface *surface ); CoreSurface *surface );
DFBResult (*RemoveSurface) ( ICoreResourceClient *thiz, DFBResult (*RemoveSurface) ( ICoreResourceClient *thiz,
CoreSurface *surface ); CoreSurface *surface );
DFBResult (*UpdateSurface) ( ICoreResourceClient *thiz, DFBResult (*UpdateSurface) ( ICoreResourceClient *thiz,
CoreSurface *surface, CoreSurface *surface,
const CoreSurfaceConfig *config ); const CoreSurfaceConfig *config );
); )
/* /*
* Client instance management * Client instance management
*/ */
ICoreResourceClient *Core_Resource_GetClient ( FusionID identity ); DFBResult Core_Resource_AddIdentity ( FusionID identity,
u32 slave_call );
DFBResult Core_Resource_AddClient ( FusionID identity ); void Core_Resource_DisposeIdentity( FusionID identity );
void Core_Resource_DisposeClient( FusionID identity );
ICoreResourceClient *Core_Resource_GetClient ( FusionID identity );
CoreSlave *Core_Resource_GetSlave ( FusionID identity );
/*
* Per client cleanup
*/
typedef struct __Core__CoreResourceCleanup CoreResourceCleanup;
typedef void (*CoreResourceCleanupCallback)( void *ctx,
void *ctx2 );
DFBResult Core_Resource_AddCleanup ( FusionID
identity,
CoreResourceCleanupCall
back callback,
void
*ctx,
void
*ctx2,
CoreResourceCleanup
**ret_cleanup );
DFBResult Core_Resource_DisposeCleanup ( CoreResourceCleanup
*cleanup );
#endif #endif
 End of changes. 14 change blocks. 
8 lines changed or deleted 118 lines changed or added


 debug.h   debug.h 
skipping to change at line 70 skipping to change at line 70
#if DIRECT_BUILD_TEXT #if DIRECT_BUILD_TEXT
#define D_DEBUG_DOMAIN(identifier,name,description) \ #define D_DEBUG_DOMAIN(identifier,name,description) \
static DirectDebugDomain identifier __attribute__((unused)) \ static DirectDebugDomain identifier __attribute__((unused)) \
= { 0, false, false, name, description, sizeof(name) - 1 } = { 0, false, false, name, description, sizeof(name) - 1 }
void direct_debug_at_always( DirectDebugDomain *domain, void direct_debug_at_always( DirectDebugDomain *domain,
const char *format, ... ) D_FORMAT_PRI NTF(2); const char *format, ... ) D_FORMAT_PRI NTF(2);
#define d_debug_at( domain, x... ) direct_debug_at_always( &domain, x ) #define d_debug_at( domain, ... ) direct_debug_at_always( &domain, __V A_ARGS__ )
#if DIRECT_BUILD_DEBUGS #if DIRECT_BUILD_DEBUGS
void direct_debug( const char *format, ... ) D_FORMAT_PRINTF(1); void direct_debug( const char *format, ... ) D_FORMAT_PRINTF(1);
void direct_debug_at( DirectDebugDomain *domain, void direct_debug_at( DirectDebugDomain *domain,
const char *format, ... ) D_FORMAT_PRINTF(2); const char *format, ... ) D_FORMAT_PRINTF(2);
void direct_debug_enter( DirectDebugDomain *domain, void direct_debug_enter( DirectDebugDomain *domain,
const char *func, const char *func,
const char *file, const char *file,
int line, int line,
const char *format, ... ) D_FORMAT_PRINTF(5); const char *format, ... ) D_FORMAT_PRINTF(5);
void direct_debug_exit( DirectDebugDomain *domain, void direct_debug_exit( DirectDebugDomain *domain,
const char *func, const char *func,
const char *file, const char *file,
int line, int line,
const char *format, ... ) D_FORMAT_PRINTF(5); const char *format, ... ) D_FORMAT_PRINTF(5);
void direct_break( const char *func, void direct_break( const char *func,
const char *file, const char *file,
int line, int line,
const char *format, ... ) D_FORMAT_PRINTF(4); const char *format, ... ) D_FORMAT_PRINTF(4);
void direct_assertion( const char *exp, void direct_assertion( const char *exp,
skipping to change at line 111 skipping to change at line 111
void direct_assumption( const char *exp, void direct_assumption( const char *exp,
const char *func, const char *func,
const char *file, const char *file,
int line ); int line );
#endif #endif
#if DIRECT_BUILD_DEBUG || defined(DIRECT_ENABLE_DEBUG) || defined(DIRECT_FO RCE_DEBUG) #if DIRECT_BUILD_DEBUG || defined(DIRECT_ENABLE_DEBUG) || defined(DIRECT_FO RCE_DEBUG)
#define D_DEBUG_ENABLED (1) #define D_DEBUG_ENABLED (1)
#define D_DEBUG(x...) \ #define D_DEBUG(...) \
do { \ do { \
if (!direct_config || direct_config->debug) \ if (!direct_config || direct_config->debug) \
direct_debug( x ); \ direct_debug( __VA_ARGS__ ); \
} while (0) } while (0)
#define D_DEBUG_AT(d,x...) \ #define D_DEBUG_AT(d,...) \
do { \ do { \
direct_debug_at( &d, x ); \ direct_debug_at( &d, __VA_ARGS__ ); \
} while (0) } while (0)
#define D_DEBUG_ENTER(d,x...) \ #define D_DEBUG_ENTER(d,...) \
do { \ do { \
direct_debug_enter( &d, __FUNCTION__, __FILE__, __LINE__, x ); \ direct_debug_enter( &d, __FUNCTION__, __FILE__, __LINE__, __VA_AR GS__ ); \
} while (0) } while (0)
#define D_DEBUG_EXIT(d,x...) \ #define D_DEBUG_EXIT(d,...) \
do { \ do { \
direct_debug_exit( &d, __FUNCTION__, __FILE__, __LINE__, x ); \ direct_debug_exit( &d, __FUNCTION__, __FILE__, __LINE__, __VA_ARG S__ ); \
} while (0) } while (0)
#define D_ASSERT(exp) \ #define D_ASSERT(exp) \
do { \ do { \
if (!(exp)) \ if (!(exp)) \
direct_assertion( #exp, __FUNCTION__, __FILE__, __LINE__ ); \ direct_assertion( #exp, __FUNCTION__, __FILE__, __LINE__ ); \
} while (0) } while (0)
#define D_ASSUME(exp) \ #define D_ASSUME(exp) \
do { \ do { \
if (!(exp)) \ if (!(exp)) \
direct_assumption( #exp, __FUNCTION__, __FILE__, __LINE__ ); \ direct_assumption( #exp, __FUNCTION__, __FILE__, __LINE__ ); \
} while (0) } while (0)
#define D_BREAK(x...) \ #define D_BREAK(...) \
do { \ do { \
direct_break( __FUNCTION__, __FILE__, __LINE__, x ); \ direct_break( __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__ ); \
} while (0) } while (0)
#define D_DEBUG_CHECK(d) \ #define D_DEBUG_CHECK(d) \
direct_debug_check_domain( &d ) direct_debug_check_domain( &d )
#elif defined(DIRECT_MINI_DEBUG) #elif defined(DIRECT_MINI_DEBUG)
/* /*
* Mini debug mode, only D_DEBUG_AT, no domain filters, simple assertion * Mini debug mode, only D_DEBUG_AT, no domain filters, simple assertion
*/ */
#define D_DEBUG_ENABLED (2) #define D_DEBUG_ENABLED (2)
#define D_DEBUG_AT(d,x...) \ #define D_DEBUG_AT(d,...) \
do { \ do { \
if (direct_config->debug) direct_debug_at_always( &d, x ); \ if (direct_config->debug) direct_debug_at_always( &d, __VA_ARGS__ ); \
} while (0) } while (0)
#define D_CHECK(exp, aa) \ #define D_CHECK(exp, aa) \
do { \ do { \
if (!(exp)) { \ if (!(exp)) { \
long long millis = direct_clock_get_millis(); \ long long millis = direct_clock_get_millis(); \
const char *name = direct_thread_self_name(); \ const char *name = direct_thread_self_name(); \
\ \
direct_log_printf( NULL, \ direct_log_printf( NULL, \
"(!) [%-15s %3lld.%03lld] (%5d) *** " #aa " [%s] failed *** [%s:%d in %s()]\n", \ "(!) [%-15s %3lld.%03lld] (%5d) *** " #aa " [%s] failed *** [%s:%d in %s()]\n", \
skipping to change at line 199 skipping to change at line 199
/* /*
* Fallback definitions, e.g. without DIRECT_BUILD_TEXT or DIRECT_ENABLE_DE BUG * Fallback definitions, e.g. without DIRECT_BUILD_TEXT or DIRECT_ENABLE_DE BUG
*/ */
#ifndef D_DEBUG_ENABLED #ifndef D_DEBUG_ENABLED
#define D_DEBUG_ENABLED (0) #define D_DEBUG_ENABLED (0)
#endif #endif
#ifndef D_DEBUG #ifndef D_DEBUG
#define D_DEBUG(x...) do {} while (0) #define D_DEBUG(...) do {} while (0)
#endif #endif
#ifndef D_DEBUG_AT #ifndef D_DEBUG_AT
#define D_DEBUG_AT(d,x...) do {} while (0) #define D_DEBUG_AT(d,...) do {} while (0)
#endif #endif
#ifndef D_DEBUG_ENTER #ifndef D_DEBUG_ENTER
#define D_DEBUG_ENTER(d,x...) do {} while (0) #define D_DEBUG_ENTER(d,...) do {} while (0)
#endif #endif
#ifndef D_DEBUG_EXIT #ifndef D_DEBUG_EXIT
#define D_DEBUG_EXIT(d,x...) do {} while (0) #define D_DEBUG_EXIT(d,...) do {} while (0)
#endif #endif
#ifndef D_ASSERT #ifndef D_ASSERT
#define D_ASSERT(exp) do {} while (0) #define D_ASSERT(exp) do {} while (0)
#endif #endif
#ifndef D_ASSUME #ifndef D_ASSUME
#define D_ASSUME(exp) do {} while (0) #define D_ASSUME(exp) do {} while (0)
#endif #endif
#ifndef D_DEBUG_CHECK #ifndef D_DEBUG_CHECK
#define D_DEBUG_CHECK(d) false #define D_DEBUG_CHECK(d) false
#endif #endif
#ifndef D_BREAK #ifndef D_BREAK
#define D_BREAK(x...) do {} while (0) #define D_BREAK(...) do {} while (0)
#endif #endif
#ifndef d_debug_at #ifndef d_debug_at
#define d_debug_at( domain, x... ) do {} while (0) #define d_debug_at( domain, ... ) do {} while (0)
#endif #endif
#ifndef D_DEBUG_DOMAIN #ifndef D_DEBUG_DOMAIN
#define D_DEBUG_DOMAIN(i,n,d) #define D_DEBUG_DOMAIN(i,n,d)
#endif #endif
/* /*
* Magic Assertions & Utilities * Magic Assertions & Utilities
*/ */
 End of changes. 21 change blocks. 
21 lines changed or deleted 21 lines changed or added


 directfb.h   directfb.h 
skipping to change at line 185 skipping to change at line 185
DFB_NOCORE = DR_NOCORE, /* Core part not availabl e. */ DFB_NOCORE = DR_NOCORE, /* Core part not availabl e. */
/* /*
* DirectFB specific result codes starting at (after) this offset * DirectFB specific result codes starting at (after) this offset
*/ */
DFB__RESULT_OFFSET = D_RESULT_TYPE_BASE( 'D','F','B' ), DFB__RESULT_OFFSET = D_RESULT_TYPE_BASE( 'D','F','B' ),
DFB_NOVIDEOMEMORY, /* There's not enough video memory. */ DFB_NOVIDEOMEMORY, /* There's not enough video memory. */
DFB_MISSINGFONT, /* No font has been set. */ DFB_MISSINGFONT, /* No font has been set. */
DFB_MISSINGIMAGE, /* No image has been set. */ DFB_MISSINGIMAGE, /* No image has been set. */
DFB_NOALLOCATION, /* No allocation. */
} DFBResult; } DFBResult;
/* /*
* A boolean. * A boolean.
*/ */
typedef enum { typedef enum {
DFB_FALSE = 0, DFB_FALSE = 0,
DFB_TRUE = !DFB_FALSE DFB_TRUE = !DFB_FALSE
} DFBBoolean; } DFBBoolean;
skipping to change at line 1485 skipping to change at line 1486
*/ */
typedef struct { typedef struct {
DFBWindowDescriptionFlags flags; /* field validation * / DFBWindowDescriptionFlags flags; /* field validation * /
DFBWindowCapabilities caps; /* capabilities */ DFBWindowCapabilities caps; /* capabilities */
int width; /* pixel width */ int width; /* pixel width */
int height; /* pixel height */ int height; /* pixel height */
DFBSurfacePixelFormat pixelformat; /* pixel format */ DFBSurfacePixelFormat pixelformat; /* pixel format */
int posx; /* distance from left layer border */ int posx; /* distance from left layer border */
int posy; /* distance from uppe r layer border */ int posy; /* distance from uppe r layer border */
DFBSurfaceCapabilities surface_caps; /* pixel format */ DFBSurfaceCapabilities surface_caps; /* surface capabiliti es */
DFBWindowID parent_id; /* window id of paren t window */ DFBWindowID parent_id; /* window id of paren t window */
DFBWindowOptions options; /* initial window opt ions */ DFBWindowOptions options; /* initial window opt ions */
DFBWindowStackingClass stacking; /* initial stacking c lass */ DFBWindowStackingClass stacking; /* initial stacking c lass */
unsigned long resource_id; /* resource id used t o create the window surface */ unsigned long resource_id; /* resource id used t o create the window surface */
DFBWindowID toplevel_id; /* top level window, if != 0 window will be a sub window */ DFBWindowID toplevel_id; /* top level window, if != 0 window will be a sub window */
} DFBWindowDescription; } DFBWindowDescription;
/* /*
skipping to change at line 3250 skipping to change at line 3251
surface is locked. */ surface is locked. */
DSLF_WRITE = 0x00000002 /* Request write access. If DSLF_WRITE = 0x00000002 /* Request write access. If
specified and surface has specified and surface has
a back buffer, it will be a back buffer, it will be
used. Otherwise, the front used. Otherwise, the front
buffer is used. */ buffer is used. */
} DFBSurfaceLockFlags; } DFBSurfaceLockFlags;
/* /*
* Available Porter/Duff rules. * Available Porter/Duff rules.
*
* pixel = (source * fs + destination * fd),
* sa = source alpha,
* da = destination alpha
*/ */
typedef enum { typedef enum {
/* pixel = (source * fs + destination * fd),
sa = source alpha,
da = destination alpha */
DSPD_NONE = 0, /* fs: sa fd: 1.0-sa (defaults) */ DSPD_NONE = 0, /* fs: sa fd: 1.0-sa (defaults) */
DSPD_CLEAR = 1, /* fs: 0.0 fd: 0.0 */ DSPD_CLEAR = 1, /* fs: 0.0 fd: 0.0 */
DSPD_SRC = 2, /* fs: 1.0 fd: 0.0 */ DSPD_SRC = 2, /* fs: 1.0 fd: 0.0 */
DSPD_SRC_OVER = 3, /* fs: 1.0 fd: 1.0-sa */ DSPD_SRC_OVER = 3, /* fs: 1.0 fd: 1.0-sa */
DSPD_DST_OVER = 4, /* fs: 1.0-da fd: 1.0 */ DSPD_DST_OVER = 4, /* fs: 1.0-da fd: 1.0 */
DSPD_SRC_IN = 5, /* fs: da fd: 0.0 */ DSPD_SRC_IN = 5, /* fs: da fd: 0.0 */
DSPD_DST_IN = 6, /* fs: 0.0 fd: sa */ DSPD_DST_IN = 6, /* fs: 0.0 fd: sa */
DSPD_SRC_OUT = 7, /* fs: 1.0-da fd: 0.0 */ DSPD_SRC_OUT = 7, /* fs: 1.0-da fd: 0.0 */
DSPD_DST_OUT = 8, /* fs: 0.0 fd: 1.0-sa */ DSPD_DST_OUT = 8, /* fs: 0.0 fd: 1.0-sa */
DSPD_SRC_ATOP = 9, /* fs: da fd: 1.0-sa */ DSPD_SRC_ATOP = 9, /* fs: da fd: 1.0-sa */
 End of changes. 4 change blocks. 
4 lines changed or deleted 6 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 (15) #define DIRECTFB_MICRO_VERSION (16)
#define DIRECTFB_BINARY_AGE (9) #define DIRECTFB_BINARY_AGE (10)
#define DIRECTFB_INTERFACE_AGE (9) #define DIRECTFB_INTERFACE_AGE (10)
#endif /* __DIRECTFB_VERSION_H__ */ #endif /* __DIRECTFB_VERSION_H__ */
 End of changes. 1 change blocks. 
3 lines changed or deleted 3 lines changed or added


 directfbgl.h   directfbgl.h 
skipping to change at line 108 skipping to change at line 108
); );
/* /*
* Get the address of an OpenGL function. * Get the address of an OpenGL function.
*/ */
DFBResult (*GetProcAddress) ( DFBResult (*GetProcAddress) (
IDirectFBGL *thiz, IDirectFBGL *thiz,
const char *name, const char *name,
void **ret_address void **ret_address
); );
/*
* Set a surface to be used by the current texture object.
*/
DFBResult (*TextureSurface) (
IDirectFBGL *thiz,
int target,
int level,
IDirectFBSurface *surface
);
) )
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
 End of changes. 1 change blocks. 
0 lines changed or deleted 10 lines changed or added


 fusion_internal.h   fusion_internal.h 
skipping to change at line 183 skipping to change at line 183
} }
# endif # endif
#endif #endif
#if FUSION_BUILD_MULTI #if FUSION_BUILD_MULTI
/* /*
* from call.c * from call.c
*/ */
void _fusion_call_process( FusionWorld *world, void _fusion_call_process( FusionWorld *world,
int call_id, int call_id,
FusionCallMessage *call ); FusionCallMessage *call,
void *ptr );
void _fusion_call_process3( FusionWorld *world, void _fusion_call_process3( FusionWorld *world,
int call_id, int call_id,
FusionCallMessage3 *msg, FusionCallMessage3 *msg,
void *ptr ); void *ptr );
#if FUSION_BUILD_KERNEL #if FUSION_BUILD_KERNEL
/* /*
* from shm.c * from shm.c
*/ */
void _fusion_shmpool_process( FusionWorld *world, void _fusion_shmpool_process( FusionWorld *world,
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 generic.h   generic.h 
skipping to change at line 248 skipping to change at line 248
} }
/************************************************************************** ********************************************/ /************************************************************************** ********************************************/
typedef void (*XopAdvanceFunc)( GenefxState *gfxs ); typedef void (*XopAdvanceFunc)( GenefxState *gfxs );
void Genefx_Aop_xy( GenefxState *gfxs, int x, int y ); void Genefx_Aop_xy( GenefxState *gfxs, int x, int y );
void Genefx_Aop_crab( GenefxState *gfxs ); void Genefx_Aop_crab( GenefxState *gfxs );
void Genefx_Aop_prev_crab( GenefxState *gfxs );
void Genefx_Aop_next( GenefxState *gfxs ); void Genefx_Aop_next( GenefxState *gfxs );
void Genefx_Aop_prev( GenefxState *gfxs ); void Genefx_Aop_prev( GenefxState *gfxs );
void Genefx_Bop_xy( GenefxState *gfxs, int x, int y ); void Genefx_Bop_xy( GenefxState *gfxs, int x, int y );
void Genefx_Bop_next( GenefxState *gfxs ); void Genefx_Bop_next( GenefxState *gfxs );
void Genefx_Bop_prev( GenefxState *gfxs ); void Genefx_Bop_prev( GenefxState *gfxs );
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 gfxcard.h   gfxcard.h 
/* /*
(c) Copyright 2001-2009 The world wide DirectFB Open Source Community ( directfb.org) (c) Copyright 2001-2011 The world wide DirectFB Open Source Community ( directfb.org)
(c) Copyright 2000-2004 Convergence (integrated media) GmbH (c) Copyright 2000-2004 Convergence (integrated media) GmbH
All rights reserved. All rights reserved.
Written by Denis Oliver Kropp <dok@directfb.org>, Written by Denis Oliver Kropp <dok@directfb.org>,
Andreas Hundt <andi@fischlustig.de>, Andreas Hundt <andi@fischlustig.de>,
Sven Neumann <neo@directfb.org>, Sven Neumann <neo@directfb.org>,
Ville Syrjälä <syrjala@sci.fi> and Ville Syrjälä <syrjala@sci.fi> and
Claudio Ciccani <klan@users.sf.net>. Claudio Ciccani <klan@users.sf.net>.
skipping to change at line 48 skipping to change at line 48
#include <fusion/property.h> #include <fusion/property.h>
#include <core/coretypes.h> #include <core/coretypes.h>
#include <directfb.h> #include <directfb.h>
typedef enum { typedef enum {
CCF_CLIPPING = 0x00000001, CCF_CLIPPING = 0x00000001,
CCF_NOTRIEMU = 0x00000002, CCF_NOTRIEMU = 0x00000002,
CCF_READSYSMEM = 0x00000004, CCF_READSYSMEM = 0x00000004,
/* CCF_WRITESYSMEM ?! */ CCF_WRITESYSMEM= 0x00000008,
CCF_AUXMEMORY = 0x00000010, CCF_AUXMEMORY = 0x00000010,
CCF_RENDEROPTS = 0x00000020 CCF_RENDEROPTS = 0x00000020
} CardCapabilitiesFlags; } CardCapabilitiesFlags;
struct __DFB_CoreGraphicsSerial { struct __DFB_CoreGraphicsSerial {
unsigned int serial; unsigned int serial;
unsigned int generation; unsigned int generation;
}; };
typedef struct { typedef struct {
skipping to change at line 313 skipping to change at line 313
GDLF_NONE = 0x00000000, GDLF_NONE = 0x00000000,
GDLF_WAIT = 0x00000001, GDLF_WAIT = 0x00000001,
GDLF_SYNC = 0x00000002, GDLF_SYNC = 0x00000002,
GDLF_INVALIDATE = 0x00000004, GDLF_INVALIDATE = 0x00000004,
GDLF_RESET = 0x00000008 GDLF_RESET = 0x00000008
} GraphicsDeviceLockFlags; } GraphicsDeviceLockFlags;
DFBResult dfb_gfxcard_lock( GraphicsDeviceLockFlags flags ); DFBResult dfb_gfxcard_lock( GraphicsDeviceLockFlags flags );
void dfb_gfxcard_unlock( void ); void dfb_gfxcard_unlock( void );
void dfb_gfxcard_holdup( void );
bool dfb_gfxcard_state_check( CardState *state, DFBAccelerationMask accel ) ; bool dfb_gfxcard_state_check( CardState *state, DFBAccelerationMask accel ) ;
/* /*
* Signal beginning of a sequence of operations using this state. * Signal beginning of a sequence of operations using this state.
* Any number of states can be 'drawing'. * Any number of states can be 'drawing'.
*/ */
void dfb_gfxcard_start_drawing( CoreGraphicsDevice *device, void dfb_gfxcard_start_drawing( CoreGraphicsDevice *device,
CardState *state ); CardState *state );
skipping to change at line 499 skipping to change at line 498
unsigned int videoram_length; unsigned int videoram_length;
unsigned int auxram_length; unsigned int auxram_length;
unsigned int auxram_offset; unsigned int auxram_offset;
char *module_name; char *module_name;
GraphicsDriverInfo driver_info; GraphicsDriverInfo driver_info;
GraphicsDeviceInfo device_info; GraphicsDeviceInfo device_info;
void *device_data; void *device_data;
FusionProperty lock; FusionSkirmish lock;
GraphicsDeviceLockFlags lock_flags; GraphicsDeviceLockFlags lock_flags;
/* /*
* Points to the current state of the graphics card. * Points to the current state of the graphics card.
*/ */
CardState *state; CardState *state;
FusionID holder; /* Fusion ID of state owner. */ FusionID holder; /* Fusion ID of state owner. */
} DFBGraphicsCoreShared; } DFBGraphicsCoreShared;
struct __DFB_DFBGraphicsCore { struct __DFB_DFBGraphicsCore {
 End of changes. 4 change blocks. 
4 lines changed or deleted 3 lines changed or added


 idirectfbdatabuffer.h   idirectfbdatabuffer.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 __IDIRECTFBDATABUFFER_H__ #ifndef __IDIRECTFBDATABUFFER_H__
#define __IDIRECTFBDATABUFFER_H__ #define __IDIRECTFBDATABUFFER_H__
#include <core/core.h> #include <core/core.h>
#include <fusion/call.h>
/* /*
* private data struct of IDirectFBDataBuffer * private data struct of IDirectFBDataBuffer
*/ */
typedef struct { typedef struct {
int ref; /* reference counter */ int ref; /* reference counter */
char *filename; /* Only set if databuffer is created from fil e. */ char *filename; /* Only set if databuffer is created from fil e. */
CoreDFB *core; CoreDFB *core;
bool is_memory; bool is_memory;
FusionCall call; /* for remote access */
} IDirectFBDataBuffer_data; } IDirectFBDataBuffer_data;
/* /*
* private data struct of IDirectFBDataBuffer_File * private data struct of IDirectFBDataBuffer_File
*/ */
typedef struct { typedef struct {
IDirectFBDataBuffer_data base; IDirectFBDataBuffer_data base;
DirectStream *stream; DirectStream *stream;
pthread_mutex_t mutex; pthread_mutex_t mutex;
 End of changes. 2 change blocks. 
0 lines changed or deleted 4 lines changed or added


 idirectfbsurface.h   idirectfbsurface.h 
skipping to change at line 38 skipping to change at line 38
#ifndef __IDIRECTFBSURFACE_H__ #ifndef __IDIRECTFBSURFACE_H__
#define __IDIRECTFBSURFACE_H__ #define __IDIRECTFBSURFACE_H__
#include <directfb.h> #include <directfb.h>
#include <direct/types.h> #include <direct/types.h>
#include <fusion/reactor.h> #include <fusion/reactor.h>
#include <core/core.h>
#include <core/state.h> #include <core/state.h>
#include <core/CoreGraphicsStateClient.h> #include <core/CoreGraphicsStateClient.h>
/* /*
* private data struct of IDirectFBSurface * private data struct of IDirectFBSurface
*/ */
typedef struct { typedef struct {
DirectLink link; DirectLink link;
skipping to change at line 135 skipping to change at line 136
Reaction reaction; Reaction reaction;
CoreDFB *core; CoreDFB *core;
IDirectFBSurface *parent; IDirectFBSurface *parent;
DirectLink *children_data; DirectLink *children_data;
pthread_mutex_t children_lock; pthread_mutex_t children_lock;
CoreGraphicsStateClient state_client; CoreGraphicsStateClient state_client;
CoreMemoryPermission *memory_permissions[3];
unsigned int memory_permissions_count;
} IDirectFBSurface_data; } IDirectFBSurface_data;
/* /*
* initializes interface struct and private data * initializes interface struct and private data
*/ */
DFBResult IDirectFBSurface_Construct( IDirectFBSurface *thiz, DFBResult IDirectFBSurface_Construct( IDirectFBSurface *thiz,
IDirectFBSurface *parent, IDirectFBSurface *parent,
DFBRectangle *req_rect, DFBRectangle *req_rect,
DFBRectangle *clip_rect, DFBRectangle *clip_rect,
DFBInsets *insets, DFBInsets *insets,
 End of changes. 2 change blocks. 
0 lines changed or deleted 4 lines changed or added


 idirectfbwindow.h   idirectfbwindow.h 
skipping to change at line 42 skipping to change at line 42
#include <directfb.h> #include <directfb.h>
#include <core/coretypes.h> #include <core/coretypes.h>
/* /*
* initializes a new window and constructs interface * initializes a new window and constructs interface
*/ */
DFBResult IDirectFBWindow_Construct( IDirectFBWindow *thiz, DFBResult IDirectFBWindow_Construct( IDirectFBWindow *thiz,
CoreWindow *window, CoreWindow *window,
CoreLayer *layer, CoreLayer *layer,
CoreDFB *core ); CoreDFB *core,
bool created );
#endif #endif
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 input.h   input.h 
skipping to change at line 171 skipping to change at line 171
DFBResult dfb_input_device_set_keymap_entry( CoreInputDevice *device, DFBResult dfb_input_device_set_keymap_entry( CoreInputDevice *device,
int keycode, int keycode,
const DFBInputDeviceKe ymapEntry *entry ); const DFBInputDeviceKe 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 );
typedef struct {
DFBInputDeviceModifierMask modifiers_l;
DFBInputDeviceModifierMask modifiers_r;
DFBInputDeviceLockState locks;
DFBInputDeviceButtonMask buttons;
} CoreInputDeviceState;
DFBResult dfb_input_device_get_state( CoreInputDevice *device,
CoreInputDeviceState *ret_sta
te );
void containers_attach_device( CoreInputDevice *device ); void containers_attach_device( CoreInputDevice *device );
void containers_detach_device( CoreInputDevice *device ); void containers_detach_device( CoreInputDevice *device );
void stack_containers_attach_device( CoreInputDevice *device ) ; void stack_containers_attach_device( CoreInputDevice *device ) ;
void stack_containers_detach_device( CoreInputDevice *device ) ; void stack_containers_detach_device( CoreInputDevice *device ) ;
DFBResult dfb_input_create_device( int device_index, DFBResult dfb_input_create_device( int device_index,
CoreDFB *core_in, CoreDFB *core_in,
 End of changes. 1 change blocks. 
0 lines changed or deleted 11 lines changed or added


 input_driver.h   input_driver.h 
skipping to change at line 101 skipping to change at line 101
static DFBResult static DFBResult
driver_resume( void ) driver_resume( void )
{ {
return DFB_UNSUPPORTED; return DFB_UNSUPPORTED;
} }
static DFBResult static DFBResult
is_created( int event_num, void *data) is_created( int event_num, void *data)
{ {
D_UNUSED_P( event_num );
D_UNUSED_P( data );
return DFB_UNSUPPORTED; return DFB_UNSUPPORTED;
} }
static InputDriverCapability static InputDriverCapability
get_capability( void ) get_capability( void )
{ {
return IDC_NONE; return IDC_NONE;
} }
static DFBResult static DFBResult
launch_hotplug(CoreDFB *core, launch_hotplug(CoreDFB *core,
void *input_driver) void *input_driver)
{ {
D_UNUSED_P( core );
D_UNUSED_P( input_driver );
return DFB_UNSUPPORTED; return DFB_UNSUPPORTED;
} }
static DFBResult static DFBResult
stop_hotplug( void ) stop_hotplug( void )
{ {
return DFB_UNSUPPORTED; return DFB_UNSUPPORTED;
} }
#endif #endif
 End of changes. 2 change blocks. 
0 lines changed or deleted 6 lines changed or added


 interface.h   interface.h 
skipping to change at line 44 skipping to change at line 44
/* /*
* Forward declaration macro for interfaces. * Forward declaration macro for interfaces.
*/ */
#define DECLARE_INTERFACE( IFACE ) \ #define DECLARE_INTERFACE( IFACE ) \
typedef struct _##IFACE IFACE; typedef struct _##IFACE IFACE;
/* /*
* Macro for an interface definition. * Macro for an interface definition.
*/ */
#define DEFINE_INTERFACE( IFACE, IDATA... ) \ #define DEFINE_INTERFACE( IFACE, ... ) \
struct _##IFACE { \ struct _##IFACE { \
void *priv; \ void *priv; \
int magic; \ int magic; \
\ \
DirectResult (*AddRef)( IFACE *thiz ); \ DirectResult (*AddRef)( IFACE *thiz ); \
DirectResult (*Release)( IFACE *thiz ); \ DirectResult (*Release)( IFACE *thiz ); \
\ \
IDATA \ __VA_ARGS__ \
}; };
/* /*
* Declare base interface * Declare base interface
*/ */
DECLARE_INTERFACE( IAny ) DECLARE_INTERFACE( IAny )
/* /*
* Define base interface * Define base interface
*/ */
skipping to change at line 153 skipping to change at line 153
#define DIRECT_DBG_INTERFACE_ADD direct_dbg_interface_add #define DIRECT_DBG_INTERFACE_ADD direct_dbg_interface_add
#define DIRECT_DBG_INTERFACE_REMOVE direct_dbg_interface_remove #define DIRECT_DBG_INTERFACE_REMOVE direct_dbg_interface_remove
#else #else
#define DIRECT_DBG_INTERFACE_ADD(func,file,line,what,interface,name) do {} while (0) #define DIRECT_DBG_INTERFACE_ADD(func,file,line,what,interface,name) do {} while (0)
#define DIRECT_DBG_INTERFACE_REMOVE(func,file,line,what,interface) do {} while (0) #define DIRECT_DBG_INTERFACE_REMOVE(func,file,line,what,interface) do {} while (0)
#endif #endif
#define DIRECT_ALLOCATE_INTERFACE(p,i) #define DIRECT_ALLOCATE_INTERFACE(p,i)
\ \
do { do {
\ \
(p) = (__typeof__(p))D_CALLOC( 1, sizeof(i) ); (p) = (__typeof__(p))D_CALLOC( 1, sizeof(i) );
\ \
if (p) {
\ \
D_MAGIC_SET( (IAny*)(p), DirectInterface ); D_MAGIC_SET( (IAny*)(p), DirectInterface );
\ \
\ \
DIRECT_DBG_INTERFACE_ADD( __FUNCTION__, __FILE__, __LINE__, #p, p DIRECT_DBG_INTERFACE_ADD( __FUNCTION__, __FILE__, __LINE__,
, #i ); \ #p, p, #i ); \
}
\
else
\
D_OOM();
\
} while (0) } while (0)
#define DIRECT_ALLOCATE_INTERFACE_DATA(p,i) \ #define DIRECT_ALLOCATE_INTERFACE_DATA(p,i) \
i##_data *data; \ i##_data *data; \
\ \
D_MAGIC_ASSERT( (IAny*)(p), DirectInterface ); \ D_MAGIC_ASSERT( (IAny*)(p), DirectInterface ); \
\ \
if (!(p)->priv) \ if (!(p)->priv) \
(p)->priv = D_CALLOC( 1, sizeof(i##_data) ); \ (p)->priv = D_CALLOC( 1, sizeof(i##_data) ); \
\ \
 End of changes. 3 change blocks. 
16 lines changed or deleted 22 lines changed or added


 layer_context.h   layer_context.h 
skipping to change at line 58 skipping to change at line 58
* Creates a pool of layer context objects. * Creates a pool of layer context objects.
*/ */
FusionObjectPool *dfb_layer_context_pool_create( const FusionWorld *world ) ; FusionObjectPool *dfb_layer_context_pool_create( const FusionWorld *world ) ;
/* /*
* Generates dfb_layer_context_ref(), dfb_layer_context_attach() etc. * Generates dfb_layer_context_ref(), dfb_layer_context_attach() etc.
*/ */
FUSION_OBJECT_METHODS( CoreLayerContext, dfb_layer_context ) FUSION_OBJECT_METHODS( CoreLayerContext, dfb_layer_context )
DFBResult dfb_layer_context_init( CoreLayerContext *context, DFBResult dfb_layer_context_init( CoreLayerContext *context,
CoreLayer *layer ); CoreLayer *layer,
bool stack );
/* /*
* Locking * Locking
*/ */
DirectResult dfb_layer_context_lock ( CoreLayerContext *context ); DirectResult dfb_layer_context_lock ( CoreLayerContext *context );
DirectResult dfb_layer_context_unlock( CoreLayerContext *context ); DirectResult dfb_layer_context_unlock( CoreLayerContext *context );
CoreWindowStack *dfb_layer_context_windowstack( const CoreLayerContext *con text ); CoreWindowStack *dfb_layer_context_windowstack( const CoreLayerContext *con text );
bool dfb_layer_context_active ( const CoreLayerContext *con text ); bool dfb_layer_context_active ( const CoreLayerContext *con text );
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 layer_control.h   layer_control.h 
skipping to change at line 37 skipping to change at line 37
*/ */
#ifndef __CORE__LAYER_CONTROL_H__ #ifndef __CORE__LAYER_CONTROL_H__
#define __CORE__LAYER_CONTROL_H__ #define __CORE__LAYER_CONTROL_H__
#include <directfb.h> #include <directfb.h>
#include <core/coretypes.h> #include <core/coretypes.h>
DFBResult dfb_layer_create_context ( CoreLayer *layer, DFBResult dfb_layer_create_context ( CoreLayer *layer,
bool stack,
CoreLayerContext **ret_conte xt ); CoreLayerContext **ret_conte xt );
DFBResult dfb_layer_get_active_context ( CoreLayer *layer, DFBResult dfb_layer_get_active_context ( CoreLayer *layer,
CoreLayerContext **ret_conte xt ); CoreLayerContext **ret_conte xt );
DFBResult dfb_layer_get_primary_context ( CoreLayer *layer, DFBResult dfb_layer_get_primary_context ( CoreLayer *layer,
bool activate, bool activate,
CoreLayerContext **ret_conte xt ); CoreLayerContext **ret_conte xt );
DFBResult dfb_layer_activate_context ( CoreLayer *layer, DFBResult dfb_layer_activate_context ( CoreLayer *layer,
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 layers.h   layers.h 
skipping to change at line 65 skipping to change at line 65
DFBColorKey src_key; /* source color key */ DFBColorKey src_key; /* source color key */
DFBColorKey dst_key; /* destination color key */ DFBColorKey dst_key; /* destination color key */
int parity; /* field parity (for inte rlaced) */ int parity; /* field parity (for inte rlaced) */
u8 alpha_ramp[4]; /* alpha values for 1 or 2 bit lookup */ u8 alpha_ramp[4]; /* alpha values for 1 or 2 bit lookup */
DFBRegion *clips; /* clip regions */ DFBRegion *clips; /* clip regions */
int num_clips; /* number of clip regions */ int num_clips; /* number of clip regions */
DFBBoolean positive; /* show or cut out region s */ DFBBoolean positive; /* show or cut out region s */
bool keep_buffers;
}; };
#if D_DEBUG_ENABLED #if D_DEBUG_ENABLED
#define DFB_CORE_LAYER_REGION_CONFIG_DEBUG_AT( domain, config ) \ #define DFB_CORE_LAYER_REGION_CONFIG_DEBUG_AT( domain, config ) \
do { \ do { \
const CoreLayerRegionConfig *_config = config; \ const CoreLayerRegionConfig *_config = config; \
\ \
D_DEBUG_AT( domain, " -> size %dx%d\n", _config->width, _c onfig->height ); \ D_DEBUG_AT( domain, " -> size %dx%d\n", _config->width, _c onfig->height ); \
D_DEBUG_AT( domain, " -> format %s\n", dfb_pixelformat_name( _config->format ) ); \ D_DEBUG_AT( domain, " -> format %s\n", dfb_pixelformat_name( _config->format ) ); \
D_DEBUG_AT( domain, " -> surf caps 0x%08x\n", _config->surface_ caps ); \ D_DEBUG_AT( domain, " -> surf caps 0x%08x\n", _config->surface_ caps ); \
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 lock.h   lock.h 
skipping to change at line 46 skipping to change at line 46
#include <direct/messages.h> #include <direct/messages.h>
#include <direct/util.h> #include <direct/util.h>
typedef struct { typedef struct {
pthread_mutex_t lock; pthread_mutex_t lock;
pthread_cond_t cond; pthread_cond_t cond;
int count; int count;
char *name; char *name;
} FusionSkirmishSingle; } FusionSkirmishSingle;
typedef union { typedef struct {
/* multi app */ /* multi app */
struct { struct {
int id; int id;
const FusionWorldShared *shared; const FusionWorldShared *shared;
/* builtin impl */ /* builtin impl */
struct { struct {
unsigned int locked; unsigned int locked;
pid_t owner; pid_t owner;
DirectLink *waiting; DirectLink *waiting;
bool requested; bool requested;
skipping to change at line 73 skipping to change at line 73
} FusionSkirmish; } FusionSkirmish;
/* /*
* Initialize. * Initialize.
*/ */
DirectResult fusion_skirmish_init ( FusionSkirmish *skirmish, DirectResult fusion_skirmish_init ( FusionSkirmish *skirmish,
const char *name, const char *name,
const FusionWorld *world ); const FusionWorld *world );
DirectResult fusion_skirmish_init2 ( FusionSkirmish *skirmish,
const char *name,
const FusionWorld *world,
bool local );
/* /*
* Lock. * Lock.
*/ */
DirectResult fusion_skirmish_prevail( FusionSkirmish *skirmish ); DirectResult fusion_skirmish_prevail( FusionSkirmish *skirmish );
/* /*
* Try lock. * Try lock.
*/ */
DirectResult fusion_skirmish_swoop ( FusionSkirmish *skirmish ); DirectResult fusion_skirmish_swoop ( FusionSkirmish *skirmish );
skipping to change at line 123 skipping to change at line 128
\ \
D_ASSERT( fusion_skirmish_lock_count( skirmish, &lock_count ) == DR_OK ); \ D_ASSERT( fusion_skirmish_lock_count( skirmish, &lock_count ) == DR_OK ); \
D_ASSERT( lock_count > 0 ); \ D_ASSERT( lock_count > 0 ); \
} while (0) } while (0)
#else #else
#define FUSION_SKIRMISH_ASSERT(skirmish) \ #define FUSION_SKIRMISH_ASSERT(skirmish) \
do { \ do { \
} while (0) } while (0)
#endif #endif
typedef enum {
FUSION_SKIRMISH_PERMIT_NONE = 0x00000000,
FUSION_SKIRMISH_PERMIT_PREVAIL = 0x00000001,
FUSION_SKIRMISH_PERMIT_SWOOP = 0x00000002,
FUSION_SKIRMISH_PERMIT_DISMISS = 0x00000004,
FUSION_SKIRMISH_PERMIT_LOCK_COUNT = 0x00000008,
FUSION_SKIRMISH_PERMIT_WAIT = 0x00000010,
FUSION_SKIRMISH_PERMIT_NOTIFY = 0x00000020,
FUSION_SKIRMISH_PERMIT_DESTROY = 0x00000040,
FUSION_SKIRMISH_PERMIT_ALL = 0x0000007F,
} FusionSkirmishPermissions;
/*
* Give permissions to another fusionee to use the skirmish.
*/
DirectResult fusion_skirmish_add_permissions( FusionSkirmish *sk
imrish,
FusionID fu
sion_id,
FusionSkirmishPermissions pe
rmissions );
#endif #endif
 End of changes. 3 change blocks. 
1 lines changed or deleted 30 lines changed or added


 messages.h   messages.h 
skipping to change at line 93 skipping to change at line 93
void direct_messages_bug ( const char *func, void direct_messages_bug ( const char *func,
const char *file, const char *file,
int line, int line,
const char *format, ... ) D_FORMAT_PRI NTF(4); const char *format, ... ) D_FORMAT_PRI NTF(4);
void direct_messages_warn ( const char *func, void direct_messages_warn ( const char *func,
const char *file, const char *file,
int line, int line,
const char *format, ... ) D_FORMAT_PRI NTF(4); const char *format, ... ) D_FORMAT_PRI NTF(4);
#define D_INFO(x...) do { \ #define D_INFO(...) do { \
if (!(direct_config->quiet & DMT_INFO)) \ if (!(direct_config->quiet & DMT_INFO)) \
direct_messages_info( x ); \ direct_messages_info( __VA_ARGS__ ); \
} while (0) } while (0)
#define D_ERROR(x...) do { \ #define D_ERROR(...) do { \
if (!(direct_config->quiet & DMT_ERROR)) \ if (!(direct_config->quiet & DMT_ERROR)) \
direct_messages_error( x ); \ direct_messages_error( __VA_ARGS__ ); \
} while (0) } while (0)
#define D_DERROR(r,x...) do { \ #define D_DERROR(r,...) do { \
if (!(direct_config->quiet & DMT_ERROR)) \ if (!(direct_config->quiet & DMT_ERROR)) \
direct_messages_derror( (DirectResult) r , x ); \ direct_messages_derror( (DirectResult)(r) , __VA_ARGS__ ); \
} while (0) } while (0)
#define D_PERROR(x...) do { \ #define D_PERROR(...) do { \
if (!(direct_config->quiet & DMT_ERROR)) \ if (!(direct_config->quiet & DMT_ERROR)) \
direct_messages_perror( errno, x ); \ direct_messages_perror( errno, __VA_ARGS __ ); \
} while (0) } while (0)
#define D_DLERROR(x...) do { \ #define D_DLERROR(...) do { \
if (!(direct_config->quiet & DMT_ERROR)) \ if (!(direct_config->quiet & DMT_ERROR)) \
direct_messages_dlerror( dlerror(), x ); \ direct_messages_dlerror( dlerror(), __VA _ARGS__ ); \
} while (0) } while (0)
#define D_ONCE(x...) do { \ #define D_ONCE(...) do { \
if (!(direct_config->quiet & DMT_ONCE)) { \ if (!(direct_config->quiet & DMT_ONCE)) { \
static bool first = true; \ static bool first = true; \
if (first) { \ if (first) { \
direct_messages_once( __FUNCTION__, \ direct_messages_once( __FUNCTION__, \
__FILE__, __L __FILE__, __L
INE__, x ); \ INE__, \
__VA_ARGS__
); \
first = false; \ first = false; \
} \ } \
} \ } \
} while (0) } while (0)
#define D_UNIMPLEMENTED() do { \ #define D_UNIMPLEMENTED() do { \
if (!(direct_config->quiet & DMT_UNIMPLEMENTE D)) { \ if (!(direct_config->quiet & DMT_UNIMPLEMENTE D)) { \
static bool first = true; \ static bool first = true; \
if (first) { \ if (first) { \
direct_messages_unimplemented( __FU NCTION__, \ direct_messages_unimplemented( __FU NCTION__, \
__FI LE__, __LINE__ ); \ __FI LE__, __LINE__ ); \
first = false; \ first = false; \
} \ } \
} \ } \
} while (0) } while (0)
#define D_BUG(x...) do { \ #define D_BUG(...) do { \
if (!(direct_config->quiet & DMT_ERROR)) \ if (!(direct_config->quiet & DMT_ERROR)) \
direct_messages_bug( __FUNCTION__, __FIL direct_messages_bug( __FUNCTION__, __FIL
E__, __LINE__, x ); \ E__, \
__LINE__, __VA_ARGS
__ ); \
} while (0) } while (0)
#define D_WARN(x...) do { \ #define D_WARN(...) do { \
if (!(direct_config->quiet & DMT_WARNING)) \ if (!(direct_config->quiet & DMT_WARNING)) \
direct_messages_warn( __FUNCTION__, __FI direct_messages_warn( __FUNCTION__, __FI
LE__, __LINE__, x );\ LE__, \
__LINE__, __VA_ARG
S__ ); \
} while (0) } while (0)
#define D_OOM() (direct_messages_warn( __FUNCTION__, __FILE__, __L INE__, \ #define D_OOM() (direct_messages_warn( __FUNCTION__, __FILE__, __L INE__, \
"out of memory" ), DR_NOLOC ALMEMORY) "out of memory" ), DR_NOLOC ALMEMORY)
#else #else
#define D_INFO(x...) do { } while (0) #define D_INFO(...) do { } while (0)
#define D_ERROR(x...) do { } while (0) #define D_ERROR(...) do { } while (0)
#define D_DERROR(x...) do { } while (0) #define D_DERROR(...) do { } while (0)
#define D_PERROR(x...) do { } while (0) #define D_PERROR(...) do { } while (0)
#define D_DLERROR(x...) do { } while (0) #define D_DLERROR(...) do { } while (0)
#define D_ONCE(x...) do { } while (0) #define D_ONCE(...) do { } while (0)
#define D_UNIMPLEMENTED() do { } while (0) #define D_UNIMPLEMENTED() do { } while (0)
#define D_BUG(x...) do { } while (0) #define D_BUG(...) do { } while (0)
#define D_WARN(x...) do { } while (0) #define D_WARN(...) do { } while (0)
#define D_OOM() (printf("out of memory\n"), DR_NOLOCALME MORY) #define D_OOM() (printf("out of memory\n"), DR_NOLOCALME MORY)
#endif #endif
#endif #endif
 End of changes. 18 change blocks. 
27 lines changed or deleted 33 lines changed or added


 state.h   state.h 
skipping to change at line 335 skipping to change at line 335
} }
} }
static inline void dfb_state_set_colorkey( CardState *state, const DFBColor Key *key ) static inline void dfb_state_set_colorkey( CardState *state, const DFBColor Key *key )
{ {
D_MAGIC_ASSERT( state, CardState ); D_MAGIC_ASSERT( state, CardState );
D_ASSERT( key != NULL ); D_ASSERT( key != NULL );
if (! DFB_COLORKEY_EQUAL( state->colorkey, *key )) { if (! DFB_COLORKEY_EQUAL( state->colorkey, *key )) {
state->colorkey = *key; state->colorkey = *key;
state->modified = (StateModificationFlags)( state->modified | SMF _COLOR ); state->modified = (StateModificationFlags)( state->modified | SMF _COLORKEY );
} }
} }
static inline void dfb_state_set_source_mask_vals( CardState *sta te, static inline void dfb_state_set_source_mask_vals( CardState *sta te,
const DFBPoint *off set, const DFBPoint *off set,
DFBSurfaceMaskFlags fla gs ) DFBSurfaceMaskFlags fla gs )
{ {
D_MAGIC_ASSERT( state, CardState ); D_MAGIC_ASSERT( state, CardState );
D_ASSERT( offset != NULL ); D_ASSERT( offset != NULL );
D_FLAGS_ASSERT( flags, DSMF_ALL ); D_FLAGS_ASSERT( flags, DSMF_ALL );
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 surface.h   surface.h 
skipping to change at line 106 skipping to change at line 106
} CoreSurfaceTypeFlags; } CoreSurfaceTypeFlags;
typedef struct { typedef struct {
CoreSurfaceConfigFlags flags; CoreSurfaceConfigFlags flags;
DFBDimension size; DFBDimension size;
DFBSurfacePixelFormat format; DFBSurfacePixelFormat format;
DFBSurfaceCapabilities caps; DFBSurfaceCapabilities caps;
struct { struct {
void *addr; void *addr; /* " */
int pitch; unsigned long phys; /* " */
unsigned long offset; /* " */
unsigned int pitch; /* " */
void *handle; /* " */
} preallocated[MAX_SURFACE_BUFFERS]; } preallocated[MAX_SURFACE_BUFFERS];
CoreSurfacePoolID preallocated_pool_id;
DFBDimension min_size; DFBDimension min_size;
} CoreSurfaceConfig; } CoreSurfaceConfig;
typedef enum { typedef enum {
CSP_SYSTEMONLY = 0x00000000, /* never try to swap CSP_SYSTEMONLY = 0x00000000, /* never try to swap
into video memory */ into video memory */
CSP_VIDEOLOW = 0x00000001, /* try to store in video memory, CSP_VIDEOLOW = 0x00000001, /* try to store in video memory,
low priority */ low priority */
CSP_VIDEOHIGH = 0x00000002, /* try to store in video memory, CSP_VIDEOHIGH = 0x00000002, /* try to store in video memory,
high priority */ high priority */
skipping to change at line 224 skipping to change at line 230
CorePalette *palette; CorePalette *palette;
GlobalReaction palette_reaction; GlobalReaction palette_reaction;
FusionSHMPoolShared *shmpool; FusionSHMPoolShared *shmpool;
void *data; /* Shared system driver-specifi c data for this surface. */ void *data; /* Shared system driver-specifi c data for this surface. */
FusionCall call; FusionCall call;
}; };
#define CORE_SURFACE_ASSERT(surface)
\
do {
\
D_MAGIC_ASSERT( surface, CoreSurface );
\
} while (0)
/* /*
* Creates a pool of surface objects. * Creates a pool of surface objects.
*/ */
FusionObjectPool *dfb_surface_pool_create( const FusionWorld *world ); FusionObjectPool *dfb_surface_pool_create( const FusionWorld *world );
/* /*
* Generates dfb_surface_ref(), dfb_surface_attach() etc. * Generates dfb_surface_ref(), dfb_surface_attach() etc.
*/ */
FUSION_OBJECT_METHODS( CoreSurface, dfb_surface ) FUSION_OBJECT_METHODS( CoreSurface, dfb_surface )
skipping to change at line 268 skipping to change at line 279
CoreSurfaceBuffer *buffer) ; CoreSurfaceBuffer *buffer) ;
DFBResult dfb_surface_flip ( CoreSurface *surface , DFBResult dfb_surface_flip ( CoreSurface *surface ,
bool swap ); bool swap );
DFBResult dfb_surface_reconfig ( CoreSurface *surface , DFBResult dfb_surface_reconfig ( CoreSurface *surface ,
const CoreSurfaceConfig *config ); const CoreSurfaceConfig *config );
DFBResult dfb_surface_destroy_buffers( CoreSurface *surface ); DFBResult dfb_surface_destroy_buffers( CoreSurface *surface );
DFBResult dfb_surface_deallocate_buffers( CoreSurface *surface
);
DFBResult dfb_surface_lock_buffer ( CoreSurface *surface , DFBResult dfb_surface_lock_buffer ( CoreSurface *surface ,
CoreSurfaceBufferRole role, CoreSurfaceBufferRole role,
CoreSurfaceAccessorID accesso r, CoreSurfaceAccessorID accesso r,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
CoreSurfaceBufferLock *ret_loc k ); CoreSurfaceBufferLock *ret_loc k );
DFBResult dfb_surface_unlock_buffer ( CoreSurface *surface , DFBResult dfb_surface_unlock_buffer ( CoreSurface *surface ,
CoreSurfaceBufferLock *lock ); CoreSurfaceBufferLock *lock );
DFBResult dfb_surface_read_buffer ( CoreSurface *surface , DFBResult dfb_surface_read_buffer ( CoreSurface *surface ,
skipping to change at line 306 skipping to change at line 319
DFBResult dfb_surface_set_field ( CoreSurface *surface , DFBResult dfb_surface_set_field ( CoreSurface *surface ,
int field ) ; int field ) ;
DFBResult dfb_surface_set_alpha_ramp( CoreSurface *surface , DFBResult dfb_surface_set_alpha_ramp( CoreSurface *surface ,
u8 a0, u8 a0,
u8 a1, u8 a1,
u8 a2, u8 a2,
u8 a3 ); u8 a3 );
DFBResult dfb_surface_clear_buffers ( CoreSurface *surfac
e );
static inline DirectResult static inline DirectResult
dfb_surface_lock( CoreSurface *surface ) dfb_surface_lock( CoreSurface *surface )
{ {
D_MAGIC_ASSERT( surface, CoreSurface ); D_MAGIC_ASSERT( surface, CoreSurface );
return fusion_skirmish_prevail( &surface->lock ); return fusion_skirmish_prevail( &surface->lock );
} }
static inline DirectResult static inline DirectResult
dfb_surface_trylock( CoreSurface *surface ) dfb_surface_trylock( CoreSurface *surface )
 End of changes. 5 change blocks. 
2 lines changed or deleted 22 lines changed or added


 surface_buffer.h   surface_buffer.h 
skipping to change at line 38 skipping to change at line 38
#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/object.h>
#include <fusion/vector.h> #include <fusion/vector.h>
#include <core/surface.h> #include <core/surface.h>
#include <core/surface_allocation.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 {
CSBF_NONE = 0x00000000, /* None of these. */ CSBF_NONE = 0x00000000, /* None of these. */
CSBF_STICKED = 0x00000001, /* Sticked to one Surface Pool, e.g. sys tem only. */ CSBF_STICKED = 0x00000001, /* Sticked to one Surface Pool, e.g. sys tem only. */
CSBF_ALL = 0x00000001 /* All of these. */ CSBF_ALL = 0x00000001 /* All of these. */
} CoreSurfaceBufferFlags; } CoreSurfaceBufferFlags;
/*
* Configuration and State flags of a Surface Buffer Allocation
*/
typedef enum {
CSALF_NONE = 0x00000000, /* None of these. */
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_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
other allocations to have enough
space for a new allocation to be made. */
CSALF_ALL = 0x00001007 /* All of these. */
} CoreSurfaceAllocationFlags;
typedef enum { typedef enum {
CSBNF_NONE = 0x00000000 CSBNF_NONE = 0x00000000
} CoreSurfaceBufferNotificationFlags; } CoreSurfaceBufferNotificationFlags;
typedef struct { typedef struct {
CoreSurfaceBufferNotificationFlags flags; CoreSurfaceBufferNotificationFlags flags;
} CoreSurfaceBufferNotification; } CoreSurfaceBufferNotification;
/* /*
* An Allocation of a Surface Buffer
*/
struct __DFB_CoreSurfaceAllocation {
int magic;
DirectSerial serial; /* Equals serial of buffe
r if content is up to date. */
CoreSurfaceBuffer *buffer; /* Surface Buffer owning
this allocation. */
CoreSurface *surface; /* Surface owning the Buf
fer of this allocation. */
CoreSurfacePool *pool; /* Surface Pool providing
the allocation. */
void *data; /* Pool's private data fo
r this allocation. */
int size; /* Amount of data used by
this allocation. */
unsigned long offset; /* Offset within address
range of pool if contiguous. */
CoreSurfaceAllocationFlags flags; /* Pool can return CSALF_
ONEFORALL upon allocation of first buffer. */
const CoreSurfaceAccessFlags *access; /* Possible acc
ess flags (pointer to pool description). */
CoreSurfaceAccessFlags accessed[_CSAID_NUM]; /* Access since
last synchronization. */
};
#define CORE_SURFACE_ALLOCATION_ASSERT(alloc)
\
do {
\
D_MAGIC_ASSERT( alloc, CoreSurfaceAllocation );
\
D_ASSUME( (alloc)->size > 0 );
\
D_ASSERT( (alloc)->size >= 0 );
\
D_ASSERT( (alloc)->offset + (alloc)->size <= ((alloc)->pool->desc
.size ?:~0UL) ); \
D_FLAGS_ASSERT( (alloc)->access[CSAID_CPU], CSAF_ALL );
\
D_FLAGS_ASSERT( (alloc)->access[CSAID_GPU], CSAF_ALL );
\
D_FLAGS_ASSERT( (alloc)->flags, CSALF_ALL );
\
D_FLAGS_ASSERT( (alloc)->accessed[CSAID_CPU], CSAF_ALL );
\
D_FLAGS_ASSERT( (alloc)->accessed[CSAID_GPU], CSAF_ALL );
\
} while (0)
/*
* A Lock on a Surface Buffer * A Lock on a Surface Buffer
*/ */
struct __DFB_CoreSurfaceBufferLock { struct __DFB_CoreSurfaceBufferLock {
int magic; /* Must be valid before c alling dfb_surface_pool_lock() */ int magic; /* Must be valid before c alling dfb_surface_pool_lock() */
CoreSurfaceAccessorID accessor; /* " */ CoreSurfaceAccessorID accessor; /* " */
CoreSurfaceAccessFlags access; /* " */ CoreSurfaceAccessFlags access; /* " */
CoreSurfaceBuffer *buffer; /* Set by dfb_surface_poo l_lock() */ CoreSurfaceBuffer *buffer; /* Set by dfb_surface_poo l_lock() */
CoreSurfaceAllocation *allocation; /* " */ CoreSurfaceAllocation *allocation; /* " */
skipping to change at line 170 skipping to change at line 121
lock->accessor = CSAID_NONE; lock->accessor = CSAID_NONE;
lock->access = CSAF_NONE; lock->access = CSAF_NONE;
D_MAGIC_CLEAR( lock ); D_MAGIC_CLEAR( lock );
} }
#define CORE_SURFACE_BUFFER_LOCK_ASSERT(lock) \ #define CORE_SURFACE_BUFFER_LOCK_ASSERT(lock) \
do { \ do { \
D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock ); \ D_MAGIC_ASSERT( lock, CoreSurfaceBufferLock ); \
D_FLAGS_ASSERT( (lock)->access, CSAF_ALL ); \ D_FLAGS_ASSERT( (lock)->access, CSAF_ALL ); \
if ((lock)->buffer) { if ((lock)->allocation) {
\ \
D_ASSERT( (lock)->allocation != NULL ); /*D_ASSERT( (lock)->buffer == (lock)->allocation->buffer );*
\ / \
D_ASSERT( (lock)->buffer == (lock)->allocation->buffer );
\
D_ASSUME( (lock)->addr != NULL || (lock)->phys != 0 || (lock )->offset != ~0 || (lock)->handle != NULL );\ D_ASSUME( (lock)->addr != NULL || (lock)->phys != 0 || (lock )->offset != ~0 || (lock)->handle != NULL );\
D_ASSUME( (lock)->offset == (lock)->allocation->offset || (l ock)->offset == ~0 ); \ D_ASSUME( (lock)->offset == (lock)->allocation->offset || (l ock)->offset == ~0 ); \
D_ASSERT( (lock)->pitch > 0 || ((lock)->addr == NULL && (loc k)->phys == 0) ); \ D_ASSERT( (lock)->pitch > 0 || ((lock)->addr == NULL && (loc k)->phys == 0) ); \
} \ } \
else { \ else { \
D_ASSERT( (lock)->allocation == NULL ); \ D_ASSERT( (lock)->buffer == NULL ); \
D_ASSERT( (lock)->addr == NULL ); \ D_ASSERT( (lock)->addr == NULL ); \
D_ASSERT( (lock)->phys == 0 ); \ D_ASSERT( (lock)->phys == 0 ); \
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
skipping to change at line 212 skipping to change at line 162
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. */
CoreSurfaceConfig config; /* Configuration of its surfac e at the time of the buffer creation */ CoreSurfaceConfig config; /* Configuration of its surfac e at the time of the buffer creation */
CoreSurfaceTypeFlags type; CoreSurfaceTypeFlags type;
unsigned long resource_id; /* layer id, window id, or use r specified */ unsigned long resource_id; /* layer id, window id, or use r specified */
}; };
#define CORE_SURFACE_BUFFER_ASSERT(buffer)
\
do {
\
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
\
} while (0)
DFBResult dfb_surface_buffer_create ( CoreDFB *core, DFBResult dfb_surface_buffer_create ( CoreDFB *core,
CoreSurface *surface, CoreSurface *surface,
CoreSurfaceBufferFlags flags, CoreSurfaceBufferFlags flags,
CoreSurfaceBuffer **ret_buffer ) ; CoreSurfaceBuffer **ret_buffer ) ;
DFBResult dfb_surface_buffer_decouple( CoreSurfaceBuffer *buffer ); DFBResult dfb_surface_buffer_decouple( CoreSurfaceBuffer *buffer );
DFBResult dfb_surface_buffer_deallocate( 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,
int pitch, int pitch,
skipping to change at line 267 skipping to change at line 224
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 FUSION_OBJECT_METHODS( CoreSurfaceBuffer, dfb_surface_buffer )
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
,
CoreSurfaceAccessFlags access );
FUSION_OBJECT_METHODS( CoreSurfaceBuffer, dfb_surface_buffer );
FusionObjectPool *dfb_surface_buffer_pool_create( const FusionWorld *world ); FusionObjectPool *dfb_surface_buffer_pool_create( const FusionWorld *world );
#endif #endif
 End of changes. 8 change blocks. 
100 lines changed or deleted 17 lines changed or added


 surface_pool.h   surface_pool.h 
skipping to change at line 180 skipping to change at line 180
/* /*
* Manage interlocks * Manage interlocks
*/ */
DFBResult (*PreLock) ( CoreSurfacePool *pool, DFBResult (*PreLock) ( CoreSurfacePool *pool,
void *pool_data, void *pool_data,
void *pool_local, void *pool_local,
CoreSurfaceAllocation *allocation, CoreSurfaceAllocation *allocation,
void *alloc_data, void *alloc_data,
CoreSurfaceAccessorID accessor, CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access ); CoreSurfaceAccessFlags access );
/*
* Handle preallocation
*
* The surface pool checks the description and extracts/generates
* information for the surface configuration, to be later used in
* the AllocateBuffer function.
*/
DFBResult (*PreAlloc)( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
const DFBSurfaceDescription *description,
CoreSurfaceConfig *config );
} 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 210 skipping to change at line 223
CoreSurfacePool *backup; CoreSurfacePool *backup;
}; };
typedef DFBEnumerationResult (*CoreSurfacePoolCallback)( CoreSurfacePool *p ool, typedef DFBEnumerationResult (*CoreSurfacePoolCallback)( CoreSurfacePool *p ool,
void *c tx ); void *c tx );
typedef DFBEnumerationResult (*CoreSurfaceAllocCallback)( CoreSurfaceAlloca tion *allocation, typedef DFBEnumerationResult (*CoreSurfaceAllocCallback)( CoreSurfaceAlloca tion *allocation,
void *ctx ); void *ctx );
DFBResult dfb_surface_pools_prealloc ( const DFBSurfaceDescription *descrip
tion,
CoreSurfaceConfig *config
);
DFBResult dfb_surface_pools_negotiate( CoreSurfaceBuffer *buffer, DFBResult dfb_surface_pools_negotiate( CoreSurfaceBuffer *buffer,
CoreSurfaceAccessorID accessor, CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
CoreSurfacePool **ret_pools, CoreSurfacePool **ret_pools,
unsigned int max_pools, unsigned int max_pools,
unsigned int *ret_num ); unsigned int *ret_num );
DFBResult dfb_surface_pools_enumerate( CoreSurfacePoolCallback callback, DFBResult dfb_surface_pools_enumerate( CoreSurfacePoolCallback callback,
void *ctx ); void *ctx );
DFBResult dfb_surface_pools_lookup ( CoreSurfacePoolID pool_id,
CoreSurfacePool **ret_pool );
DFBResult dfb_surface_pools_allocate ( CoreSurfaceBuffer *buffer, DFBResult dfb_surface_pools_allocate ( CoreSurfaceBuffer *buffer,
CoreSurfaceAccessorID accessor, CoreSurfaceAccessorID accessor,
CoreSurfaceAccessFlags access, CoreSurfaceAccessFlags access,
CoreSurfaceAllocation **ret_allocat ion ); CoreSurfaceAllocation **ret_allocat ion );
DFBResult dfb_surface_pool_initialize( CoreDFB *core, DFBResult dfb_surface_pool_initialize( CoreDFB *core,
const SurfacePoolFuncs *funcs, const SurfacePoolFuncs *funcs,
CoreSurfacePool **ret_pool ); CoreSurfacePool **ret_pool );
DFBResult dfb_surface_pool_initialize2( CoreDFB *core,
const SurfacePoolFuncs *funcs,
void *ctx,
CoreSurfacePool **ret_pool )
;
DFBResult dfb_surface_pool_join ( CoreDFB *core, DFBResult dfb_surface_pool_join ( CoreDFB *core,
CoreSurfacePool *pool, CoreSurfacePool *pool,
const SurfacePoolFuncs *funcs ); const SurfacePoolFuncs *funcs );
DFBResult dfb_surface_pool_join2 ( CoreDFB *core,
CoreSurfacePool *pool,
const SurfacePoolFuncs *funcs,
void *ctx );
DFBResult dfb_surface_pool_destroy ( CoreSurfacePool *pool ); DFBResult dfb_surface_pool_destroy ( CoreSurfacePool *pool );
DFBResult dfb_surface_pool_leave ( CoreSurfacePool *pool ); DFBResult dfb_surface_pool_leave ( CoreSurfacePool *pool );
DFBResult dfb_surface_pool_allocate ( CoreSurfacePool *pool, DFBResult dfb_surface_pool_allocate ( CoreSurfacePool *pool,
CoreSurfaceBuffer *buffer, CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation **ret_allocat ion ); CoreSurfaceAllocation **ret_allocat ion );
DFBResult dfb_surface_pool_deallocate( CoreSurfacePool *pool, DFBResult dfb_surface_pool_deallocate( CoreSurfacePool *pool,
CoreSurfaceAllocation *allocation ); CoreSurfaceAllocation *allocation );
 End of changes. 5 change blocks. 
0 lines changed or deleted 32 lines changed or added


 surface_pool_bridge.h   surface_pool_bridge.h 
skipping to change at line 38 skipping to change at line 38
#ifndef __CORE__SURFACE_POOL_BRIDGE_H__ #ifndef __CORE__SURFACE_POOL_BRIDGE_H__
#define __CORE__SURFACE_POOL_BRIDGE_H__ #define __CORE__SURFACE_POOL_BRIDGE_H__
#include <directfb.h> #include <directfb.h>
#include <core/coretypes.h> #include <core/coretypes.h>
#include <core/surface.h> #include <core/surface.h>
#include <core/surface_buffer.h> #include <core/surface_buffer.h>
#include <core/surface_pool.h>
typedef enum { typedef enum {
CSPBCAPS_NONE = 0x00000000, CSPBCAPS_NONE = 0x00000000,
CSPBCAPS_ALL = 0x00000000 CSPBCAPS_ALL = 0x00000000
} CoreSurfacePoolBridgeCapabilities; } CoreSurfacePoolBridgeCapabilities;
/* /*
* Increase this number when changes result in binary incompatibility! * Increase this number when changes result in binary incompatibility!
*/ */
#define DFB_SURFACE_POOL_BRIDGE_ABI_VERSION 1 #define DFB_SURFACE_POOL_BRIDGE_ABI_VERSION 1
#define DFB_SURFACE_POOL_BRIDGE_DESC_NAME_LENGTH 44 #define DFB_SURFACE_POOL_BRIDGE_DESC_NAME_LENGTH 44
typedef struct { typedef struct {
CoreSurfacePoolBridgeCapabilities caps; CoreSurfacePoolBridgeCapabilities caps;
char name[DFB_SURFACE_POOL_BRIDGE_DESC_N AME_LENGTH]; char name[DFB_SURFACE_POOL_BRIDGE_DESC_N AME_LENGTH];
CoreSurfacePoolPriority priority;
} CoreSurfacePoolBridgeDescription; } CoreSurfacePoolBridgeDescription;
typedef struct { typedef struct {
int (*PoolBridgeDataSize)( void ); int (*PoolBridgeDataSize)( void );
int (*PoolBridgeLocalDataSize)( void ); int (*PoolBridgeLocalDataSize)( void );
int (*PoolTransferDataSize)( void ); int (*PoolTransferDataSize)( void );
/* /*
* Bridge init/destroy * Bridge init/destroy
 End of changes. 2 change blocks. 
0 lines changed or deleted 2 lines changed or added


 util.h   util.h 
skipping to change at line 36 skipping to change at line 36
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
*/ */
#ifndef __GFX__UTIL_H__ #ifndef __GFX__UTIL_H__
#define __GFX__UTIL_H__ #define __GFX__UTIL_H__
#include <core/surface.h> #include <core/surface.h>
void dfb_gfx_copy( CoreSurface *source, CoreSurface *destination, const DFB Rectangle *rect ); void dfb_gfx_copy( CoreSurface *source, CoreSurface *destination, const DFB Rectangle *rect );
void dfb_gfx_copy_to( CoreSurface *source, CoreSurface *destination, const DFBRectangle *rect, int x, int y, bool from_back ); void dfb_gfx_copy_to( CoreSurface *source, CoreSurface *destination, const DFBRectangle *rect, int x, int y, bool from_back );
void dfb_gfx_clear( CoreSurface *surface, CoreSurfaceBufferRole role );
void dfb_gfx_stretch_to( CoreSurface *source, CoreSurface *destination, con st DFBRectangle *srect, const DFBRectangle *drect, bool from_back ); void dfb_gfx_stretch_to( CoreSurface *source, CoreSurface *destination, con st DFBRectangle *srect, const DFBRectangle *drect, bool from_back );
void dfb_back_to_front_copy( CoreSurface *surface, const DFBRegion *region ); void dfb_back_to_front_copy( CoreSurface *surface, const DFBRegion *region );
void dfb_back_to_front_copy_rotation( CoreSurface *surface, const DFBRegion *region, int rotation ); void dfb_back_to_front_copy_rotation( CoreSurface *surface, const DFBRegion *region, int rotation );
void dfb_clear_depth( CoreSurface *surface, const DFBRegion *region ); void dfb_clear_depth( CoreSurface *surface, const DFBRegion *region );
void dfb_sort_triangle( DFBTriangle *tri ); void dfb_sort_triangle( DFBTriangle *tri );
void dfb_sort_trapezoid( DFBTrapezoid *trap ); void dfb_sort_trapezoid( DFBTrapezoid *trap );
void dfb_gfx_copy_regions( CoreSurface *source, void dfb_gfx_copy_regions( CoreSurface *source,
CoreSurfaceBufferRole from, CoreSurfaceBufferRole from,
CoreSurface *destination, CoreSurface *destination,
CoreSurfaceBufferRole to, CoreSurfaceBufferRole to,
const DFBRegion *regions, const DFBRegion *regions,
unsigned int num, unsigned int num,
int x, int x,
int y ); int y );
/*
* Simplyfy blitting flags
*
* Allow any combination of DSBLIT_ROTATE_ and DSBLIT_FLIP_ flags to be red
uced
* to a combination of DSBLIT_ROTATE_90, DSBLIT_FLIP_HORIZONTAL and DSBLIT_
FLIP_VERTICAL
*
*/
static inline void dfb_simplify_blittingflags( DFBSurfaceBlittingFlags *fla
gs )
{
if (*flags & DSBLIT_ROTATE180)
*flags ^= (DSBLIT_ROTATE180 | DSBLIT_FLIP_HORIZONTAL | DSBLIT_FLI
P_VERTICAL);
if (*flags & DSBLIT_ROTATE270) {
if (*flags & DSBLIT_ROTATE90)
*flags ^= (DSBLIT_ROTATE90 | DSBLIT_ROTATE270);
else
*flags ^= (DSBLIT_ROTATE90 | DSBLIT_ROTATE270 | DSBLIT_FLIP_
HORIZONTAL | DSBLIT_FLIP_VERTICAL);
}
}
#endif #endif
 End of changes. 2 change blocks. 
0 lines changed or deleted 26 lines changed or added


 windows.h   windows.h 
skipping to change at line 245 skipping to change at line 245
/* /*
* change window configuration * change window configuration
*/ */
DFBResult DFBResult
dfb_window_set_config( CoreWindow *window, dfb_window_set_config( CoreWindow *window,
const CoreWindowConfig *config, const CoreWindowConfig *config,
CoreWindowConfigFlags flags ); CoreWindowConfigFlags flags );
/* /*
* change window cursor
*/
DFBResult
dfb_window_set_cursor_shape( CoreWindow *window,
CoreSurface *surface,
unsigned int hot_x,
unsigned int hot_y );
/*
* sets the global alpha factor * sets the global alpha factor
*/ */
DFBResult DFBResult
dfb_window_set_opacity( CoreWindow *window, dfb_window_set_opacity( CoreWindow *window,
u8 opacity ); u8 opacity );
/* /*
* sets the window options * sets the window options
*/ */
DFBResult DFBResult
 End of changes. 1 change blocks. 
0 lines changed or deleted 9 lines changed or added


 windows_internal.h   windows_internal.h 
skipping to change at line 112 skipping to change at line 112
DFBWindowID toplevel_id; /* in case of a sub window top level_id != 0 */ DFBWindowID toplevel_id; /* in case of a sub window top level_id != 0 */
CoreWindow *toplevel; /* for top level windows this will be NULL */ CoreWindow *toplevel; /* for top level windows this will be NULL */
FusionVector subwindows; /* list of sub windows (only v alid for top level windows) */ FusionVector subwindows; /* list of sub windows (only v alid for top level windows) */
CoreWindow *subfocus; /* which of the sub windows ha s the focus? */ CoreWindow *subfocus; /* which of the sub windows ha s the focus? */
unsigned long resource_id; unsigned long resource_id;
FusionCall call; FusionCall call;
struct {
int hot_x;
int hot_y;
CoreSurface *surface;
} cursor;
}; };
typedef enum { typedef enum {
CWSF_NONE = 0x00000000, CWSF_NONE = 0x00000000,
CWSF_INITIALIZED = 0x00000001, CWSF_INITIALIZED = 0x00000001,
CWSF_ACTIVATED = 0x00000002, CWSF_ACTIVATED = 0x00000002,
CWSF_ALL = 0x00000003 CWSF_ALL = 0x00000003
} CoreWindowStackFlags; } CoreWindowStackFlags;
 End of changes. 1 change blocks. 
0 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/