conf.h   conf.h 
skipping to change at line 239 skipping to change at line 239
struct { struct {
DFBDimension min_size; DFBDimension min_size;
} create_surface; } create_surface;
struct { struct {
DFBDimension min_size; DFBDimension min_size;
} allocate_buffer; } allocate_buffer;
} warn; } warn;
int keep_accumulators; /* Free accumulators abov e this limit */ int keep_accumulators; /* Free accumulators abov e this limit */
bool software_trace;
} 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


 convert.h   convert.h 
skipping to change at line 284 skipping to change at line 284
(((pixel) & 0x0000F000) >> 8) | \ (((pixel) & 0x0000F000) >> 8) | \
(((pixel) & 0x000000F0) >> 4) ) (((pixel) & 0x000000F0) >> 4) )
#define ARGB_TO_RGB555(pixel) ( (((pixel) & 0x00F80000) >> 9) | \ #define ARGB_TO_RGB555(pixel) ( (((pixel) & 0x00F80000) >> 9) | \
(((pixel) & 0x0000F800) >> 6) | \ (((pixel) & 0x0000F800) >> 6) | \
(((pixel) & 0x000000F8) >> 3) ) (((pixel) & 0x000000F8) >> 3) )
#define ARGB_TO_BGR555(pixel) ( (((pixel) & 0x00F80000) >> 19) | \ #define ARGB_TO_BGR555(pixel) ( (((pixel) & 0x00F80000) >> 19) | \
(((pixel) & 0x0000F800) >> 6) | \ (((pixel) & 0x0000F800) >> 6) | \
(((pixel) & 0x000000F8) << 7) ) (((pixel) & 0x000000F8) << 7) )
/* RGB <-> YCbCr conversion */
extern const u16 y_for_rgb[256]; /* RGB <-> YCbCr conversion */
extern const s16 cr_for_r[256];
extern const s16 cr_for_g[256];
extern const s16 cb_for_g[256];
extern const s16 cb_for_b[256];
#define YCBCR_TO_RGB( y, cb, cr, r, g, b ) do { \ #define YCBCR_TO_RGB( y, cb, cr, r, g, b ) \
u16 _y, _cb, _cr;\ do { \
s16 _r, _g, _b;\ int _y = (y) - 16; \
_y = y_for_rgb[(y)]; _cb = (cb); _cr = (cr);\ int _cb = (cb) - 128; \
_r = _y + cr_for_r[_cr]; \ int _cr = (cr) - 128; \
_g = _y + cr_for_g[_cr] + cb_for_g[_cb]; \ \
_b = _y + cb_for_b[_cb]; \ int _r = (298 * _y + 409 * _cr + 128) >> 8; \
(r) = CLAMP( _r, 0, 255 ); \ int _g = (298 * _y - 100 * _cb - 208 * _cr + 128) >> 8; \
(g) = CLAMP( _g, 0, 255 ); \ int _b = (298 * _y + 516 * _cb + 128) >> 8; \
(b) = CLAMP( _b, 0, 255 ); \ \
(r) = CLAMP( _r, 0, 255 ); \
(g) = CLAMP( _g, 0, 255 ); \
(b) = CLAMP( _b, 0, 255 ); \
} while (0) } while (0)
extern const u16 y_from_ey[256]; #define RGB_TO_YCBCR( r, g, b, y, cb, cr ) \
extern const u16 cb_from_bey[512]; do { \
extern const u16 cr_from_rey[512]; int _r = (r), _g = (g), _b = (b); \
\
#define RGB_TO_YCBCR( r, g, b, y, cb, cr ) do { \ (y) = ( 66 * _r + 129 * _g + 25 * _b + 16*256 + 128) >> 8; \
u32 _ey, _r, _g, _b;\ (cb) = ( - 38 * _r - 74 * _g + 112 * _b + 128*256 + 128) >> 8; \
_r = (r); _g = (g); _b = (b);\ (cr) = ( 112 * _r - 94 * _g - 18 * _b + 128*256 + 128) >> 8; \
_ey = (19595 * _r + 38469 * _g + 7471 * _b) >> 16;\
(y) = y_from_ey[_ey]; \
(cb) = cb_from_bey[_b-_ey+255]; \
(cr) = cr_from_rey[_r-_ey+255]; \
} while (0) } while (0)
DFBSurfacePixelFormat dfb_pixelformat_for_depth( int depth ); DFBSurfacePixelFormat dfb_pixelformat_for_depth( int depth );
void dfb_pixel_to_color ( DFBSurfacePixelFormat format, void dfb_pixel_to_color ( DFBSurfacePixelFormat format,
unsigned long pixel, unsigned long pixel,
DFBColor *ret_colo r ); DFBColor *ret_colo r );
unsigned long dfb_pixel_from_color( DFBSurfacePixelFormat format, unsigned long dfb_pixel_from_color( DFBSurfacePixelFormat format,
const DFBColor *color ); const DFBColor *color );
skipping to change at line 344 skipping to change at line 338
static inline u32 static inline u32
dfb_color_to_argb( const DFBColor *color ) dfb_color_to_argb( const DFBColor *color )
{ {
return (color->a << 24) | (color->r << 16) | (color->g << 8) | color-> b; return (color->a << 24) | (color->r << 16) | (color->g << 8) | color-> b;
} }
static inline u32 static inline u32
dfb_color_to_aycbcr( const DFBColor *color ) dfb_color_to_aycbcr( const DFBColor *color )
{ {
unsigned int red = color->r; u32 y = ( 66 * color->r + 129 * color->g + 25 * color->b + 16*25
unsigned int green = color->g; 6 + 128) >> 8;
unsigned int blue = color->b; u32 cb = ( - 38 * color->r - 74 * color->g + 112 * color->b + 128*25
6 + 128) >> 8;
u8 y = (u8)(((66 * red + 129 * green + 25 * blue) / 256) + 16); u32 cr = ( 112 * color->r - 94 * color->g - 18 * color->b + 128*25
6 + 128) >> 8;
u8 cb = (u8)((128 * 256 - 38 * red - 74 * green + 112 * blue) / 256
);
u8 cr = (u8)((128 * 256 + 112 * red - 94 * green - 18 * blue) / 256
);
return (color->a << 24) | (y << 16) | (cb << 8) | cr; return (color->a << 24) | (y << 16) | (cb << 8) | cr;
} }
static inline void static inline void
dfb_argb_to_rgb332( u32 *src, u8 *dst, int len ) dfb_argb_to_rgb332( u32 *src, u8 *dst, int len )
{ {
int i; int i;
for (i=0; i<len; i++) { for (i=0; i<len; i++) {
 End of changes. 5 change blocks. 
37 lines changed or deleted 27 lines changed or added


 directfb.h   directfb.h 
skipping to change at line 880 skipping to change at line 880
to avoid visibility of content to avoid visibility of content
that is still in preparation. that is still in preparation.
Normally a window's content can Normally a window's content can
get visible before an update if get visible before an update if
there is another reason causing there is another reason causing
a window stack repaint. */ a window stack repaint. */
DWCAPS_INPUTONLY = 0x00000004, /* The window has no surface. DWCAPS_INPUTONLY = 0x00000004, /* The window has no surface.
You can not draw to it but it You can not draw to it but it
receives events */ receives events */
DWCAPS_NODECORATION = 0x00000008, /* The window won't be decorated. * / DWCAPS_NODECORATION = 0x00000008, /* The window won't be decorated. * /
DWCAPS_ALL = 0x0000000F /* All valid flags. */
DWCAPS_NOFOCUS = 0x00000100, /* Window will never get focus or r
eceive key events, unless it grabs them. */
DWCAPS_ALL = 0x0000010F /* All of these. */
} DFBWindowCapabilities; } DFBWindowCapabilities;
/* /*
* Flags controlling the appearance and behaviour of the window. * Flags controlling the appearance and behaviour of the window.
*/ */
typedef enum { typedef enum {
DWOP_NONE = 0x00000000, /* none of these */ DWOP_NONE = 0x00000000, /* none of these */
DWOP_COLORKEYING = 0x00000001, /* enable color key */ DWOP_COLORKEYING = 0x00000001, /* enable color key */
DWOP_ALPHACHANNEL = 0x00000002, /* enable alpha blending using the DWOP_ALPHACHANNEL = 0x00000002, /* enable alpha blending using the
window's alpha channel */ window's alpha channel */
skipping to change at line 1082 skipping to change at line 1085
/* 8 bit ALUT (1 byte, alpha 4@4, color lookup 4@0) */ /* 8 bit ALUT (1 byte, alpha 4@4, color lookup 4@0) */
DSPF_ALUT44 = DFB_SURFACE_PIXELFORMAT( 12, 4, 4, 1, 0, 1, 0, 0, 0, 1, 0 ), DSPF_ALUT44 = DFB_SURFACE_PIXELFORMAT( 12, 4, 4, 1, 0, 1, 0, 0, 0, 1, 0 ),
/* 32 bit ARGB (4 byte, inv. alpha 8@24, red 8@16, green 8@8, blue 8@ 0) */ /* 32 bit ARGB (4 byte, inv. alpha 8@24, red 8@16, green 8@8, blue 8@ 0) */
DSPF_AiRGB = DFB_SURFACE_PIXELFORMAT( 13, 24, 8, 1, 0, 4, 0, 0, 0, 0, 1 ), DSPF_AiRGB = DFB_SURFACE_PIXELFORMAT( 13, 24, 8, 1, 0, 4, 0, 0, 0, 0, 1 ),
/* 1 bit alpha (1 byte/ 8 pixel, most significant bit used first) */ /* 1 bit alpha (1 byte/ 8 pixel, most significant bit used first) */
DSPF_A1 = DFB_SURFACE_PIXELFORMAT( 14, 0, 1, 1, 1, 0, 7, 0, 0, 0, 0 ), DSPF_A1 = DFB_SURFACE_PIXELFORMAT( 14, 0, 1, 1, 1, 0, 7, 0, 0, 0, 0 ),
/* 12 bit YUV (8 bit Y plane followed by one 16 bit quarter size CbC r [15:0] plane) */ /* 12 bit YUV (8 bit Y plane followed by one 16 bit quarter size Cb| Cr [7:0|7:0] plane) */
DSPF_NV12 = DFB_SURFACE_PIXELFORMAT( 15, 12, 0, 0, 0, 1, 0, 2, 0, 0, 0 ), DSPF_NV12 = DFB_SURFACE_PIXELFORMAT( 15, 12, 0, 0, 0, 1, 0, 2, 0, 0, 0 ),
/* 16 bit YUV (8 bit Y plane followed by one 16 bit half width CbCr [15:0] plane) */ /* 16 bit YUV (8 bit Y plane followed by one 16 bit half width Cb|Cr [7:0|7:0] plane) */
DSPF_NV16 = DFB_SURFACE_PIXELFORMAT( 16, 24, 0, 0, 0, 1, 0, 0, 1, 0, 0 ), DSPF_NV16 = DFB_SURFACE_PIXELFORMAT( 16, 24, 0, 0, 0, 1, 0, 0, 1, 0, 0 ),
/* 16 bit ARGB (2 byte, alpha 2@14, red 5@9, green 5@4, blue 4@0) */ /* 16 bit ARGB (2 byte, alpha 2@14, red 5@9, green 5@4, blue 4@0) */
DSPF_ARGB2554 = DFB_SURFACE_PIXELFORMAT( 17, 14, 2, 1, 0, 2, 0, 0, 0, 0, 0 ), DSPF_ARGB2554 = DFB_SURFACE_PIXELFORMAT( 17, 14, 2, 1, 0, 2, 0, 0, 0, 0, 0 ),
/* 16 bit ARGB (2 byte, alpha 4@12, red 4@8, green 4@4, blue 4@0) */ /* 16 bit ARGB (2 byte, alpha 4@12, red 4@8, green 4@4, blue 4@0) */
DSPF_ARGB4444 = DFB_SURFACE_PIXELFORMAT( 18, 12, 4, 1, 0, 2, 0, 0, 0, 0, 0 ), DSPF_ARGB4444 = DFB_SURFACE_PIXELFORMAT( 18, 12, 4, 1, 0, 2, 0, 0, 0, 0, 0 ),
/* 12 bit YUV (8 bit Y plane followed by one 16 bit quarter size CrC b [15:0] plane) */ /* 12 bit YUV (8 bit Y plane followed by one 16 bit quarter size Cr| Cb [7:0|7:0] plane) */
DSPF_NV21 = DFB_SURFACE_PIXELFORMAT( 19, 12, 0, 0, 0, 1, 0, 2, 0, 0, 0 ), DSPF_NV21 = DFB_SURFACE_PIXELFORMAT( 19, 12, 0, 0, 0, 1, 0, 2, 0, 0, 0 ),
/* 32 bit AYUV (4 byte, alpha 8@24, Y 8@16, Cb 8@8, Cr 8@0) */ /* 32 bit AYUV (4 byte, alpha 8@24, Y 8@16, Cb 8@8, Cr 8@0) */
DSPF_AYUV = DFB_SURFACE_PIXELFORMAT( 20, 24, 8, 1, 0, 4, 0, 0, 0, 0, 0 ), DSPF_AYUV = DFB_SURFACE_PIXELFORMAT( 20, 24, 8, 1, 0, 4, 0, 0, 0, 0, 0 ),
/* 4 bit alpha (1 byte/ 2 pixel, more significant nibble used first) */ /* 4 bit alpha (1 byte/ 2 pixel, more significant nibble used first) */
DSPF_A4 = DFB_SURFACE_PIXELFORMAT( 21, 0, 4, 1, 4, 0, 1, 0, 0, 0, 0 ), DSPF_A4 = DFB_SURFACE_PIXELFORMAT( 21, 0, 4, 1, 4, 0, 1, 0, 0, 0, 0 ),
/* 1 bit alpha (3 byte/ alpha 1@18, red 6@16, green 6@6, blue 6@0) * / /* 1 bit alpha (3 byte/ alpha 1@18, red 6@16, green 6@6, blue 6@0) * /
DSPF_ARGB1666 = DFB_SURFACE_PIXELFORMAT( 22, 18, 1, 1, 0, 3, 0, 0, 0, 0, 0 ), DSPF_ARGB1666 = DFB_SURFACE_PIXELFORMAT( 22, 18, 1, 1, 0, 3, 0, 0, 0, 0, 0 ),
/* 6 bit alpha (3 byte/ alpha 6@18, red 6@16, green 6@6, blue 6@0) * / /* 6 bit alpha (3 byte/ alpha 6@18, red 6@16, green 6@6, blue 6@0) * /
DSPF_ARGB6666 = DFB_SURFACE_PIXELFORMAT( 23, 18, 6, 1, 0, 3, 0, 0, 0, 0, 0 ), DSPF_ARGB6666 = DFB_SURFACE_PIXELFORMAT( 23, 18, 6, 1, 0, 3, 0, 0, 0, 0, 0 ),
/* 6 bit RGB (3 byte/ red 6@16, green 6@6, blue 6@0) */ /* 6 bit RGB (3 byte/ red 6@16, green 6@6, blue 6@0) */
DSPF_RGB18 = DFB_SURFACE_PIXELFORMAT( 24, 18, 0, 0, 0, 3, 0, 0, 0, 0, 0 ), DSPF_RGB18 = DFB_SURFACE_PIXELFORMAT( 24, 18, 0, 0, 0, 3, 0, 0, 0, 0, 0 ),
/* 2 bit LUT (1 byte/ 4 pixel, 2 bit color and alpha lookup from pa lette) */ /* 2 bit LUT (1 byte/ 4 pixel, 2 bit color and alpha lookup from pa lette) */
DSPF_LUT2 = DFB_SURFACE_PIXELFORMAT( 25, 2, 0, 1, 2, 0, 3, 0, 0, 1, 0 ), DSPF_LUT2 = DFB_SURFACE_PIXELFORMAT( 25, 2, 0, 1, 2, 0, 3, 0, 0, 1, 0 ),
/* 16 bit RGB (2 byte, nothing @12, red 4@8, green 4@4, blue 4@0) */ /* 16 bit RGB (2 byte, nothing @12, red 4@8, green 4@4, blue 4@0) */
DSPF_RGB444 = DFB_SURFACE_PIXELFORMAT( 26, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0 ), DSPF_RGB444 = DFB_SURFACE_PIXELFORMAT( 26, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0 ),
/* 16 bit RGB (2 byte, nothing @15, red 5@10, green 5@5, blue 5@0) * / /* 16 bit RGB (2 byte, nothing @15, red 5@10, green 5@5, blue 5@0) * /
DSPF_RGB555 = DFB_SURFACE_PIXELFORMAT( 27, 15, 0, 0, 0, 2, 0, 0, 0, 0, 0 ), DSPF_RGB555 = DFB_SURFACE_PIXELFORMAT( 27, 15, 0, 0, 0, 2, 0, 0, 0, 0, 0 ),
/* 16 bit BGR (2 byte, nothing @15, blue 5@10, green 5@5, red 5@0) * / /* 16 bit BGR (2 byte, nothing @15, blue 5@10, green 5@5, red 5@0) * /
DSPF_BGR555 = DFB_SURFACE_PIXELFORMAT( 28, 15, 0, 0, 0, 2, 0, 0, 0, 0, 0 ) DSPF_BGR555 = DFB_SURFACE_PIXELFORMAT( 28, 15, 0, 0, 0, 2, 0, 0, 0, 0, 0 )
} DFBSurfacePixelFormat; } DFBSurfacePixelFormat;
skipping to change at line 1287 skipping to change at line 1290
DFBInputDeviceAxisIdentifier max_axis; /* highest axis DFBInputDeviceAxisIdentifier max_axis; /* highest axis
identifier */ identifier */
DFBInputDeviceButtonIdentifier max_button; /* highest button DFBInputDeviceButtonIdentifier max_button; /* highest button
identifier */ identifier */
char name[DFB_INPUT_DEVICE_DESC_NAME_LENGTH]; /* Device name */ char name[DFB_INPUT_DEVICE_DESC_NAME_LENGTH]; /* Device name */
char vendor[DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH]; /* Device vendor */ char vendor[DFB_INPUT_DEVICE_DESC_VENDOR_LENGTH]; /* Device vendor */
} DFBInputDeviceDescription; } DFBInputDeviceDescription;
typedef enum {
DIAIF_NONE = 0x00000000,
DIAIF_ABS_MIN = 0x00000001,
DIAIF_ABS_MAX = 0x00000002,
DIAIF_ALL = 0x00000003
} DFBInputDeviceAxisInfoFlags;
typedef struct {
DFBInputDeviceAxisInfoFlags flags;
int abs_min;
int abs_max;
} DFBInputDeviceAxisInfo;
#define DFB_GRAPHICS_DRIVER_INFO_NAME_LENGTH 40 #define DFB_GRAPHICS_DRIVER_INFO_NAME_LENGTH 40
#define DFB_GRAPHICS_DRIVER_INFO_VENDOR_LENGTH 60 #define DFB_GRAPHICS_DRIVER_INFO_VENDOR_LENGTH 60
typedef struct { typedef struct {
int major; /* Major version */ int major; /* Major version */
int minor; /* Minor version */ int minor; /* Minor version */
char name[DFB_GRAPHICS_DRIVER_INFO_NAME_LENGTH]; /* Driver name */ char name[DFB_GRAPHICS_DRIVER_INFO_NAME_LENGTH]; /* Driver name */
char vendor[DFB_GRAPHICS_DRIVER_INFO_VENDOR_LENGTH]; /* Driver vendor */ char vendor[DFB_GRAPHICS_DRIVER_INFO_VENDOR_LENGTH]; /* Driver vendor */
} DFBGraphicsDriverInfo; } DFBGraphicsDriverInfo;
skipping to change at line 4193 skipping to change at line 4211
DIET_KEYRELEASE, /* a key is been released */ DIET_KEYRELEASE, /* a key is been released */
DIET_BUTTONPRESS, /* a (mouse) button is been pressed */ DIET_BUTTONPRESS, /* a (mouse) button is been pressed */
DIET_BUTTONRELEASE, /* a (mouse) button is been released */ DIET_BUTTONRELEASE, /* a (mouse) button is been released */
DIET_AXISMOTION /* mouse/joystick movement */ DIET_AXISMOTION /* mouse/joystick movement */
} DFBInputEventType; } DFBInputEventType;
/* /*
* Flags defining which additional (optional) event fields are valid. * Flags defining which additional (optional) event fields are valid.
*/ */
typedef enum { typedef enum {
DIEF_NONE = 0x000, /* no additional fields */ DIEF_NONE = 0x0000, /* no additional fields */
DIEF_TIMESTAMP = 0x001, /* timestamp is valid */ DIEF_TIMESTAMP = 0x0001, /* timestamp is valid */
DIEF_AXISABS = 0x002, /* axis and axisabs are valid */ DIEF_AXISABS = 0x0002, /* axis and axisabs are valid */
DIEF_AXISREL = 0x004, /* axis and axisrel are valid */ DIEF_AXISREL = 0x0004, /* axis and axisrel are valid */
DIEF_KEYCODE = 0x008, /* used internally by the input core, DIEF_KEYCODE = 0x0008, /* used internally by the input core,
always set at application level */ always set at application level */
DIEF_KEYID = 0x010, /* used internally by the input core, DIEF_KEYID = 0x0010, /* used internally by the input core,
always set at application level */ always set at application level */
DIEF_KEYSYMBOL = 0x020, /* used internally by the input core, DIEF_KEYSYMBOL = 0x0020, /* used internally by the input core,
always set at application level */ always set at application level */
DIEF_MODIFIERS = 0x040, /* used internally by the input core, DIEF_MODIFIERS = 0x0040, /* used internally by the input core,
always set at application level */ always set at application level */
DIEF_LOCKS = 0x080, /* used internally by the input core, DIEF_LOCKS = 0x0080, /* used internally by the input core,
always set at application level */ always set at application level */
DIEF_BUTTONS = 0x100, /* used internally by the input core, DIEF_BUTTONS = 0x0100, /* used internally by the input core,
always set at application level */ always set at application level */
DIEF_GLOBAL = 0x200, /* Only for event buffers creates by DIEF_GLOBAL = 0x0200, /* Only for event buffers creates by
IDirectFB::CreateInputEventBuffer() IDirectFB::CreateInputEventBuffer()
with global events enabled. with global events enabled.
Indicates that the event would have Indicates that the event would have
been been
filtered if the buffer hadn't been filtered if the buffer hadn't been
global. */ global. */
DIEF_REPEAT = 0x400, /* repeated event, e.g. key or button p DIEF_REPEAT = 0x0400, /* repeated event, e.g. key or button
ress */ press */
DIEF_FOLLOW = 0x800 /* another event will follow immediatel DIEF_FOLLOW = 0x0800, /* another event will follow immediate
y, e.g. x/y axis */ ly, e.g. x/y axis */
DIEF_MIN = 0x1000, /* minimum value is set, e.g. for abso
lute axis motion */
DIEF_MAX = 0x2000, /* maximum value is set, e.g. for abso
lute axis motion */
} DFBInputEventFlags; } DFBInputEventFlags;
/* /*
* An input event, item of an input buffer. * An input event, item of an input buffer.
*/ */
typedef struct { typedef struct {
DFBEventClass clazz; /* clazz of event */ DFBEventClass clazz; /* clazz of event */
DFBInputEventType type; /* type of event */ DFBInputEventType type; /* type of event */
DFBInputDeviceID device_id; /* source of event */ DFBInputDeviceID device_id; /* source of event */
skipping to change at line 4264 skipping to change at line 4285
pressed buttons */ pressed buttons */
/* DIET_AXISMOTION */ /* DIET_AXISMOTION */
DFBInputDeviceAxisIdentifier axis; /* in case of an axis DFBInputDeviceAxisIdentifier axis; /* in case of an axis
event */ event */
/* one of these two (check flags) */ /* one of these two (check flags) */
int axisabs; /* absolute mouse/ int axisabs; /* absolute mouse/
joystick coordinate */ joystick coordinate */
int axisrel; /* relative mouse/ int axisrel; /* relative mouse/
joystick movement */ joystick movement */
/* general information */
int min; /* minimum possible value
*/
int max; /* maximum possible value
*/
} DFBInputEvent; } DFBInputEvent;
/* /*
* Window Event Types - can also be used as flags for event filters. * Window Event Types - can also be used as flags for event filters.
*/ */
typedef enum { typedef enum {
DWET_NONE = 0x00000000, DWET_NONE = 0x00000000,
DWET_POSITION = 0x00000001, /* window has been moved by DWET_POSITION = 0x00000001, /* window has been moved by
window manager or the window manager or the
 End of changes. 9 change blocks. 
32 lines changed or deleted 62 lines changed or added


 directfb_keynames.h   directfb_keynames.h 
#ifndef __DIRECTFB_KEYNAMES_H__ #ifndef __DIRECTFB_KEYNAMES_H__
#define __DIRECTFB_KEYNAMES_H__ #define __DIRECTFB_KEYNAMES_H__
#define DirectFBKeySymbolNames(Identifier) struct DFBKeySymbolName { \ struct DFBKeySymbolName {
DFBInputDeviceKeySymbol symbol; \ DFBInputDeviceKeySymbol symbol;
const char *name; \ const char *name;
} Identifier[] = { \ };
#define DirectFBKeySymbolNames(Identifier) struct DFBKeySymbolName Identifi
er[] = { \
{ DIKS_BACKSPACE, "BACKSPACE" }, \ { DIKS_BACKSPACE, "BACKSPACE" }, \
{ DIKS_TAB, "TAB" }, \ { DIKS_TAB, "TAB" }, \
{ DIKS_RETURN, "RETURN" }, \ { DIKS_RETURN, "RETURN" }, \
{ DIKS_CANCEL, "CANCEL" }, \ { DIKS_CANCEL, "CANCEL" }, \
{ DIKS_ESCAPE, "ESCAPE" }, \ { DIKS_ESCAPE, "ESCAPE" }, \
{ DIKS_SPACE, "SPACE" }, \ { DIKS_SPACE, "SPACE" }, \
{ DIKS_EXCLAMATION_MARK, "EXCLAMATION_MARK" }, \ { DIKS_EXCLAMATION_MARK, "EXCLAMATION_MARK" }, \
{ DIKS_QUOTATION, "QUOTATION" }, \ { DIKS_QUOTATION, "QUOTATION" }, \
{ DIKS_NUMBER_SIGN, "NUMBER_SIGN" }, \ { DIKS_NUMBER_SIGN, "NUMBER_SIGN" }, \
{ DIKS_DOLLAR_SIGN, "DOLLAR_SIGN" }, \ { DIKS_DOLLAR_SIGN, "DOLLAR_SIGN" }, \
skipping to change at line 354 skipping to change at line 356
{ DIKS_CUSTOM93, "CUSTOM93" }, \ { DIKS_CUSTOM93, "CUSTOM93" }, \
{ DIKS_CUSTOM94, "CUSTOM94" }, \ { DIKS_CUSTOM94, "CUSTOM94" }, \
{ DIKS_CUSTOM95, "CUSTOM95" }, \ { DIKS_CUSTOM95, "CUSTOM95" }, \
{ DIKS_CUSTOM96, "CUSTOM96" }, \ { DIKS_CUSTOM96, "CUSTOM96" }, \
{ DIKS_CUSTOM97, "CUSTOM97" }, \ { DIKS_CUSTOM97, "CUSTOM97" }, \
{ DIKS_CUSTOM98, "CUSTOM98" }, \ { DIKS_CUSTOM98, "CUSTOM98" }, \
{ DIKS_CUSTOM99, "CUSTOM99" }, \ { DIKS_CUSTOM99, "CUSTOM99" }, \
{ DIKS_NULL, "NULL" } \ { DIKS_NULL, "NULL" } \
}; };
#define DirectFBKeyIdentifierNames(Identifier) struct DFBKeyIdentifierName struct DFBKeyIdentifierName {
{ \ DFBInputDeviceKeyIdentifier identifier;
DFBInputDeviceKeyIdentifier identifier; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBKeyIdentifierNames(Identifier) struct DFBKeyIdentifierName
Identifier[] = { \
{ DIKI_A, "A" }, \ { DIKI_A, "A" }, \
{ DIKI_B, "B" }, \ { DIKI_B, "B" }, \
{ DIKI_C, "C" }, \ { DIKI_C, "C" }, \
{ DIKI_D, "D" }, \ { DIKI_D, "D" }, \
{ DIKI_E, "E" }, \ { DIKI_E, "E" }, \
{ DIKI_F, "F" }, \ { DIKI_F, "F" }, \
{ DIKI_G, "G" }, \ { DIKI_G, "G" }, \
{ DIKI_H, "H" }, \ { DIKI_H, "H" }, \
{ DIKI_I, "I" }, \ { DIKI_I, "I" }, \
{ DIKI_J, "J" }, \ { DIKI_J, "J" }, \
 End of changes. 2 change blocks. 
9 lines changed or deleted 14 lines changed or added


 directfb_strings.h   directfb_strings.h 
#ifndef __DIRECTFB_STRINGS_H__ #ifndef __DIRECTFB_STRINGS_H__
#define __DIRECTFB_STRINGS_H__ #define __DIRECTFB_STRINGS_H__
#define DirectFBPixelFormatNames(Identifier) struct DFBPixelFormatName { \ struct DFBPixelFormatName {
DFBSurfacePixelFormat format; \ DFBSurfacePixelFormat format;
const char *name; \ const char *name;
} Identifier[] = { \ };
#define DirectFBPixelFormatNames(Identifier) struct DFBPixelFormatName Iden
tifier[] = { \
{ DSPF_ARGB1555, "ARGB1555" }, \ { DSPF_ARGB1555, "ARGB1555" }, \
{ DSPF_RGB16, "RGB16" }, \ { DSPF_RGB16, "RGB16" }, \
{ DSPF_RGB24, "RGB24" }, \ { DSPF_RGB24, "RGB24" }, \
{ DSPF_RGB32, "RGB32" }, \ { DSPF_RGB32, "RGB32" }, \
{ DSPF_ARGB, "ARGB" }, \ { DSPF_ARGB, "ARGB" }, \
{ DSPF_A8, "A8" }, \ { DSPF_A8, "A8" }, \
{ DSPF_YUY2, "YUY2" }, \ { DSPF_YUY2, "YUY2" }, \
{ DSPF_RGB332, "RGB332" }, \ { DSPF_RGB332, "RGB332" }, \
{ DSPF_UYVY, "UYVY" }, \ { DSPF_UYVY, "UYVY" }, \
{ DSPF_I420, "I420" }, \ { DSPF_I420, "I420" }, \
skipping to change at line 40 skipping to change at line 42
{ DSPF_ARGB1666, "ARGB1666" }, \ { DSPF_ARGB1666, "ARGB1666" }, \
{ DSPF_ARGB6666, "ARGB6666" }, \ { DSPF_ARGB6666, "ARGB6666" }, \
{ DSPF_RGB18, "RGB18" }, \ { DSPF_RGB18, "RGB18" }, \
{ DSPF_LUT2, "LUT2" }, \ { DSPF_LUT2, "LUT2" }, \
{ DSPF_RGB444, "RGB444" }, \ { DSPF_RGB444, "RGB444" }, \
{ DSPF_RGB555, "RGB555" }, \ { DSPF_RGB555, "RGB555" }, \
{ DSPF_BGR555, "BGR555" }, \ { DSPF_BGR555, "BGR555" }, \
{ DSPF_UNKNOWN, "UNKNOWN" } \ { DSPF_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBInputDeviceTypeFlagsNames(Identifier) struct DFBInputDevice struct DFBInputDeviceTypeFlagsName {
TypeFlagsName { \ DFBInputDeviceTypeFlags type;
DFBInputDeviceTypeFlags type; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBInputDeviceTypeFlagsNames(Identifier) struct DFBInputDevice
TypeFlagsName Identifier[] = { \
{ DIDTF_KEYBOARD, "KEYBOARD" }, \ { DIDTF_KEYBOARD, "KEYBOARD" }, \
{ DIDTF_MOUSE, "MOUSE" }, \ { DIDTF_MOUSE, "MOUSE" }, \
{ DIDTF_JOYSTICK, "JOYSTICK" }, \ { DIDTF_JOYSTICK, "JOYSTICK" }, \
{ DIDTF_REMOTE, "REMOTE" }, \ { DIDTF_REMOTE, "REMOTE" }, \
{ DIDTF_VIRTUAL, "VIRTUAL" }, \ { DIDTF_VIRTUAL, "VIRTUAL" }, \
{ DIDTF_NONE, "NONE" } \ { DIDTF_NONE, "NONE" } \
}; };
#define DirectFBSurfaceDrawingFlagsNames(Identifier) struct DFBSurfaceDrawi struct DFBSurfaceDrawingFlagsName {
ngFlagsName { \ DFBSurfaceDrawingFlags flag;
DFBSurfaceDrawingFlags flag; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBSurfaceDrawingFlagsNames(Identifier) struct DFBSurfaceDrawi
ngFlagsName Identifier[] = { \
{ DSDRAW_BLEND, "BLEND" }, \ { DSDRAW_BLEND, "BLEND" }, \
{ DSDRAW_DST_COLORKEY, "DST_COLORKEY" }, \ { DSDRAW_DST_COLORKEY, "DST_COLORKEY" }, \
{ DSDRAW_SRC_PREMULTIPLY, "SRC_PREMULTIPLY" }, \ { DSDRAW_SRC_PREMULTIPLY, "SRC_PREMULTIPLY" }, \
{ DSDRAW_DST_PREMULTIPLY, "DST_PREMULTIPLY" }, \ { DSDRAW_DST_PREMULTIPLY, "DST_PREMULTIPLY" }, \
{ DSDRAW_DEMULTIPLY, "DEMULTIPLY" }, \ { DSDRAW_DEMULTIPLY, "DEMULTIPLY" }, \
{ DSDRAW_XOR, "XOR" }, \ { DSDRAW_XOR, "XOR" }, \
{ DSDRAW_NOFX, "NOFX" } \ { DSDRAW_NOFX, "NOFX" } \
}; };
#define DirectFBSurfaceBlittingFlagsNames(Identifier) struct DFBSurfaceBlit struct DFBSurfaceBlittingFlagsName {
tingFlagsName { \ DFBSurfaceBlittingFlags flag;
DFBSurfaceBlittingFlags flag; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBSurfaceBlittingFlagsNames(Identifier) struct DFBSurfaceBlit
tingFlagsName Identifier[] = { \
{ DSBLIT_BLEND_ALPHACHANNEL, "BLEND_ALPHACHANNEL" }, \ { DSBLIT_BLEND_ALPHACHANNEL, "BLEND_ALPHACHANNEL" }, \
{ DSBLIT_BLEND_COLORALPHA, "BLEND_COLORALPHA" }, \ { DSBLIT_BLEND_COLORALPHA, "BLEND_COLORALPHA" }, \
{ DSBLIT_COLORIZE, "COLORIZE" }, \ { DSBLIT_COLORIZE, "COLORIZE" }, \
{ DSBLIT_SRC_COLORKEY, "SRC_COLORKEY" }, \ { DSBLIT_SRC_COLORKEY, "SRC_COLORKEY" }, \
{ DSBLIT_DST_COLORKEY, "DST_COLORKEY" }, \ { DSBLIT_DST_COLORKEY, "DST_COLORKEY" }, \
{ DSBLIT_SRC_PREMULTIPLY, "SRC_PREMULTIPLY" }, \ { DSBLIT_SRC_PREMULTIPLY, "SRC_PREMULTIPLY" }, \
{ DSBLIT_DST_PREMULTIPLY, "DST_PREMULTIPLY" }, \ { DSBLIT_DST_PREMULTIPLY, "DST_PREMULTIPLY" }, \
{ DSBLIT_DEMULTIPLY, "DEMULTIPLY" }, \ { DSBLIT_DEMULTIPLY, "DEMULTIPLY" }, \
{ DSBLIT_DEINTERLACE, "DEINTERLACE" }, \ { DSBLIT_DEINTERLACE, "DEINTERLACE" }, \
{ DSBLIT_SRC_PREMULTCOLOR, "SRC_PREMULTCOLOR" }, \ { DSBLIT_SRC_PREMULTCOLOR, "SRC_PREMULTCOLOR" }, \
{ DSBLIT_XOR, "XOR" }, \ { DSBLIT_XOR, "XOR" }, \
{ DSBLIT_INDEX_TRANSLATION, "INDEX_TRANSLATION" }, \ { DSBLIT_INDEX_TRANSLATION, "INDEX_TRANSLATION" }, \
{ DSBLIT_ROTATE180, "ROTATE180" }, \ { DSBLIT_ROTATE180, "ROTATE180" }, \
{ DSBLIT_COLORKEY_PROTECT, "COLORKEY_PROTECT" }, \ { DSBLIT_COLORKEY_PROTECT, "COLORKEY_PROTECT" }, \
{ DSBLIT_SRC_MASK_ALPHA, "SRC_MASK_ALPHA" }, \ { DSBLIT_SRC_MASK_ALPHA, "SRC_MASK_ALPHA" }, \
{ DSBLIT_SRC_MASK_COLOR, "SRC_MASK_COLOR" }, \ { DSBLIT_SRC_MASK_COLOR, "SRC_MASK_COLOR" }, \
{ DSBLIT_NOFX, "NOFX" } \ { DSBLIT_NOFX, "NOFX" } \
}; };
#define DirectFBSurfaceBlendFunctionNames(Identifier) struct DFBSurfaceBlen struct DFBSurfaceBlendFunctionName {
dFunctionName { \ DFBSurfaceBlendFunction function;
DFBSurfaceBlendFunction function; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBSurfaceBlendFunctionNames(Identifier) struct DFBSurfaceBlen
dFunctionName Identifier[] = { \
{ DSBF_ZERO, "ZERO" }, \ { DSBF_ZERO, "ZERO" }, \
{ DSBF_ONE, "ONE" }, \ { DSBF_ONE, "ONE" }, \
{ DSBF_SRCCOLOR, "SRCCOLOR" }, \ { DSBF_SRCCOLOR, "SRCCOLOR" }, \
{ DSBF_INVSRCCOLOR, "INVSRCCOLOR" }, \ { DSBF_INVSRCCOLOR, "INVSRCCOLOR" }, \
{ DSBF_SRCALPHA, "SRCALPHA" }, \ { DSBF_SRCALPHA, "SRCALPHA" }, \
{ DSBF_INVSRCALPHA, "INVSRCALPHA" }, \ { DSBF_INVSRCALPHA, "INVSRCALPHA" }, \
{ DSBF_DESTALPHA, "DESTALPHA" }, \ { DSBF_DESTALPHA, "DESTALPHA" }, \
{ DSBF_INVDESTALPHA, "INVDESTALPHA" }, \ { DSBF_INVDESTALPHA, "INVDESTALPHA" }, \
{ DSBF_DESTCOLOR, "DESTCOLOR" }, \ { DSBF_DESTCOLOR, "DESTCOLOR" }, \
{ DSBF_INVDESTCOLOR, "INVDESTCOLOR" }, \ { DSBF_INVDESTCOLOR, "INVDESTCOLOR" }, \
{ DSBF_SRCALPHASAT, "SRCALPHASAT" }, \ { DSBF_SRCALPHASAT, "SRCALPHASAT" }, \
{ DSBF_UNKNOWN, "UNKNOWN" } \ { DSBF_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBInputDeviceCapabilitiesNames(Identifier) struct DFBInputDev struct DFBInputDeviceCapabilitiesName {
iceCapabilitiesName { \ DFBInputDeviceCapabilities capability;
DFBInputDeviceCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBInputDeviceCapabilitiesNames(Identifier) struct DFBInputDev
iceCapabilitiesName Identifier[] = { \
{ DICAPS_KEYS, "KEYS" }, \ { DICAPS_KEYS, "KEYS" }, \
{ DICAPS_AXES, "AXES" }, \ { DICAPS_AXES, "AXES" }, \
{ DICAPS_BUTTONS, "BUTTONS" }, \ { DICAPS_BUTTONS, "BUTTONS" }, \
{ DICAPS_NONE, "NONE" } \ { DICAPS_NONE, "NONE" } \
}; };
#define DirectFBDisplayLayerTypeFlagsNames(Identifier) struct DFBDisplayLay struct DFBDisplayLayerTypeFlagsName {
erTypeFlagsName { \ DFBDisplayLayerTypeFlags type;
DFBDisplayLayerTypeFlags type; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBDisplayLayerTypeFlagsNames(Identifier) struct DFBDisplayLay
erTypeFlagsName Identifier[] = { \
{ DLTF_GRAPHICS, "GRAPHICS" }, \ { DLTF_GRAPHICS, "GRAPHICS" }, \
{ DLTF_VIDEO, "VIDEO" }, \ { DLTF_VIDEO, "VIDEO" }, \
{ DLTF_STILL_PICTURE, "STILL_PICTURE" }, \ { DLTF_STILL_PICTURE, "STILL_PICTURE" }, \
{ DLTF_BACKGROUND, "BACKGROUND" }, \ { DLTF_BACKGROUND, "BACKGROUND" }, \
{ DLTF_NONE, "NONE" } \ { DLTF_NONE, "NONE" } \
}; };
#define DirectFBDisplayLayerCapabilitiesNames(Identifier) struct DFBDisplay struct DFBDisplayLayerCapabilitiesName {
LayerCapabilitiesName { \ DFBDisplayLayerCapabilities capability;
DFBDisplayLayerCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBDisplayLayerCapabilitiesNames(Identifier) struct DFBDisplay
LayerCapabilitiesName Identifier[] = { \
{ DLCAPS_SURFACE, "SURFACE" }, \ { DLCAPS_SURFACE, "SURFACE" }, \
{ DLCAPS_OPACITY, "OPACITY" }, \ { DLCAPS_OPACITY, "OPACITY" }, \
{ DLCAPS_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DLCAPS_ALPHACHANNEL, "ALPHACHANNEL" }, \
{ DLCAPS_SCREEN_LOCATION, "SCREEN_LOCATION" }, \ { DLCAPS_SCREEN_LOCATION, "SCREEN_LOCATION" }, \
{ DLCAPS_FLICKER_FILTERING, "FLICKER_FILTERING" }, \ { DLCAPS_FLICKER_FILTERING, "FLICKER_FILTERING" }, \
{ DLCAPS_DEINTERLACING, "DEINTERLACING" }, \ { DLCAPS_DEINTERLACING, "DEINTERLACING" }, \
{ DLCAPS_SRC_COLORKEY, "SRC_COLORKEY" }, \ { DLCAPS_SRC_COLORKEY, "SRC_COLORKEY" }, \
{ DLCAPS_DST_COLORKEY, "DST_COLORKEY" }, \ { DLCAPS_DST_COLORKEY, "DST_COLORKEY" }, \
{ DLCAPS_BRIGHTNESS, "BRIGHTNESS" }, \ { DLCAPS_BRIGHTNESS, "BRIGHTNESS" }, \
{ DLCAPS_CONTRAST, "CONTRAST" }, \ { DLCAPS_CONTRAST, "CONTRAST" }, \
skipping to change at line 155 skipping to change at line 171
{ DLCAPS_WINDOWS, "WINDOWS" }, \ { DLCAPS_WINDOWS, "WINDOWS" }, \
{ DLCAPS_SOURCES, "SOURCES" }, \ { DLCAPS_SOURCES, "SOURCES" }, \
{ DLCAPS_ALPHA_RAMP, "ALPHA_RAMP" }, \ { DLCAPS_ALPHA_RAMP, "ALPHA_RAMP" }, \
{ DLCAPS_PREMULTIPLIED, "PREMULTIPLIED" }, \ { DLCAPS_PREMULTIPLIED, "PREMULTIPLIED" }, \
{ DLCAPS_SCREEN_POSITION, "SCREEN_POSITION" }, \ { DLCAPS_SCREEN_POSITION, "SCREEN_POSITION" }, \
{ DLCAPS_SCREEN_SIZE, "SCREEN_SIZE" }, \ { DLCAPS_SCREEN_SIZE, "SCREEN_SIZE" }, \
{ DLCAPS_CLIP_REGIONS, "CLIP_REGIONS" }, \ { DLCAPS_CLIP_REGIONS, "CLIP_REGIONS" }, \
{ DLCAPS_NONE, "NONE" } \ { DLCAPS_NONE, "NONE" } \
}; };
#define DirectFBDisplayLayerBufferModeNames(Identifier) struct DFBDisplayLa struct DFBDisplayLayerBufferModeName {
yerBufferModeName { \ DFBDisplayLayerBufferMode mode;
DFBDisplayLayerBufferMode mode; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBDisplayLayerBufferModeNames(Identifier) struct DFBDisplayLa
yerBufferModeName Identifier[] = { \
{ DLBM_FRONTONLY, "FRONTONLY" }, \ { DLBM_FRONTONLY, "FRONTONLY" }, \
{ DLBM_BACKVIDEO, "BACKVIDEO" }, \ { DLBM_BACKVIDEO, "BACKVIDEO" }, \
{ DLBM_BACKSYSTEM, "BACKSYSTEM" }, \ { DLBM_BACKSYSTEM, "BACKSYSTEM" }, \
{ DLBM_TRIPLE, "TRIPLE" }, \ { DLBM_TRIPLE, "TRIPLE" }, \
{ DLBM_WINDOWS, "WINDOWS" }, \ { DLBM_WINDOWS, "WINDOWS" }, \
{ DLBM_UNKNOWN, "UNKNOWN" } \ { DLBM_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBWindowCapabilitiesNames(Identifier) struct DFBWindowCapabil struct DFBWindowCapabilitiesName {
itiesName { \ DFBWindowCapabilities capability;
DFBWindowCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBWindowCapabilitiesNames(Identifier) struct DFBWindowCapabil
itiesName Identifier[] = { \
{ DWCAPS_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DWCAPS_ALPHACHANNEL, "ALPHACHANNEL" }, \
{ DWCAPS_DOUBLEBUFFER, "DOUBLEBUFFER" }, \ { DWCAPS_DOUBLEBUFFER, "DOUBLEBUFFER" }, \
{ DWCAPS_INPUTONLY, "INPUTONLY" }, \ { DWCAPS_INPUTONLY, "INPUTONLY" }, \
{ DWCAPS_NODECORATION, "NODECORATION" }, \ { DWCAPS_NODECORATION, "NODECORATION" }, \
{ DWCAPS_NOFOCUS, "NOFOCUS" }, \
{ DWCAPS_NONE, "NONE" } \ { DWCAPS_NONE, "NONE" } \
}; };
#define DirectFBWindowOptionsNames(Identifier) struct DFBWindowOptionsName struct DFBWindowOptionsName {
{ \ DFBWindowOptions option;
DFBWindowOptions option; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBWindowOptionsNames(Identifier) struct DFBWindowOptionsName
Identifier[] = { \
{ DWOP_COLORKEYING, "COLORKEYING" }, \ { DWOP_COLORKEYING, "COLORKEYING" }, \
{ DWOP_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DWOP_ALPHACHANNEL, "ALPHACHANNEL" }, \
{ DWOP_OPAQUE_REGION, "OPAQUE_REGION" }, \ { DWOP_OPAQUE_REGION, "OPAQUE_REGION" }, \
{ DWOP_SHAPED, "SHAPED" }, \ { DWOP_SHAPED, "SHAPED" }, \
{ DWOP_ALPHACHANNEL, "ALPHACHANNEL" }, \ { DWOP_ALPHACHANNEL, "ALPHACHANNEL" }, \
{ DWOP_KEEP_POSITION, "KEEP_POSITION" }, \ { DWOP_KEEP_POSITION, "KEEP_POSITION" }, \
{ DWOP_KEEP_SIZE, "KEEP_SIZE" }, \ { DWOP_KEEP_SIZE, "KEEP_SIZE" }, \
{ DWOP_KEEP_STACKING, "KEEP_STACKING" }, \ { DWOP_KEEP_STACKING, "KEEP_STACKING" }, \
{ DWOP_GHOST, "GHOST" }, \ { DWOP_GHOST, "GHOST" }, \
{ DWOP_INDESTRUCTIBLE, "INDESTRUCTIBLE" }, \ { DWOP_INDESTRUCTIBLE, "INDESTRUCTIBLE" }, \
{ DWOP_SCALE, "SCALE" }, \ { DWOP_SCALE, "SCALE" }, \
{ DWOP_KEEP_ABOVE, "KEEP_ABOVE" }, \ { DWOP_KEEP_ABOVE, "KEEP_ABOVE" }, \
{ DWOP_KEEP_UNDER, "KEEP_UNDER" }, \ { DWOP_KEEP_UNDER, "KEEP_UNDER" }, \
{ DWOP_NONE, "NONE" } \ { DWOP_NONE, "NONE" } \
}; };
#define DirectFBScreenCapabilitiesNames(Identifier) struct DFBScreenCapabil struct DFBScreenCapabilitiesName {
itiesName { \ DFBScreenCapabilities capability;
DFBScreenCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenCapabilitiesNames(Identifier) struct DFBScreenCapabil
itiesName Identifier[] = { \
{ DSCCAPS_VSYNC, "VSYNC" }, \ { DSCCAPS_VSYNC, "VSYNC" }, \
{ DSCCAPS_POWER_MANAGEMENT, "POWER_MANAGEMENT" }, \ { DSCCAPS_POWER_MANAGEMENT, "POWER_MANAGEMENT" }, \
{ DSCCAPS_MIXERS, "MIXERS" }, \ { DSCCAPS_MIXERS, "MIXERS" }, \
{ DSCCAPS_ENCODERS, "ENCODERS" }, \ { DSCCAPS_ENCODERS, "ENCODERS" }, \
{ DSCCAPS_OUTPUTS, "OUTPUTS" }, \ { DSCCAPS_OUTPUTS, "OUTPUTS" }, \
{ DSCCAPS_NONE, "NONE" } \ { DSCCAPS_NONE, "NONE" } \
}; };
#define DirectFBScreenEncoderCapabilitiesNames(Identifier) struct DFBScreen struct DFBScreenEncoderCapabilitiesName {
EncoderCapabilitiesName { \ DFBScreenEncoderCapabilities capability;
DFBScreenEncoderCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenEncoderCapabilitiesNames(Identifier) struct DFBScreen
EncoderCapabilitiesName Identifier[] = { \
{ DSECAPS_TV_STANDARDS, "TV_STANDARDS" }, \ { DSECAPS_TV_STANDARDS, "TV_STANDARDS" }, \
{ DSECAPS_TEST_PICTURE, "TEST_PICTURE" }, \ { DSECAPS_TEST_PICTURE, "TEST_PICTURE" }, \
{ DSECAPS_MIXER_SEL, "MIXER_SEL" }, \ { DSECAPS_MIXER_SEL, "MIXER_SEL" }, \
{ DSECAPS_OUT_SIGNALS, "OUT_SIGNALS" }, \ { DSECAPS_OUT_SIGNALS, "OUT_SIGNALS" }, \
{ DSECAPS_SCANMODE, "SCANMODE" }, \ { DSECAPS_SCANMODE, "SCANMODE" }, \
{ DSECAPS_FREQUENCY, "FREQUENCY" }, \ { DSECAPS_FREQUENCY, "FREQUENCY" }, \
{ DSECAPS_BRIGHTNESS, "BRIGHTNESS" }, \ { DSECAPS_BRIGHTNESS, "BRIGHTNESS" }, \
{ DSECAPS_CONTRAST, "CONTRAST" }, \ { DSECAPS_CONTRAST, "CONTRAST" }, \
{ DSECAPS_HUE, "HUE" }, \ { DSECAPS_HUE, "HUE" }, \
{ DSECAPS_SATURATION, "SATURATION" }, \ { DSECAPS_SATURATION, "SATURATION" }, \
{ DSECAPS_CONNECTORS, "CONNECTORS" }, \ { DSECAPS_CONNECTORS, "CONNECTORS" }, \
{ DSECAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \ { DSECAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \
{ DSECAPS_RESOLUTION, "RESOLUTION" }, \ { DSECAPS_RESOLUTION, "RESOLUTION" }, \
{ DSECAPS_NONE, "NONE" } \ { DSECAPS_NONE, "NONE" } \
}; };
#define DirectFBScreenEncoderTypeNames(Identifier) struct DFBScreenEncoderT struct DFBScreenEncoderTypeName {
ypeName { \ DFBScreenEncoderType type;
DFBScreenEncoderType type; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenEncoderTypeNames(Identifier) struct DFBScreenEncoderT
ypeName Identifier[] = { \
{ DSET_CRTC, "CRTC" }, \ { DSET_CRTC, "CRTC" }, \
{ DSET_TV, "TV" }, \ { DSET_TV, "TV" }, \
{ DSET_DIGITAL, "DIGITAL" }, \ { DSET_DIGITAL, "DIGITAL" }, \
{ DSET_UNKNOWN, "UNKNOWN" } \ { DSET_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBScreenEncoderTVStandardsNames(Identifier) struct DFBScreenE struct DFBScreenEncoderTVStandardsName {
ncoderTVStandardsName { \ DFBScreenEncoderTVStandards standard;
DFBScreenEncoderTVStandards standard; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenEncoderTVStandardsNames(Identifier) struct DFBScreenE
ncoderTVStandardsName Identifier[] = { \
{ DSETV_PAL, "PAL" }, \ { DSETV_PAL, "PAL" }, \
{ DSETV_NTSC, "NTSC" }, \ { DSETV_NTSC, "NTSC" }, \
{ DSETV_SECAM, "SECAM" }, \ { DSETV_SECAM, "SECAM" }, \
{ DSETV_PAL_60, "PAL_60" }, \ { DSETV_PAL_60, "PAL_60" }, \
{ DSETV_PAL_BG, "PAL_BG" }, \ { DSETV_PAL_BG, "PAL_BG" }, \
{ DSETV_PAL_I, "PAL_I" }, \ { DSETV_PAL_I, "PAL_I" }, \
{ DSETV_PAL_M, "PAL_M" }, \ { DSETV_PAL_M, "PAL_M" }, \
{ DSETV_PAL_N, "PAL_N" }, \ { DSETV_PAL_N, "PAL_N" }, \
{ DSETV_PAL_NC, "PAL_NC" }, \ { DSETV_PAL_NC, "PAL_NC" }, \
{ DSETV_NTSC_M_JPN, "NTSC_M_JPN" }, \ { DSETV_NTSC_M_JPN, "NTSC_M_JPN" }, \
{ DSETV_DIGITAL, "DIGITAL" }, \ { DSETV_DIGITAL, "DIGITAL" }, \
{ DSETV_UNKNOWN, "UNKNOWN" } \ { DSETV_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBScreenOutputCapabilitiesNames(Identifier) struct DFBScreenO struct DFBScreenOutputCapabilitiesName {
utputCapabilitiesName { \ DFBScreenOutputCapabilities capability;
DFBScreenOutputCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenOutputCapabilitiesNames(Identifier) struct DFBScreenO
utputCapabilitiesName Identifier[] = { \
{ DSOCAPS_CONNECTORS, "CONNECTORS" }, \ { DSOCAPS_CONNECTORS, "CONNECTORS" }, \
{ DSOCAPS_ENCODER_SEL, "ENCODER_SEL" }, \ { DSOCAPS_ENCODER_SEL, "ENCODER_SEL" }, \
{ DSOCAPS_SIGNAL_SEL, "SIGNAL_SEL" }, \ { DSOCAPS_SIGNAL_SEL, "SIGNAL_SEL" }, \
{ DSOCAPS_CONNECTOR_SEL, "CONNECTOR_SEL" }, \ { DSOCAPS_CONNECTOR_SEL, "CONNECTOR_SEL" }, \
{ DSOCAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \ { DSOCAPS_SLOW_BLANKING, "SLOW_BLANKING" }, \
{ DSOCAPS_RESOLUTION, "RESOLUTION" }, \ { DSOCAPS_RESOLUTION, "RESOLUTION" }, \
{ DSOCAPS_NONE, "NONE" } \ { DSOCAPS_NONE, "NONE" } \
}; };
#define DirectFBScreenOutputConnectorsNames(Identifier) struct DFBScreenOut struct DFBScreenOutputConnectorsName {
putConnectorsName { \ DFBScreenOutputConnectors connector;
DFBScreenOutputConnectors connector; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenOutputConnectorsNames(Identifier) struct DFBScreenOut
putConnectorsName Identifier[] = { \
{ DSOC_VGA, "VGA" }, \ { DSOC_VGA, "VGA" }, \
{ DSOC_SCART, "SCART" }, \ { DSOC_SCART, "SCART" }, \
{ DSOC_YC, "YC" }, \ { DSOC_YC, "YC" }, \
{ DSOC_CVBS, "CVBS" }, \ { DSOC_CVBS, "CVBS" }, \
{ DSOC_SCART2, "SCART2" }, \ { DSOC_SCART2, "SCART2" }, \
{ DSOC_COMPONENT, "COMPONENT" }, \ { DSOC_COMPONENT, "COMPONENT" }, \
{ DSOC_HDMI, "HDMI" }, \ { DSOC_HDMI, "HDMI" }, \
{ DSOC_UNKNOWN, "UNKNOWN" } \ { DSOC_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBScreenOutputSignalsNames(Identifier) struct DFBScreenOutput struct DFBScreenOutputSignalsName {
SignalsName { \ DFBScreenOutputSignals signal;
DFBScreenOutputSignals signal; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenOutputSignalsNames(Identifier) struct DFBScreenOutput
SignalsName Identifier[] = { \
{ DSOS_VGA, "VGA" }, \ { DSOS_VGA, "VGA" }, \
{ DSOS_YC, "YC" }, \ { DSOS_YC, "YC" }, \
{ DSOS_CVBS, "CVBS" }, \ { DSOS_CVBS, "CVBS" }, \
{ DSOS_RGB, "RGB" }, \ { DSOS_RGB, "RGB" }, \
{ DSOS_YCBCR, "YCBCR" }, \ { DSOS_YCBCR, "YCBCR" }, \
{ DSOS_HDMI, "HDMI" }, \ { DSOS_HDMI, "HDMI" }, \
{ DSOS_656, "656" }, \ { DSOS_656, "656" }, \
{ DSOS_NONE, "NONE" } \ { DSOS_NONE, "NONE" } \
}; };
#define DirectFBScreenOutputSlowBlankingSignalsNames(Identifier) struct DFB struct DFBScreenOutputSlowBlankingSignalsName {
ScreenOutputSlowBlankingSignalsName { \ DFBScreenOutputSlowBlankingSignals slow_signal;
DFBScreenOutputSlowBlankingSignals slow_signal; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenOutputSlowBlankingSignalsNames(Identifier) struct DFB
ScreenOutputSlowBlankingSignalsName Identifier[] = { \
{ DSOSB_16x9, "16x9" }, \ { DSOSB_16x9, "16x9" }, \
{ DSOSB_4x3, "4x3" }, \ { DSOSB_4x3, "4x3" }, \
{ DSOSB_FOLLOW, "FOLLOW" }, \ { DSOSB_FOLLOW, "FOLLOW" }, \
{ DSOSB_MONITOR, "MONITOR" }, \ { DSOSB_MONITOR, "MONITOR" }, \
{ DSOSB_OFF, "OFF" } \ { DSOSB_OFF, "OFF" } \
}; };
#define DirectFBScreenOutputResolutionNames(Identifier) struct DFBScreenOut struct DFBScreenOutputResolutionName {
putResolutionName { \ DFBScreenOutputResolution resolution;
DFBScreenOutputResolution resolution; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenOutputResolutionNames(Identifier) struct DFBScreenOut
putResolutionName Identifier[] = { \
{ DSOR_640_480, "640_480" }, \ { DSOR_640_480, "640_480" }, \
{ DSOR_720_480, "720_480" }, \ { DSOR_720_480, "720_480" }, \
{ DSOR_720_576, "720_576" }, \ { DSOR_720_576, "720_576" }, \
{ DSOR_800_600, "800_600" }, \ { DSOR_800_600, "800_600" }, \
{ DSOR_1024_768, "1024_768" }, \ { DSOR_1024_768, "1024_768" }, \
{ DSOR_1152_864, "1152_864" }, \ { DSOR_1152_864, "1152_864" }, \
{ DSOR_1280_720, "1280_720" }, \ { DSOR_1280_720, "1280_720" }, \
{ DSOR_1280_768, "1280_768" }, \ { DSOR_1280_768, "1280_768" }, \
{ DSOR_1280_960, "1280_960" }, \ { DSOR_1280_960, "1280_960" }, \
{ DSOR_1280_1024, "1280_1024" }, \ { DSOR_1280_1024, "1280_1024" }, \
{ DSOR_1400_1050, "1400_1050" }, \ { DSOR_1400_1050, "1400_1050" }, \
{ DSOR_1600_1200, "1600_1200" }, \ { DSOR_1600_1200, "1600_1200" }, \
{ DSOR_1920_1080, "1920_1080" }, \ { DSOR_1920_1080, "1920_1080" }, \
{ DSOR_UNKNOWN, "UNKNOWN" } \ { DSOR_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBScreenMixerCapabilitiesNames(Identifier) struct DFBScreenMi struct DFBScreenMixerCapabilitiesName {
xerCapabilitiesName { \ DFBScreenMixerCapabilities capability;
DFBScreenMixerCapabilities capability; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenMixerCapabilitiesNames(Identifier) struct DFBScreenMi
xerCapabilitiesName Identifier[] = { \
{ DSMCAPS_FULL, "FULL" }, \ { DSMCAPS_FULL, "FULL" }, \
{ DSMCAPS_SUB_LEVEL, "SUB_LEVEL" }, \ { DSMCAPS_SUB_LEVEL, "SUB_LEVEL" }, \
{ DSMCAPS_SUB_LAYERS, "SUB_LAYERS" }, \ { DSMCAPS_SUB_LAYERS, "SUB_LAYERS" }, \
{ DSMCAPS_BACKGROUND, "BACKGROUND" }, \ { DSMCAPS_BACKGROUND, "BACKGROUND" }, \
{ DSMCAPS_NONE, "NONE" } \ { DSMCAPS_NONE, "NONE" } \
}; };
#define DirectFBScreenMixerTreeNames(Identifier) struct DFBScreenMixerTreeN struct DFBScreenMixerTreeName {
ame { \ DFBScreenMixerTree tree;
DFBScreenMixerTree tree; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenMixerTreeNames(Identifier) struct DFBScreenMixerTreeN
ame Identifier[] = { \
{ DSMT_FULL, "FULL" }, \ { DSMT_FULL, "FULL" }, \
{ DSMT_SUB_LEVEL, "SUB_LEVEL" }, \ { DSMT_SUB_LEVEL, "SUB_LEVEL" }, \
{ DSMT_SUB_LAYERS, "SUB_LAYERS" }, \ { DSMT_SUB_LAYERS, "SUB_LAYERS" }, \
{ DSMT_UNKNOWN, "UNKNOWN" } \ { DSMT_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBScreenEncoderTestPictureNames(Identifier) struct DFBScreenE struct DFBScreenEncoderTestPictureName {
ncoderTestPictureName { \ DFBScreenEncoderTestPicture test_picture;
DFBScreenEncoderTestPicture test_picture; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenEncoderTestPictureNames(Identifier) struct DFBScreenE
ncoderTestPictureName Identifier[] = { \
{ DSETP_MULTI, "MULTI" }, \ { DSETP_MULTI, "MULTI" }, \
{ DSETP_SINGLE, "SINGLE" }, \ { DSETP_SINGLE, "SINGLE" }, \
{ DSETP_WHITE, "WHITE" }, \ { DSETP_WHITE, "WHITE" }, \
{ DSETP_YELLOW, "YELLOW" }, \ { DSETP_YELLOW, "YELLOW" }, \
{ DSETP_CYAN, "CYAN" }, \ { DSETP_CYAN, "CYAN" }, \
{ DSETP_GREEN, "GREEN" }, \ { DSETP_GREEN, "GREEN" }, \
{ DSETP_MAGENTA, "MAGENTA" }, \ { DSETP_MAGENTA, "MAGENTA" }, \
{ DSETP_RED, "RED" }, \ { DSETP_RED, "RED" }, \
{ DSETP_BLUE, "BLUE" }, \ { DSETP_BLUE, "BLUE" }, \
{ DSETP_BLACK, "BLACK" }, \ { DSETP_BLACK, "BLACK" }, \
{ DSETP_OFF, "OFF" } \ { DSETP_OFF, "OFF" } \
}; };
#define DirectFBScreenEncoderScanModeNames(Identifier) struct DFBScreenEnco struct DFBScreenEncoderScanModeName {
derScanModeName { \ DFBScreenEncoderScanMode scan_mode;
DFBScreenEncoderScanMode scan_mode; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBScreenEncoderScanModeNames(Identifier) struct DFBScreenEnco
derScanModeName Identifier[] = { \
{ DSESM_INTERLACED, "INTERLACED" }, \ { DSESM_INTERLACED, "INTERLACED" }, \
{ DSESM_PROGRESSIVE, "PROGRESSIVE" }, \ { DSESM_PROGRESSIVE, "PROGRESSIVE" }, \
{ DSESM_UNKNOWN, "UNKNOWN" } \ { DSESM_UNKNOWN, "UNKNOWN" } \
}; };
#define DirectFBAccelerationMaskNames(Identifier) struct DFBAccelerationMas struct DFBAccelerationMaskName {
kName { \ DFBAccelerationMask mask;
DFBAccelerationMask mask; \ const char *name;
const char *name; \ };
} Identifier[] = { \
#define DirectFBAccelerationMaskNames(Identifier) struct DFBAccelerationMas
kName Identifier[] = { \
{ DFXL_FILLRECTANGLE, "FILLRECTANGLE" }, \ { DFXL_FILLRECTANGLE, "FILLRECTANGLE" }, \
{ DFXL_DRAWRECTANGLE, "DRAWRECTANGLE" }, \ { DFXL_DRAWRECTANGLE, "DRAWRECTANGLE" }, \
{ DFXL_DRAWLINE, "DRAWLINE" }, \ { DFXL_DRAWLINE, "DRAWLINE" }, \
{ DFXL_FILLTRIANGLE, "FILLTRIANGLE" }, \ { DFXL_FILLTRIANGLE, "FILLTRIANGLE" }, \
{ DFXL_BLIT, "BLIT" }, \ { DFXL_BLIT, "BLIT" }, \
{ DFXL_STRETCHBLIT, "STRETCHBLIT" }, \ { DFXL_STRETCHBLIT, "STRETCHBLIT" }, \
{ DFXL_TEXTRIANGLES, "TEXTRIANGLES" }, \ { DFXL_TEXTRIANGLES, "TEXTRIANGLES" }, \
{ DFXL_DRAWSTRING, "DRAWSTRING" }, \ { DFXL_DRAWSTRING, "DRAWSTRING" }, \
{ DFXL_NONE, "NONE" } \ { DFXL_NONE, "NONE" } \
}; };
 End of changes. 26 change blocks. 
124 lines changed or deleted 176 lines changed or added


 directfb_util.h   directfb_util.h 
skipping to change at line 42 skipping to change at line 42
#include <stdlib.h> #include <stdlib.h>
#include <errno.h> #include <errno.h>
#include <directfb.h> #include <directfb.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
#include <directfb_strings.h>
#include <direct/types.h> #include <direct/types.h>
#include <direct/debug.h> #include <direct/debug.h>
bool dfb_region_intersect( DFBRegion *region, bool dfb_region_intersect( DFBRegion *region,
int x1, int y1, int x2, int y2 ); int x1, int y1, int x2, int y2 );
bool dfb_region_region_intersect( DFBRegion *region, bool dfb_region_region_intersect( DFBRegion *region,
const DFBRegion *clip ); const DFBRegion *clip );
bool dfb_region_rectangle_intersect( DFBRegion *region, bool dfb_region_rectangle_intersect( DFBRegion *region,
skipping to change at line 393 skipping to change at line 395
return false; return false;
if (x) if (x)
*x = (s64)(x2 - x1) * num / den + x1; *x = (s64)(x2 - x1) * num / den + x1;
if (y) if (y)
*y = (s64)(y2 - y1) * num / den + y1; *y = (s64)(y2 - y1) * num / den + y1;
return true; return true;
} }
/*
* Copied declaration of DFBPixelFormatName from directfb_strings.h
*/
extern const struct DFBPixelFormatName dfb_pixelformat_names[];
const char *dfb_input_event_type_name ( DFBInputEventType type ); const char *dfb_input_event_type_name ( DFBInputEventType type );
const char *dfb_pixelformat_name ( DFBSurfacePixelFormat format ); const char *dfb_pixelformat_name ( DFBSurfacePixelFormat format );
const char *dfb_window_event_type_name( DFBWindowEventType type ); const char *dfb_window_event_type_name( DFBWindowEventType type );
typedef struct { typedef struct {
int magic; int magic;
DFBRegion *regions; DFBRegion *regions;
int max_regions; int max_regions;
int num_regions; int num_regions;
 End of changes. 2 change blocks. 
0 lines changed or deleted 7 lines changed or added


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


 input.h   input.h 
skipping to change at line 77 skipping to change at line 77
typedef struct { typedef struct {
unsigned int prefered_id; /* Prefered predefined input device i d, unsigned int prefered_id; /* Prefered predefined input device i d,
e.g. DIDID_MOUSE */ e.g. DIDID_MOUSE */
DFBInputDeviceDescription desc; /* Capabilities, type, etc. */ DFBInputDeviceDescription desc; /* Capabilities, type, etc. */
} InputDeviceInfo; } InputDeviceInfo;
typedef struct { typedef struct {
int (*GetAvailable) (void); int (*GetAvailable) (void);
void (*GetDriverInfo) (InputDriverInfo *driver_info); void (*GetDriverInfo) (InputDriverInfo *driver_info
DFBResult (*OpenDevice) (CoreInputDevice *device, );
unsigned int number, DFBResult (*OpenDevice) (CoreInputDevice *device,
InputDeviceInfo *device_info, unsigned int number,
void **driver_data); InputDeviceInfo *device_info
DFBResult (*GetKeymapEntry) (CoreInputDevice *device, ,
void *driver_data, void **driver_data
DFBInputDeviceKeymapEntry *entry); );
void (*CloseDevice) (void *driver_data); DFBResult (*GetKeymapEntry) (CoreInputDevice *device,
void *driver_data
,
DFBInputDeviceKeymapEntry *entry);
void (*CloseDevice) (void *driver_data
);
DFBResult (*GetAxisInfo) (CoreInputDevice *device,
void *driver_data
,
DFBInputDeviceAxisIdentifier axis,
DFBInputDeviceAxisInfo *ret_info);
} InputDriverFuncs; } InputDriverFuncs;
typedef DFBEnumerationResult (*InputDeviceCallback) (CoreInputDevice *devic e, typedef DFBEnumerationResult (*InputDeviceCallback) (CoreInputDevice *devic e,
void *ctx); void *ctx);
void dfb_input_enumerate_devices( InputDeviceCallback callback, void dfb_input_enumerate_devices( InputDeviceCallback callback,
void *ctx, void *ctx,
DFBInputDeviceCapabilities caps ); DFBInputDeviceCapabilities caps );
DirectResult dfb_input_attach ( CoreInputDevice *device, DirectResult dfb_input_attach ( CoreInputDevice *device,
 End of changes. 1 change blocks. 
9 lines changed or deleted 20 lines changed or added


 input_driver.h   input_driver.h 
skipping to change at line 51 skipping to change at line 51
driver_open_device( CoreInputDevice *device, driver_open_device( CoreInputDevice *device,
unsigned int number, unsigned int number,
InputDeviceInfo *info, InputDeviceInfo *info,
void **driver_data ); void **driver_data );
static DFBResult static DFBResult
driver_get_keymap_entry( CoreInputDevice *device, driver_get_keymap_entry( CoreInputDevice *device,
void *driver_data, void *driver_data,
DFBInputDeviceKeymapEntry *entry ); DFBInputDeviceKeymapEntry *entry );
#ifdef DFB_INPUTDRIVER_HAS_AXIS_INFO
static DFBResult
driver_get_axis_info( CoreInputDevice *device,
void *driver_data,
DFBInputDeviceAxisIdentifier axis,
DFBInputDeviceAxisInfo *ret_info );
#endif
static void static void
driver_close_device( void *driver_data ); driver_close_device( void *driver_data );
static const InputDriverFuncs driver_funcs = { static const InputDriverFuncs driver_funcs = {
.GetAvailable = driver_get_available, .GetAvailable = driver_get_available,
.GetDriverInfo = driver_get_info, .GetDriverInfo = driver_get_info,
.OpenDevice = driver_open_device, .OpenDevice = driver_open_device,
.GetKeymapEntry = driver_get_keymap_entry, .GetKeymapEntry = driver_get_keymap_entry,
.CloseDevice = driver_close_device .CloseDevice = driver_close_device,
#ifdef DFB_INPUTDRIVER_HAS_AXIS_INFO
.GetAxisInfo = driver_get_axis_info
#endif
}; };
#define DFB_INPUT_DRIVER(shortname) \ #define DFB_INPUT_DRIVER(shortname) \
__attribute__((constructor)) void directfb_##shortname(); \ __attribute__((constructor)) void directfb_##shortname(); \
\ \
void \ void \
directfb_##shortname() \ directfb_##shortname() \
{ \ { \
direct_modules_register( &dfb_input_modules, DFB_INPUT_DRIVER_ABI_VERS ION, \ direct_modules_register( &dfb_input_modules, DFB_INPUT_DRIVER_ABI_VERS ION, \
#shortname, &driver_funcs ); \ #shortname, &driver_funcs ); \
 End of changes. 2 change blocks. 
1 lines changed or deleted 13 lines changed or added


 interface_implementation.h   interface_implementation.h 
skipping to change at line 69 skipping to change at line 69
\ \
static DirectResult \ static DirectResult \
Allocate( void **interface ) \ Allocate( void **interface ) \
{ \ { \
DIRECT_ALLOCATE_INTERFACE( *interface, type ); \ DIRECT_ALLOCATE_INTERFACE( *interface, type ); \
return DR_OK; \ return DR_OK; \
} \ } \
\ \
__attribute__((constructor)) \ __attribute__((constructor)) \
void \ void \
type##_##impl_ctor(void) \ type##_##impl##_ctor(void) \
{ \ { \
DirectRegisterInterface( &interface_funcs ); \ DirectRegisterInterface( &interface_funcs ); \
} \ } \
\ \
__attribute__((destructor)) \ __attribute__((destructor)) \
void \ void \
type##_##impl_dtor(void) \ type##_##impl##_dtor(void) \
{ \ { \
DirectUnregisterInterface( &interface_funcs ); \ DirectUnregisterInterface( &interface_funcs ); \
} }
#endif #endif
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 surface_buffer.h   surface_buffer.h 
skipping to change at line 154 skipping to change at line 154
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)->buffer) { \
D_ASSERT( (lock)->allocation != NULL ); \ D_ASSERT( (lock)->allocation != NULL ); \
D_ASSERT( (lock)->buffer == (lock)->allocation->buffer ); \ D_ASSERT( (lock)->buffer == (lock)->allocation->buffer ); \
D_ASSUME( (lock)->addr != NULL || \ D_ASSUME( (lock)->addr != NULL || \
!((lock)->access & (CSAF_CPU_READ|CSAF_CPU_WRITE)) ); \ !((lock)->access & (CSAF_CPU_READ|CSAF_CPU_WRITE)) ); \
D_ASSUME( (lock)->phys != 0 || (lock)->offset != ~0 || (lock )->handle != NULL || \ D_ASSUME( (lock)->phys != 0 || (lock)->offset != ~0 || (lock )->handle != NULL || \
!((lock)->access & (CSAF_GPU_READ|CSAF_GPU_WRITE)) ); \ !((lock)->access & (CSAF_GPU_READ|CSAF_GPU_WRITE)) ); \
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 ); \ D_ASSERT( (lock)->pitch > 0 || ((lock)->addr == NULL && (loc k)->phys == 0) ); \
} \ } \
else { \ else { \
D_ASSERT( (lock)->allocation == NULL ); \ D_ASSERT( (lock)->allocation == 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)
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 trace.h   trace.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 __DIRECT__TRACE_H__ #ifndef __DIRECT__TRACE_H__
#define __DIRECT__TRACE_H__ #define __DIRECT__TRACE_H__
#include <direct/types.h> #include <direct/types.h>
/**************************************************************************
*********************************************
** Symbols
*/
/*
* Returns filename on success or NULL.
*
* Stores load address of object in 'ret_base' on success.
*/
const char *direct_trace_lookup_file ( void *address,
void **ret_base );
/*
* Look up a symbol by filename and offset.
*
* Returns symbol name on success or NULL.
*/
const char *direct_trace_lookup_symbol( const char *filename,
long offset );
/*
* Convenience function combining direct_trace_lookup_file() and direct_tra
ce_lookup_symbol().
*/
static inline const char *
direct_trace_lookup_symbol_at( void *address )
{
void *base;
const char *filename;
filename = direct_trace_lookup_file( address, &base );
return direct_trace_lookup_symbol( filename, (unsigned long) address -
(unsigned long) base );
}
/**************************************************************************
*********************************************
** Stacks
*/
/*
* Print stack in 'buffer' or current if NULL.
*/
void direct_trace_print_stack( DirectTraceBuffer *buffer ); void direct_trace_print_stack( DirectTraceBuffer *buffer );
/*
* Print stack of each known thread.
*/
void direct_trace_print_stacks( void ); void direct_trace_print_stacks( void );
/*
* Returns indent level for debug output.
*/
int direct_trace_debug_indent( void ); int direct_trace_debug_indent( void );
/*
* Create a copy of a stack in 'buffer' or of current if NULL.
*/
DirectTraceBuffer *direct_trace_copy_buffer( DirectTraceBuffer *buffer ); DirectTraceBuffer *direct_trace_copy_buffer( DirectTraceBuffer *buffer );
/*
* Free a (copied) stack buffer.
*/
void direct_trace_free_buffer( DirectTraceBuffer *buffer ); void direct_trace_free_buffer( DirectTraceBuffer *buffer );
#endif #endif
 End of changes. 5 change blocks. 
0 lines changed or deleted 59 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/