input.c File Reference

#include <stdio.h>
#include <malloc.h>
#include <libpad.h>
#include <input.h>

Include dependency graph for input.c:

Go to the source code of this file.

Functions
pad_t *	pad_open (unsigned int port, unsigned int slot, unsigned int mode, unsigned int lock)
void	pad_close (pad_t *pad)
int	pad_get_state (pad_t *pad)
void	pad_wait (pad_t *pad)
int	pad_get_num_modes (pad_t *pad)
int	pad_has_type (pad_t *pad, int type)
int	pad_get_type (pad_t *pad)
void	pad_set_mode (pad_t *pad, int mode, int lock)
void	pad_set_sensitivity (pad_t *pad, int enable)
void	pad_init_actuators (pad_t *pad)
void	pad_set_actuators (pad_t *pad, int small, unsigned char large)

Function Documentation

pad_close()

void pad_close

(

pad_t *

pad

)

Close the pad

Definition at line 82 of file input.c.

{
 
        if (pad == NULL)
        {
                return;
        }
 
        if (pad->actuator != NULL)
        {
                free(pad->actuator);
        }
 
        padPortClose(pad->port,pad->slot);
 
        free(pad->buttons);
        free(pad->buffer);
        free(pad);
 
}

References pad_t::actuator, pad_t::buffer, pad_t::buttons, NULL, padPortClose(), pad_t::port, and pad_t::slot.

pad_get_num_modes()

int pad_get_num_modes

(

pad_t *

pad

)

Get number of modes supported by pad

Definition at line 145 of file input.c.

{
 
        pad->num_modes = padInfoMode(pad->port,pad->slot,PAD_MODETABLE,-1);
 
        return pad->num_modes;
 
}

References pad_t::num_modes, PAD_MODETABLE, padInfoMode(), pad_t::port, and pad_t::slot.

Referenced by pad_has_type().

pad_get_state()

int pad_get_state

(

pad_t *

pad

)

Get the pad's state

Definition at line 103 of file input.c.

{
 
        pad->state = padGetState(pad->port, pad->slot);
 
        return pad->state;
 
}

References padGetState(), pad_t::port, pad_t::slot, and pad_t::state.

Referenced by pad_wait().

pad_get_type()

int pad_get_type

(

pad_t *

pad

)

Get the pad's type

Definition at line 206 of file input.c.

{
 
        pad->type = padInfoMode(pad->port,pad->slot,PAD_MODECURID,0);
 
        return pad->type;
 
}

References PAD_MODECURID, padInfoMode(), pad_t::port, pad_t::slot, and pad_t::type.

pad_has_type()

int pad_has_type	(	pad_t *	pad,
		int	type
	)

Check if a type is supported by pad

Definition at line 178 of file input.c.

{
 
        int i = 0;
 
        if (pad->num_modes < 0)
        {
                pad_get_num_modes(pad);
        }
 
        if ((pad->num_modes == 0) && (type == PAD_TYPE_DIGITAL))
        {
                return 1;
        }
 
        for (i = 0; i < pad->num_modes; i++)
        {
                if (padInfoMode(pad->port,pad->slot,PAD_MODETABLE,i) == type)
                {
                        return 1;
                }
 
        }
 
        return 0;
 
}

References pad_t::num_modes, pad_get_num_modes(), PAD_MODETABLE, PAD_TYPE_DIGITAL, padInfoMode(), pad_t::port, and pad_t::slot.

Referenced by pad_set_mode().

pad_init_actuators()

void pad_init_actuators

(

pad_t *

pad

)

Init actuators

Definition at line 288 of file input.c.

{
 
        if (pad->actuator == NULL)
        {
#ifdef _XINPUT
                if (padInfoAct(pad->port, pad->slot, -1, 0))
#else
                if (padInfoMode(pad->port,pad->slot,PAD_MODECUREXID,0))
#endif
                {
                        pad_wait(pad);
                        pad->actuator = (actuator_t*)malloc(sizeof(actuator_t));
                }
                else
                {
                        pad_wait(pad);
                        return;
                }
        }
 
        pad->actuator->small = 0;
        pad->actuator->large = 0x00;
 
        pad->actuator->status[0] = 0;
        pad->actuator->status[1] = 1;
        pad->actuator->status[2] = 0xFF;
        pad->actuator->status[3] = 0xFF;
        pad->actuator->status[4] = 0xFF;
        pad->actuator->status[5] = 0xFF;
 
 
        pad_wait(pad);
        padSetActAlign(pad->port,pad->slot,pad->actuator->status);
        pad_wait(pad);
 
}

References pad_t::actuator, actuator_t::large, NULL, PAD_MODECUREXID, pad_wait(), padInfoAct(), padInfoMode(), padSetActAlign(), pad_t::port, pad_t::slot, actuator_t::small, and actuator_t::status.

pad_open()

pad_t* pad_open	(	unsigned int	port,
		unsigned int	slot,
		unsigned int	mode,
		unsigned int	lock
	)

Open and initialize a pad

Definition at line 10 of file input.c.

{
 
        pad_t *pad = (pad_t*)malloc(sizeof(pad_t));
 
        pad->buffer = (char*)memalign(64,256);
        pad->buttons = (struct padButtonStatus*)malloc(sizeof(struct padButtonStatus));
        pad->actuator = NULL;
 
        // there are only two ports
        if (port > 1)
        {
                free(pad->buttons);
                free(pad);
                return NULL;
        }
 
#ifdef _XINPUT
        if (mtapGetConnection(pad->port))
        {
                // there are only four slots
                if (slot > 3)
                {
                        free(pad->buttons);
                        free(pad);
                        return NULL;
                }
        }
        else
        {
#endif
        // there's only one slot
        if (slot)
        {
                free(pad->buttons);
                free(pad);
                return NULL;
        }
#ifdef _XINPUT
        }
#endif
 
        pad->port = port;
#ifdef _XINPUT
        pad->slot = slot;
#else
        pad->slot = 0;
#endif
 
        // Placeholders
        pad->type = PAD_TYPE_DIGITAL;
 
        pad->state = 0;
        pad->last_state = -1;
        pad->exec_cmd = 0;
        pad->num_modes = -1;
        pad->sensitivity = 0;
 
        // These get verified by pad_set_mode()
        pad->mode = mode;
        pad->lock = lock;
 
        padPortOpen(pad->port,pad->slot,pad->buffer);
 
        pad_wait(pad);
 
        pad_set_mode(pad,pad->mode,pad->lock);
 
        return pad;
 
}

References pad_t::actuator, pad_t::buffer, pad_t::buttons, pad_t::exec_cmd, pad_t::last_state, pad_t::lock, lock, pad_t::mode, mode, mtapGetConnection(), NULL, pad_t::num_modes, pad_set_mode(), PAD_TYPE_DIGITAL, pad_wait(), padPortOpen(), pad_t::port, port, pad_t::sensitivity, pad_t::slot, slot, pad_t::state, and pad_t::type.

pad_set_actuators()

void pad_set_actuators	(	pad_t *	pad,
		int	small,
		unsigned char	large
	)

Set actuators

Definition at line 326 of file input.c.

{
 
        if (!small)
        {
                pad->actuator->small = small;
        }
        else
        {
                pad->actuator->small = 0x01;
        }
 
        pad->actuator->large = large;
 
        pad->actuator->status[0] = pad->actuator->small;
        pad->actuator->status[1] = pad->actuator->large;
 
        padSetActDirect(pad->port,pad->slot,pad->actuator->status);
 
}

References pad_t::actuator, actuator_t::large, padSetActDirect(), pad_t::port, pad_t::slot, actuator_t::small, and actuator_t::status.

pad_set_mode()

void pad_set_mode	(	pad_t *	pad,
		int	mode,
		int	lock
	)

Set the pad's mode and mode lock

Definition at line 215 of file input.c.

{
 
        int status = 0;
 
        if (lock == PAD_MMODE_LOCK)
        {
                pad->lock = lock;
        }
        else
        {
                pad->lock = PAD_MMODE_UNLOCK;
        }
 
        if ((mode == PAD_MMODE_DUALSHOCK) || (mode == PAD_TYPE_DUALSHOCK))
        {
                if (pad_has_type(pad,PAD_TYPE_DUALSHOCK))
                {
                        status = padSetMainMode(pad->port,pad->slot,pad->mode,pad->lock);
                }
 
                if (status)
                {
                        pad->mode = PAD_MMODE_DUALSHOCK;
                }
        }
        else
        {
                if (pad_has_type(pad,PAD_TYPE_DIGITAL))
                {
                        status = padSetMainMode(pad->port,pad->slot,pad->mode,pad->lock);
                }
 
                if (status)
                {
                        pad->mode = PAD_MMODE_DIGITAL;
                }
        }
 
        if (status)
        {
                pad_wait(pad);
        }
 
}

References pad_t::lock, lock, pad_t::mode, mode, pad_has_type(), PAD_MMODE_DIGITAL, PAD_MMODE_DUALSHOCK, PAD_MMODE_LOCK, PAD_MMODE_UNLOCK, PAD_TYPE_DIGITAL, PAD_TYPE_DUALSHOCK, pad_wait(), padSetMainMode(), pad_t::port, and pad_t::slot.

Referenced by pad_open().

pad_set_sensitivity()

void pad_set_sensitivity	(	pad_t *	pad,
		int	enable
	)

Set the pad's pressure sensitivity

Definition at line 261 of file input.c.

{
 
        if(padInfoPressMode(pad->port,pad->slot))
        {
                pad_wait(pad);
                pad->sensitivity = 1;
        }
        else
        {
                pad_wait(pad);
                pad->sensitivity = 0;
                return;
        }
 
        if (enable)
        {
                padEnterPressMode(pad->port,pad->slot);
        }
        else
        {
                padExitPressMode(pad->port,pad->slot);
        }
 
 
}

References pad_wait(), padEnterPressMode(), padExitPressMode(), padInfoPressMode(), pad_t::port, pad_t::sensitivity, and pad_t::slot.

pad_wait()

void pad_wait

(

pad_t *

pad

)

Wait until the pad is ready to accept commands

Definition at line 122 of file input.c.

{
 
        pad_get_state(pad);
 
        if (pad->state != pad->last_state)
        {
#ifdef DEBUG
                pad_print_state(pad);
#endif
                pad->last_state = pad->state;
 
        }
 
        if (pad->state == PAD_STATE_STABLE) return;
        if (pad->state == PAD_STATE_ERROR) return;
        if (pad->state == PAD_STATE_DISCONN) return;
        if (pad->state == PAD_STATE_FINDCTP1) return;
 
        return pad_wait(pad);
 
}

References pad_t::last_state, pad_get_state(), PAD_STATE_DISCONN, PAD_STATE_ERROR, PAD_STATE_FINDCTP1, PAD_STATE_STABLE, pad_wait(), and pad_t::state.

Referenced by pad_init_actuators(), pad_open(), pad_set_mode(), pad_set_sensitivity(), and pad_wait().