/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 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
*/
#include "SDL_config.h"

#ifdef SDL_JOYSTICK_OS2

/* OS/2 Joystick driver, contributed by Daniel Caetano */

#include <mem.h>

#define INCL_DOSDEVICES
#define INCL_DOSDEVIOCTL
#define INCL_DOSMEMMGR
#include <os2.h>
#include "joyos2.h"

#include "SDL_joystick.h"
#include "SDL_events.h"
#include "../SDL_sysjoystick.h"
#include "../SDL_joystick_c.h"

HFILE hJoyPort = NULL;          /* Joystick GAME$ Port Address */
#define MAX_JOYSTICKS	2       /* Maximum of two joysticks */
#define MAX_AXES	4       /* each joystick can have up to 4 axes */
#define MAX_BUTTONS	8       /* 8 buttons */
#define MAX_HATS	0       /* 0 hats - OS/2 doesn't support it */
#define MAX_BALLS	0       /* and 0 balls - OS/2 doesn't support it */
#define AXIS_MIN -32768         /* minimum value for axes coordinate */
#define AXIS_MAX 32767          /* maximum value for axes coordinate */
#define MAX_JOYNAME	128     /* Joystick name may have 128 characters */
/* limit axes to 256 possible positions to filter out noise */
#define JOY_AXIS_THRESHOLD (((AXIS_MAX)-(AXIS_MIN))/256)
/* Calc Button Flag for buttons A to D */
#define JOY_BUTTON_FLAG(n) (1<<n)

/* Joystick data... hold information about detected devices */
typedef struct SYS_JoyData_s
{
    Sint8 id;                   // Device ID
    char szDeviceName[MAX_JOYNAME];     // Device Name
    char axes;                  // Number of axes
    char buttons;               // Number of buttons
    char hats;                  // Number of buttons
    char balls;                 // Number of buttons
    int axes_min[MAX_AXES];     // minimum callibration value for axes
    int axes_med[MAX_AXES];     // medium callibration value for axes
    int axes_max[MAX_AXES];     // maximum callibration value for axes
    int buttoncalc[4];          // Used for buttons 5, 6, 7 and 8.
} SYS_JoyData_t, *SYS_JoyData_p;

SYS_JoyData_t SYS_JoyData[MAX_JOYSTICKS];


/* Structure used to convert data from OS/2 driver format to SDL format */
struct joystick_hwdata
{
    Sint8 id;
    struct _transaxes
    {
        int offset;             /* Center Offset */
        float scale1;           /* Center to left/up Scale */
        float scale2;           /* Center to right/down Scale */
    } transaxes[MAX_AXES];
};

/* Structure used to get values from Joystick Environment Variable */
struct _joycfg
{
    char name[MAX_JOYNAME];
    unsigned int axes;
    unsigned int buttons;
    unsigned int hats;
    unsigned int balls;
};

/* OS/2 Implementation Function Prototypes */
APIRET joyPortOpen(HFILE * hGame);
void joyPortClose(HFILE * hGame);
int joyGetData(char *joyenv, char *name, char stopchar, size_t maxchars);
int joyGetEnv(struct _joycfg *joydata);



/************************************************************************/
/* Function to scan the system for joysticks.									*/
/* This function should set SDL_numjoysticks to the number of available	*/
/* joysticks.  Joystick 0 should be the system default joystick.			*/
/* It should return 0, or -1 on an unrecoverable fatal error.				*/
/************************************************************************/
int
SDL_SYS_JoystickInit(void)
{
    APIRET rc;                  /* Generic OS/2 return code */
    GAME_PORT_STRUCT stJoyStatus;       /* Joystick Status Structure */
    GAME_PARM_STRUCT stGameParms;       /* Joystick Parameter Structure */
    GAME_CALIB_STRUCT stGameCalib;      /* Calibration Struct */
    ULONG ulDataLen;            /* Size of data */
    ULONG ulLastTick;           /* Tick Counter for timing operations */
    Uint8 maxdevs;              /* Maximum number of devices */
    Uint8 numdevs;              /* Number of present devices */
    Uint8 maxbut;               /* Maximum number of buttons... */
    Uint8 i;                    /* Temporary Count Vars */
    Uint8 ucNewJoystickMask;    /* Mask for Joystick Detection */
    struct _joycfg joycfg;      /* Joy Configuration from envvar */


/* Get Max Number of Devices */
    rc = joyPortOpen(&hJoyPort);        /* Open GAME$ port */
    if (rc != 0)
        return 0;               /* Cannot open... report no joystick */
    ulDataLen = sizeof(stGameParms);
    rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_GET_PARMS, NULL, 0, NULL, &stGameParms, ulDataLen, &ulDataLen);     /* Ask device info */
    if (rc != 0) {
        joyPortClose(&hJoyPort);
        SDL_SetError("Could not read joystick port.");
        return -1;
    }
    if (stGameParms.useA != 0)
        maxdevs++;
    if (stGameParms.useB != 0)
        maxdevs++;
    if (maxdevs > MAX_JOYSTICKS)
        maxdevs = MAX_JOYSTICKS;

/* Defines min/max axes values (callibration) */
    ulDataLen = sizeof(stGameCalib);
    rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_GET_CALIB,
                     NULL, 0, NULL, &stGameCalib, ulDataLen, &ulDataLen);
    if (rc != 0) {
        joyPortClose(&hJoyPort);
        SDL_SetError("Could not read callibration data.");
        return -1;
    }

/* Determine how many joysticks are active */
    numdevs = 0;                /* Points no device */
    ucNewJoystickMask = 0x0F;   /* read all 4 joystick axis */
    ulDataLen = sizeof(ucNewJoystickMask);
    rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_PORT_RESET,
                     &ucNewJoystickMask, ulDataLen, &ulDataLen, NULL, 0,
                     NULL);
    if (rc == 0) {
        ulDataLen = sizeof(stJoyStatus);
        rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_PORT_GET,
                         NULL, 0, NULL, &stJoyStatus, ulDataLen, &ulDataLen);
        if (rc != 0) {
            joyPortClose(&hJoyPort);
            SDL_SetError("Could not call joystick port.");
            return -1;
        }
        ulLastTick = stJoyStatus.ulJs_Ticks;
        while (stJoyStatus.ulJs_Ticks == ulLastTick) {
            rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_PORT_GET,
                             NULL, 0, NULL, &stJoyStatus, ulDataLen,
                             &ulDataLen);
        }
        if ((stJoyStatus.ucJs_JoyStickMask & 0x03) > 0)
            numdevs++;
        if (((stJoyStatus.ucJs_JoyStickMask >> 2) & 0x03) > 0)
            numdevs++;
    }

    if (numdevs > maxdevs)
        numdevs = maxdevs;

/* If *any* joystick was detected... Let's configure SDL for them */
    if (numdevs > 0) {
        /* Verify if it is a "user defined" joystick */
        if (joyGetEnv(&joycfg)) {
            GAME_3POS_STRUCT *axis[4];
            axis[0] = &stGameCalib.Ax;
            axis[1] = &stGameCalib.Ay;
            axis[2] = &stGameCalib.Bx;
            axis[3] = &stGameCalib.By;
            /* Say it has one device only (user defined is always one device only) */
            numdevs = 1;
            /* Define Device 0 as... */
            SYS_JoyData[0].id = 0;
            /* Define Number of Axes... up to 4 */
            if (joycfg.axes > MAX_AXES)
                joycfg.axes = MAX_AXES;
            SYS_JoyData[0].axes = joycfg.axes;
            /* Define number of buttons... 8 if 2 axes, 6 if 3 axes and 4 if 4 axes */
            maxbut = MAX_BUTTONS;
            if (joycfg.axes > 2)
                maxbut -= ((joycfg.axes - 2) << 1);     /* MAX_BUTTONS - 2*(axes-2) */
            if (joycfg.buttons > maxbut)
                joycfg.buttons = maxbut;
            SYS_JoyData[0].buttons = joycfg.buttons;
            /* Define number of hats */
            if (joycfg.hats > MAX_HATS)
                joycfg.hats = MAX_HATS;
            SYS_JoyData[0].hats = joycfg.hats;
            /* Define number of balls */
            if (joycfg.balls > MAX_BALLS)
                joycfg.balls = MAX_BALLS;
            SYS_JoyData[0].balls = joycfg.balls;
            /* Initialize Axes Callibration Values */
            for (i = 0; i < joycfg.axes; i++) {
                SYS_JoyData[0].axes_min[i] = axis[i]->lower;
                SYS_JoyData[0].axes_med[i] = axis[i]->centre;
                SYS_JoyData[0].axes_max[i] = axis[i]->upper;
            }
            /* Initialize Buttons 5 to 8 structures */
            if (joycfg.buttons >= 5)
                SYS_JoyData[0].buttoncalc[0] =
                    ((axis[2]->lower + axis[3]->centre) >> 1);
            if (joycfg.buttons >= 6)
                SYS_JoyData[0].buttoncalc[1] =
                    ((axis[3]->lower + axis[3]->centre) >> 1);
            if (joycfg.buttons >= 7)
                SYS_JoyData[0].buttoncalc[2] =
                    ((axis[2]->upper + axis[3]->centre) >> 1);
            if (joycfg.buttons >= 8)
                SYS_JoyData[0].buttoncalc[3] =
                    ((axis[3]->upper + axis[3]->centre) >> 1);
            /* Intialize Joystick Name */
            SDL_strlcpy(SYS_JoyData[0].szDeviceName, joycfg.name,
                        SDL_arraysize(SYS_JoyData[0].szDeviceName));
        }
        /* Default Init ... autoconfig */
        else {
            /* if two devices were detected... configure as Joy1 4 axis and Joy2 2 axis */
            if (numdevs == 2) {
                /* Define Device 0 as 4 axes, 4 buttons */
                SYS_JoyData[0].id = 0;
                SYS_JoyData[0].axes = 4;
                SYS_JoyData[0].buttons = 4;
                SYS_JoyData[0].hats = 0;
                SYS_JoyData[0].balls = 0;
                SYS_JoyData[0].axes_min[0] = stGameCalib.Ax.lower;
                SYS_JoyData[0].axes_med[0] = stGameCalib.Ax.centre;
                SYS_JoyData[0].axes_max[0] = stGameCalib.Ax.upper;
                SYS_JoyData[0].axes_min[1] = stGameCalib.Ay.lower;
                SYS_JoyData[0].axes_med[1] = stGameCalib.Ay.centre;
                SYS_JoyData[0].axes_max[1] = stGameCalib.Ay.upper;
                SYS_JoyData[0].axes_min[2] = stGameCalib.Bx.lower;
                SYS_JoyData[0].axes_med[2] = stGameCalib.Bx.centre;
                SYS_JoyData[0].axes_max[2] = stGameCalib.Bx.upper;
                SYS_JoyData[0].axes_min[3] = stGameCalib.By.lower;
                SYS_JoyData[0].axes_med[3] = stGameCalib.By.centre;
                SYS_JoyData[0].axes_max[3] = stGameCalib.By.upper;
                /* Define Device 1 as 2 axes, 2 buttons */
                SYS_JoyData[1].id = 1;
                SYS_JoyData[1].axes = 2;
                SYS_JoyData[1].buttons = 2;
                SYS_JoyData[1].hats = 0;
                SYS_JoyData[1].balls = 0;
                SYS_JoyData[1].axes_min[0] = stGameCalib.Bx.lower;
                SYS_JoyData[1].axes_med[0] = stGameCalib.Bx.centre;
                SYS_JoyData[1].axes_max[0] = stGameCalib.Bx.upper;
                SYS_JoyData[1].axes_min[1] = stGameCalib.By.lower;
                SYS_JoyData[1].axes_med[1] = stGameCalib.By.centre;
                SYS_JoyData[1].axes_max[1] = stGameCalib.By.upper;
            }
            /* One joystick only? */
            else {
                /* If it is joystick A... */
                if ((stJoyStatus.ucJs_JoyStickMask & 0x03) > 0) {
                    /* Define Device 0 as 2 axes, 4 buttons */
                    SYS_JoyData[0].id = 0;
                    SYS_JoyData[0].axes = 2;
                    SYS_JoyData[0].buttons = 4;
                    SYS_JoyData[0].hats = 0;
                    SYS_JoyData[0].balls = 0;
                    SYS_JoyData[0].axes_min[0] = stGameCalib.Ax.lower;
                    SYS_JoyData[0].axes_med[0] = stGameCalib.Ax.centre;
                    SYS_JoyData[0].axes_max[0] = stGameCalib.Ax.upper;
                    SYS_JoyData[0].axes_min[1] = stGameCalib.Ay.lower;
                    SYS_JoyData[0].axes_med[1] = stGameCalib.Ay.centre;
                    SYS_JoyData[0].axes_max[1] = stGameCalib.Ay.upper;
                }
                /* If not, it is joystick B */
                else {
                    /* Define Device 1 as 2 axes, 2 buttons */
                    SYS_JoyData[0].id = 1;
                    SYS_JoyData[0].axes = 2;
                    SYS_JoyData[0].buttons = 2;
                    SYS_JoyData[0].hats = 0;
                    SYS_JoyData[0].balls = 0;
                    SYS_JoyData[0].axes_min[0] = stGameCalib.Bx.lower;
                    SYS_JoyData[0].axes_med[0] = stGameCalib.Bx.centre;
                    SYS_JoyData[0].axes_max[0] = stGameCalib.Bx.upper;
                    SYS_JoyData[0].axes_min[1] = stGameCalib.By.lower;
                    SYS_JoyData[0].axes_med[1] = stGameCalib.By.centre;
                    SYS_JoyData[0].axes_max[1] = stGameCalib.By.upper;
                }
            }
            /* Hack to define Joystick Port Names */
            if (numdevs > maxdevs)
                numdevs = maxdevs;
            for (i = 0; i < numdevs; i++)
                SDL_snprintf(SYS_JoyData[i].szDeviceName,
                             SDL_arraysize(SYS_JoyData[i].szDeviceName),
                             "Default Joystick %c", 'A' + SYS_JoyData[i].id);

        }
    }
/* Return the number of devices found */
    return (numdevs);
}


/***********************************************************/
/* Function to get the device-dependent name of a joystick */
/***********************************************************/
const char *
SDL_SYS_JoystickName(int index)
{
/* No need to verify if device exists, already done in upper layer */
    return (SYS_JoyData[index].szDeviceName);
}



/******************************************************************************/
/* Function to open a joystick for use.													*/
/* The joystick to open is specified by the index field of the joystick.		*/
/* This should fill the nbuttons and naxes fields of the joystick structure.	*/
/* It returns 0, or -1 if there is an error.												*/
/******************************************************************************/
int
SDL_SYS_JoystickOpen(SDL_Joystick * joystick)
{
    int index;                  /* Index shortcut for index in joystick structure */
    int i;                      /* Generic Counter */

/* allocate memory for system specific hardware data */
    joystick->hwdata =
        (struct joystick_hwdata *) SDL_malloc(sizeof(*joystick->hwdata));
    if (joystick->hwdata == NULL) {
        SDL_OutOfMemory();
        return (-1);
    }
/* Reset Hardware Data */
    SDL_memset(joystick->hwdata, 0, sizeof(*joystick->hwdata));

/* ShortCut Pointer */
    index = joystick->index;
/* Define offsets and scales for all axes */
    joystick->hwdata->id = SYS_JoyData[index].id;
    for (i = 0; i < MAX_AXES; ++i) {
        if ((i < 2) || i < SYS_JoyData[index].axes) {
            joystick->hwdata->transaxes[i].offset =
                ((AXIS_MAX + AXIS_MIN) >> 1) - SYS_JoyData[index].axes_med[i];
            //joystick->hwdata->transaxes[i].scale = (float)((AXIS_MAX - AXIS_MIN)/(SYS_JoyData[index].axes_max[i]-SYS_JoyData[index].axes_min[i]));
            joystick->hwdata->transaxes[i].scale1 =
                (float) abs((AXIS_MIN / SYS_JoyData[index].axes_min[i]));
            joystick->hwdata->transaxes[i].scale2 =
                (float) abs((AXIS_MAX / SYS_JoyData[index].axes_max[i]));
        } else {
            joystick->hwdata->transaxes[i].offset = 0;
            //joystick->hwdata->transaxes[i].scale = 1.0; /* Just in case */
            joystick->hwdata->transaxes[i].scale1 = 1.0;        /* Just in case */
            joystick->hwdata->transaxes[i].scale2 = 1.0;        /* Just in case */
        }
    }

/* fill nbuttons, naxes, and nhats fields */
    joystick->nbuttons = SYS_JoyData[index].buttons;
    joystick->naxes = SYS_JoyData[index].axes;
/* joystick->nhats = SYS_JoyData[index].hats; */
    joystick->nhats = 0;        /* No support for hats at this time */
/* joystick->nballs = SYS_JoyData[index].balls; */
    joystick->nballs = 0;       /* No support for balls at this time */
    return 0;
}



/***************************************************************************/
/* Function to update the state of a joystick - called as a device poll.	*/
/* This function shouldn't update the joystick structure directly,			*/
/* but instead should call SDL_PrivateJoystick*() to deliver events			*/
/* and update joystick device state.													*/
/***************************************************************************/
void
SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
{
    APIRET rc;                  /* Generic OS/2 return code */
    int index;                  /* index shortcurt to joystick index */
    int i;                      /* Generic counter */
    int normbut;                /* Number of buttons reported by joystick */
    int corr;                   /* Correction for button names */
    Sint16 value, change;       /* Values used to update axis values */
    struct _transaxes *transaxes;       /* Shortcut for Correction structure */
    Uint32 pos[MAX_AXES];       /* Vector to inform the Axis status */
    ULONG ulDataLen;            /* Size of data */
    GAME_STATUS_STRUCT stGameStatus;    /* Joystick Status Structure */

    ulDataLen = sizeof(stGameStatus);
    rc = DosDevIOCtl(hJoyPort, IOCTL_CAT_USER, GAME_GET_STATUS,
                     NULL, 0, NULL, &stGameStatus, ulDataLen, &ulDataLen);
    if (rc != 0) {
        SDL_SetError("Could not read joystick status.");
        return;                 /* Could not read data */
    }

/* Shortcut pointer */
    index = joystick->index;
/* joystick motion events */

    if (SYS_JoyData[index].id == 0) {
        pos[0] = stGameStatus.curdata.A.x;
        pos[1] = stGameStatus.curdata.A.y;
        if (SYS_JoyData[index].axes >= 3)
            pos[2] = stGameStatus.curdata.B.x;
        else
            pos[2] = 0;
        if (SYS_JoyData[index].axes >= 4)
            pos[3] = stGameStatus.curdata.B.y;
        else
            pos[3] = 0;
        pos[4] = 0;             /* OS/2 basic drivers do not support more than 4 axes joysticks */
        pos[5] = 0;
    } else if (SYS_JoyData[index].id == 1) {
        pos[0] = stGameStatus.curdata.B.x;
        pos[1] = stGameStatus.curdata.B.y;
        pos[2] = 0;
        pos[3] = 0;
        pos[4] = 0;
        pos[5] = 0;
    }

/* Corrects the movements using the callibration */
    transaxes = joystick->hwdata->transaxes;
    for (i = 0; i < joystick->naxes; i++) {
        value = pos[i] + transaxes[i].offset;
        if (value < 0) {
            value *= transaxes[i].scale1;
            if (value > 0)
                value = AXIS_MIN;
        } else {
            value *= transaxes[i].scale2;
            if (value < 0)
                value = AXIS_MAX;
        }
        change = (value - joystick->axes[i]);
        if ((change < -JOY_AXIS_THRESHOLD) || (change > JOY_AXIS_THRESHOLD)) {
            SDL_PrivateJoystickAxis(joystick, (Uint8) i, (Sint16) value);
        }
    }

/* joystick button A to D events */
    if (SYS_JoyData[index].id == 1)
        corr = 2;
    else
        corr = 0;
    normbut = 4;                /* Number of normal buttons */
    if (joystick->nbuttons < normbut)
        normbut = joystick->nbuttons;
    for (i = corr; (i - corr) < normbut; ++i) {
        /*
           Button A: 1110 0000
           Button B: 1101 0000
           Button C: 1011 0000
           Button D: 0111 0000
         */
        if ((~stGameStatus.curdata.butMask) >> 4 & JOY_BUTTON_FLAG(i)) {
            if (!joystick->buttons[i - corr]) {
                SDL_PrivateJoystickButton(joystick, (Uint8) (i - corr),
                                          SDL_PRESSED);
            }
        } else {
            if (joystick->buttons[i - corr]) {
                SDL_PrivateJoystickButton(joystick, (Uint8) (i - corr),
                                          SDL_RELEASED);
            }
        }
    }

/* Joystick button E to H buttons */
    /*
       Button E: Axis 2 X Left
       Button F: Axis 2 Y Up
       Button G: Axis 2 X Right
       Button H: Axis 2 Y Down
     */
    if (joystick->nbuttons >= 5) {
        if (stGameStatus.curdata.B.x < SYS_JoyData[index].buttoncalc[0])
            SDL_PrivateJoystickButton(joystick, (Uint8) 4, SDL_PRESSED);
        else
            SDL_PrivateJoystickButton(joystick, (Uint8) 4, SDL_RELEASED);
    }
    if (joystick->nbuttons >= 6) {
        if (stGameStatus.curdata.B.y < SYS_JoyData[index].buttoncalc[1])
            SDL_PrivateJoystickButton(joystick, (Uint8) 5, SDL_PRESSED);
        else
            SDL_PrivateJoystickButton(joystick, (Uint8) 5, SDL_RELEASED);
    }
    if (joystick->nbuttons >= 7) {
        if (stGameStatus.curdata.B.x > SYS_JoyData[index].buttoncalc[2])
            SDL_PrivateJoystickButton(joystick, (Uint8) 6, SDL_PRESSED);
        else
            SDL_PrivateJoystickButton(joystick, (Uint8) 6, SDL_RELEASED);
    }
    if (joystick->nbuttons >= 8) {
        if (stGameStatus.curdata.B.y > SYS_JoyData[index].buttoncalc[3])
            SDL_PrivateJoystickButton(joystick, (Uint8) 7, SDL_PRESSED);
        else
            SDL_PrivateJoystickButton(joystick, (Uint8) 7, SDL_RELEASED);
    }

/* joystick hat events */
/* Not Supported under OS/2 */
/* joystick ball events */
/* Not Supported under OS/2 */
}



/******************************************/
/* Function to close a joystick after use */
/******************************************/
void
SDL_SYS_JoystickClose(SDL_Joystick * joystick)
{
    if (joystick->hwdata != NULL) {
        /* free system specific hardware data */
        SDL_free(joystick->hwdata);
    }
}



/********************************************************************/
/* Function to perform any system-specific joystick related cleanup */
/********************************************************************/
void
SDL_SYS_JoystickQuit(void)
{
    joyPortClose(&hJoyPort);
}



/************************/
/************************/
/* OS/2 Implementations */
/************************/
/************************/


/*****************************************/
/* Open Joystick Port, if not opened yet */
/*****************************************/
APIRET
joyPortOpen(HFILE * hGame)
{
    APIRET rc;                  /* Generic Return Code */
    ULONG ulAction;             /* ? */
    ULONG ulVersion;            /* Version of joystick driver */
    ULONG ulDataLen;            /* Size of version data */

/* Verifies if joyport is not already open... */
    if (*hGame != NULL)
        return 0;
/* Open GAME$ for read */
    rc = DosOpen((PSZ) GAMEPDDNAME, hGame, &ulAction, 0, FILE_READONLY,
                 FILE_OPEN, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, NULL);
    if (rc != 0) {
        SDL_SetError("Could not open Joystick Port.");
        return -1;
    }

/* Get Joystick Driver Version... must be 2.0 or higher */
    ulVersion = 0;
    ulDataLen = sizeof(ulVersion);
    rc = DosDevIOCtl(*hGame, IOCTL_CAT_USER, GAME_GET_VERSION,
                     NULL, 0, NULL, &ulVersion, ulDataLen, &ulDataLen);
    if (rc != 0) {
        joyPortClose(hGame);
        SDL_SetError("Could not get Joystick Driver version.");
        return -1;
    }
    if (ulVersion < GAME_VERSION) {
        joyPortClose(hGame);
        SDL_SetError
            ("Driver too old. At least IBM driver version 2.0 required.");
        return -1;
    }
    return 0;
}



/****************************/
/* Close JoyPort, if opened */
/****************************/
void
joyPortClose(HFILE * hGame)
{
    if (*hGame != NULL)
        DosClose(*hGame);
    *hGame = NULL;
}



/***************************/
/* Get SDL Joystick EnvVar */
/***************************/
int
joyGetEnv(struct _joycfg *joydata)
{
    char *joyenv;               /* Pointer to tested character */
    char tempnumber[5];         /* Temporary place to put numeric texts */

    joyenv = SDL_getenv("SDL_OS2_JOYSTICK");
    if (joyenv == NULL)
        return 0;
/* Joystick Environment is defined! */
    while (*joyenv == ' ' && *joyenv != 0)
        joyenv++;               /* jump spaces... */
/* If the string name starts with '... get if fully */
    if (*joyenv == '\'')
        joyenv +=
            joyGetData(++joyenv, joydata->name, '\'', sizeof(joydata->name));
/* If not, get it until the next space */
    else if (*joyenv == '\"')
        joyenv +=
            joyGetData(++joyenv, joydata->name, '\"', sizeof(joydata->name));
    else
        joyenv +=
            joyGetData(joyenv, joydata->name, ' ', sizeof(joydata->name));
/* Now get the number of axes */
    while (*joyenv == ' ' && *joyenv != 0)
        joyenv++;               /* jump spaces... */
    joyenv += joyGetData(joyenv, tempnumber, ' ', sizeof(tempnumber));
    joydata->axes = atoi(tempnumber);
/* Now get the number of buttons */
    while (*joyenv == ' ' && *joyenv != 0)
        joyenv++;               /* jump spaces... */
    joyenv += joyGetData(joyenv, tempnumber, ' ', sizeof(tempnumber));
    joydata->buttons = atoi(tempnumber);
/* Now get the number of hats */
    while (*joyenv == ' ' && *joyenv != 0)
        joyenv++;               /* jump spaces... */
    joyenv += joyGetData(joyenv, tempnumber, ' ', sizeof(tempnumber));
    joydata->hats = atoi(tempnumber);
/* Now get the number of balls */
    while (*joyenv == ' ' && *joyenv != 0)
        joyenv++;               /* jump spaces... */
    joyenv += joyGetData(joyenv, tempnumber, ' ', sizeof(tempnumber));
    joydata->balls = atoi(tempnumber);
    return 1;
}



/************************************************************************/
/* Get a text from in the string starting in joyenv until it finds		*/
/* the stopchar or maxchars is reached. The result is placed in name.	*/
/************************************************************************/
int
joyGetData(char *joyenv, char *name, char stopchar, size_t maxchars)
{
    char *nameptr;              /* Pointer to the selected character */
    int chcnt = 0;              /* Count how many characters where copied */

    nameptr = name;
    while (*joyenv != stopchar && *joyenv != 0) {
        if (nameptr < (name + (maxchars - 1))) {
            *nameptr = *joyenv; /* Only copy if smaller than maximum */
            nameptr++;
        }
        chcnt++;
        joyenv++;
    }
    if (*joyenv == stopchar) {
        joyenv++;               /* Jump stopchar */
        chcnt++;
    }
    *nameptr = 0;               /* Mark last byte */
    return chcnt;
}

#endif /* SDL_JOYSTICK_OS2 */
/* vi: set ts=4 sw=4 expandtab: */