Skip to content
This repository has been archived by the owner. It is now read-only.
Permalink
Browse files

Support for HID devices (mice and keyboards only for now) has been added

  • Loading branch information
llmike committed Apr 28, 2009
1 parent 5ccd5e6 commit 7c54f601447a71e25a4a2490fad8e1b846752454

Large diffs are not rendered by default.

@@ -0,0 +1,165 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
QNX Graphics Framework SDL driver
Copyright (C) 2009 Mike Gorchak
(mike@malva.ua, lestat@i.com.ua)
*/

#ifndef __SDL_GF_INPUT_H__
#define __SDL_GF_INPUT_H__

#include "SDL_config.h"
#include "SDL_video.h"
#include "../SDL_sysvideo.h"

#include <errno.h>

#include <gf/gf.h>

#include <sys/hiddi.h>
#include <sys/hidut.h>

#include "SDL_qnxgf.h"

typedef struct SDL_MouseData
{
SDL_DisplayData* didata;
} SDL_MouseData;

int32_t gf_addinputdevices(_THIS);
int32_t gf_delinputdevices(_THIS);

#define SDL_GF_MOUSE_COLOR_BLACK 0xFF000000
#define SDL_GF_MOUSE_COLOR_WHITE 0xFFFFFFFF
#define SDL_GF_MOUSE_COLOR_TRANS 0x00000000

/*****************************************************************************/
/* This is HIDDI closed interface declarations */
/*****************************************************************************/
#define HID_TYPE_MAIN 0x0
#define HID_TYPE_GLOBAL 0x1
#define HID_TYPE_LOCAL 0x2
#define HID_TYPE_RESERVED 0x3

#define HID_GLOBAL_USAGE_PAGE 0x0
#define HID_LOCAL_USAGE 0x0

typedef struct _hid_byte
{
uint8_t HIDB_Length;
uint8_t HIDB_Type;
uint8_t HIDB_Tag;
uint8_t reserved[1];
} hid_byte_t;

typedef struct _hidd_global_item
{
uint16_t usage_page;
uint16_t logical_min;
uint16_t logical_max;
uint16_t physical_min;
uint16_t physical_max;
uint16_t unit_expo;
uint16_t unit;
uint16_t report_size;
uint16_t report_id;
uint16_t report_count;
} hidd_global_item_t;

typedef struct _hidd_local_item
{
uint16_t type;
uint8_t reserved[2];
uint32_t value;
struct _hidd_local_item* next_local;
struct _hidd_local_item* alt_local;
} hidd_local_item_t;

typedef struct _hidd_local_table
{
hidd_local_item_t* usage_info;
hidd_local_item_t* designator_info;
hidd_local_item_t* string_info;
uint8_t delimiter;
uint8_t reserved[3];
} hidd_local_table_t;

typedef struct _hidd_field
{
struct hidd_report_instance* report;
struct hidd_collection* collection;
uint16_t report_offset;
uint16_t flags;
hidd_global_item_t gitem;
hidd_local_table_t* ltable;
struct _hidd_field* next_field;
void* user;
} hidd_field_t;

typedef struct hidd_report_instance
{
uint8_t report_id;
uint8_t reserved[1];
uint16_t report_type;
hidd_field_t* field;
uint16_t num_field;
uint16_t byte_len;
uint16_t bit_len;
uint8_t reserved2[2];
struct hidd_collection* collection;
struct hidd_report_instance* next_col_report;
struct hidd_report_instance* next_report;
} hidd_report_instance_t;

typedef struct hidd_report
{
TAILQ_ENTRY(hidd_report) link;
hidd_report_instance_t* rinst;
hidd_device_instance_t* dev_inst;
uint32_t flags;
struct hidd_connection* connection;
void* user;
} hidd_report_t;

typedef struct hidview_device
{
struct hidd_report_instance* instance;
struct hidd_report* report;
} hidview_device_t;

/*****************************************************************************/
/* Closed HIDDI interface declarations end */
/*****************************************************************************/

/* Maximum devices and subdevices amount per host */
#define SDL_HIDDI_MAX_DEVICES 64

/* Detected device/subdevice type for SDL */
#define SDL_GF_HIDDI_NONE 0x00000000
#define SDL_GF_HIDDI_MOUSE 0x00000001
#define SDL_GF_HIDDI_KEYBOARD 0x00000002
#define SDL_GF_HIDDI_JOYSTICK 0x00000003

extern void hiddi_enable_mouse();
extern void hiddi_disable_mouse();

#endif /* __SDL_GF_INPUT_H__ */
@@ -1,8 +1,3 @@
Date: Mon, 23 Mar 2009 09:17:24 +0200
From: "Mike Gorchak" <mike@malva.ua>
To: "Sam Lantinga" <slouken@devolution.com>
Subject: New QNX patches

/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
@@ -53,4 +48,3 @@ GLAPI void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte
glColor4f(((GLfloat)red)/255.f, ((GLfloat)green)/255.f, ((GLfloat)blue)/255.f, ((GLfloat)alpha)/255.f);
return;
}

@@ -0,0 +1,37 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
QNX Graphics Framework SDL driver
Copyright (C) 2009 Mike Gorchak
(mike@malva.ua, lestat@i.com.ua)
*/

#ifndef __SDL_GF_OPENGLES_H__
#define __SDL_GF_OPENGLES_H__

#include <GLES/gl.h>
#include <GLES/glext.h>

GLAPI void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
GLAPI void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);

#endif /* __SDL_GF_OPENGLES_H__ */
@@ -35,24 +35,24 @@
#include "SDL_qnxgf.h"

static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags);
static int gf_displaymodechanged(SDL_Renderer* renderer);
static int gf_activaterenderer(SDL_Renderer* renderer);
static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch);
static int gf_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors);
static int gf_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors);
static int gf_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch);
static int gf_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch);
static int gf_displaymodechanged(SDL_Renderer* renderer);
static int gf_activaterenderer(SDL_Renderer* renderer);
static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch);
static int gf_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors);
static int gf_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors);
static int gf_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture);
static int gf_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch);
static int gf_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch);
static void gf_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture);
static void gf_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects);
static int gf_renderpoint(SDL_Renderer* renderer, int x, int y);
static int gf_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2);
static int gf_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect);
static int gf_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect);
static int gf_renderpoint(SDL_Renderer* renderer, int x, int y);
static int gf_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2);
static int gf_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect);
static int gf_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect);
static void gf_renderpresent(SDL_Renderer* renderer);
static void gf_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture);
static void gf_destroyrenderer(SDL_Renderer* renderer);
@@ -222,7 +222,6 @@ static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags)
for (it=0; it<rdata->surfaces_count; it++)
{
/* TODO: add palette creation */
/* do not waste surfaces when using GL ES */

/* Create displayable surfaces */
status=gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0,
@@ -236,6 +235,7 @@ static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags)
for (jt=it-1; jt>0; jt--)
{
gf_surface_free(rdata->surface[jt]);
rdata->surface[jt]=NULL;
}
SDL_free(rdata);
SDL_free(renderer);
@@ -288,10 +288,10 @@ static int gf_activaterenderer(SDL_Renderer* renderer)
SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata;

/* Setup current surface as visible */
gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1);
// gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1);

/* Set visible surface when hardware in idle state */
gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
// gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);

return 0;
}
@@ -391,7 +391,10 @@ static void gf_destroyrenderer(SDL_Renderer* renderer)

for (it=0; it<rdata->surfaces_count; it++)
{
gf_surface_free(rdata->surface[it]);
if (rdata->surface[it]!=NULL)
{
gf_surface_free(rdata->surface[it]);
}
}
}

@@ -0,0 +1,34 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
QNX Graphics Framework SDL driver
Copyright (C) 2009 Mike Gorchak
(mike@malva.ua, lestat@i.com.ua)
*/

#ifndef __SDL_HIDDI_JOYSTICK_H__
#define __SDL_HIDDI_JOYSTICK_H__

#include <inttypes.h>



#endif /* __SDL_HIDDI_JOYSTICK_H__ */

0 comments on commit 7c54f60

Please sign in to comment.