gamepad-config.cpp

Go to the documentation of this file.

/*
 * gamepad-config.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of gamepad configuration object.
 */

// includes --------------------------------------------------------------------
#include "gamepad-config.h"     // always include our own header first

#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "util/uuid.h"


namespace gamepad {


// interface destructors
Configurator::~Configurator(void) throw() { }


struct instruct_rec_t {
        eInstruction    instruct;
        const char *    token;
};

#define INSTRUCT_ENTRY(name, token)                                     \
        { eInstruction_ ## name , token } ,

static const instruct_rec_t s_instructionRecords[] = {

        INSTRUCT_ENTRY(Calibrate,       "calibrate")
        INSTRUCT_ENTRY(ButtonPress,     "buttonPress")
        INSTRUCT_ENTRY(DpadCenter,      "dpadCenter")
        INSTRUCT_ENTRY(DpadLeft,        "dpadLeft")
        INSTRUCT_ENTRY(DpadRight,       "dpadRight")
        INSTRUCT_ENTRY(DpadUp,          "dpadUp")
        INSTRUCT_ENTRY(DpadDown,        "dpadDown")
        INSTRUCT_ENTRY(JoyCenter,       "joyCenter")
        INSTRUCT_ENTRY(JoyLeft,         "joyLeft")
        INSTRUCT_ENTRY(JoyUp,           "joyUp")
        INSTRUCT_ENTRY(PotCenter,       "potCenter")
        INSTRUCT_ENTRY(PotExtreme,      "potExtreme")

        // keep this last!
        { eInstruction_Invalid, NULL }
};

typedef std::multimap<int, std::string> priority_map_t;


static const int s_interleave           = 8;

static const float s_buttonThreshold    = 0.95;

////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static const instruct_rec_t *
getInstructionRecord
(
IN eInstruction instruct
)
{
        for (const instruct_rec_t * p = s_instructionRecords; p->token; ++p) {
                if (p->instruct == instruct)
                        return p;
        }

        // not found!
        ASSERT_THROW(false, "Invalid instruction value: " << instruct);
        return NULL;    // never get here
}


void
addToMultimap
(
IN priority_map_t& map,
IN int key,
IN const char * val
)
{
        ASSERT(key >= 0, "Bad key: %d", key);
        ASSERT(val, "null");

        map.insert(std::pair<int, std::string>(key, val));
}



static bool
notEqual
(
IN const char * string1,
IN const char * string2A,
IN const char * string2B
)
{
        ASSERT(string1, "null");
        ASSERT(string2A, "null");
        ASSERT(string2B, "null");

        int n2A = strlen(string2A);
        if (strncmp(string1, string2A, n2A)) {
                DPRINTF("Compared first %d characters of '%s' and '%s'",
                    n2A, string1, string2A);
                DPRINTF("Mismatch!");
                return true;    // doesn't match
        }
        DPRINTF("Comparing '%s' and '%s'", string1 + n2A, string2B);
        return (0 != strcmp(string1 + n2A, string2B));
}



////////////////////////////////////////////////////////////////////////////////
//
//      Config -- class that implements the gamepad::Configurator interface
//
////////////////////////////////////////////////////////////////////////////////

class Config : public Configurator {
public:
        // constructor, destructor ---------------------------------------------
        ~Config(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<Manager>& mgr,
                                IN smart_ptr<SourceDevice>& device,
                                IN smart_ptr<Type>& type,
                                IN const char * name);

        // gamepad::Configurator class interface methods -----------------------
        void reset(void);
        bool update(OUT config_status_t& status);
        void calibrationComplete(void);
        smart_ptr<Map> getMapping(void);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<int, std::string> map_int_t;   // input --> logical
        typedef std::map<std::string, int> map_logical_t;//logical name->configd

        // private helper methods ----------------------------------------------
        const char * getLogicalName(void) const throw();
        void setInstruction(void);
        void handleRelease(IN int buttonReleased,
                                IN int potWithMaxValue,
                                IN const device_state_t& state);
        bool calibrating(void);
        int getConfigured(IN const char * logical) const throw();
        void updateConfigured(IN const char * logical,
                                IN eInputType type);

        // private member data -------------------------------------------------
        smart_ptr<Manager>              m_mgr;
        smart_ptr<SourceDevice>         m_device;
        smart_ptr<Type>                 m_type;
        smart_ptr<Datahash>             m_map;  // output gamepad mapping
        smart_ptr<Datahash>             m_sub;  // current subhash for map
        std::string                     m_mapName; // name of mapping
        priority_map_t                  m_logicalNames; // for type
        const char *                    m_primary;      // primary action button
        device_state_t                  m_state;
        map_int_t                       m_buttonsSeen;  // seen these
        map_int_t                       m_potsSeen;
        map_logical_t                   m_configured;
        priority_map_t::const_iterator  m_currInput;
        int                             m_currStep;
        int                             m_currSubstep;
        int                             m_maxInputs;
        int                             m_primaryIndex;
        int                             m_minValue;
        int                             m_DpadUsesPots;
        eInstruction                    m_instruct;
};


void
Config::initialize
(
IN smart_ptr<Manager>& mgr,
IN smart_ptr<SourceDevice>& device,
IN smart_ptr<Type>& type,
IN const char * name
)
{
        ASSERT(mgr, "null");
        ASSERT(device, "null");
        ASSERT(type, "null");
        ASSERT(name, "null");

        m_mgr = mgr;
        m_device = device;
        m_type = type;
        m_mapName = name;
        m_primary = m_type->getMainButton();

        VecString logicalNames;
        m_type->getAllInputs(logicalNames);
        DPRINTF("Type '%s' contains %d logical inputs",
            m_type->getName(), (int) logicalNames.size());

        // now add to priority map
        for (VecString::const_iterator i = logicalNames.begin();
             i != logicalNames.end(); ++i) {
                const char * lname = i->c_str();
                eInputType intype = m_type->getInputTypes(lname);

                // add to priority map based on type
                //     (low priority == high number)
                if (eInput_Button & intype) {
                        DPRINTF("%s is a button", lname);
                        int pri = 10;   // default priority
                        if (!strcmp(m_primary, lname)) {
                                pri = 0;        // primary button
                        }
                        addToMultimap(m_logicalNames, pri, lname);
                } else if (eInput_Joystick & intype) {
                        DPRINTF("%s is a joystick", lname);
                        addToMultimap(m_logicalNames,  20, lname);
                } else if (eInput_Pot & intype) {
                        DPRINTF("%s is a potentiometer", lname);
                        addToMultimap(m_logicalNames,  30, lname);
                } else if (eInput_Dpad & intype) {
                        DPRINTF("%s is a dpad", lname);
                        addToMultimap(m_logicalNames,  40, lname);
                } else {
                        ASSERT_THROW(false, "Unknown input type: " << lname);
                }
        }
        m_maxInputs = (int) m_logicalNames.size() + 1;

        // reset
        this->reset();
}



////////////////////////////////////////////////////////////////////////////////
//
//      Config -- gamepad::Configurator class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
Config::reset
(
void
)
{
        // reset map
        m_map = new Datahash;
        ASSERT(m_map, "out of memory");

        // initialize map with important UUIDs
        char buffer[eUUID_Length];
        const char * uuid = generateUUID(buffer);
        m_map->insert("id", uuid);
        m_map->insert("typeId", m_type->getId());
        m_map->insert("name", m_mapName);
        m_map->insert("deviceName", m_device->getPublicName());

        // clear state
        m_sub = NULL;
        m_currStep = 0;
        m_currSubstep = 0;
        snapshotState(m_device, m_state);
        m_buttonsSeen.clear();
        m_potsSeen.clear();
        m_configured.clear();

        // clear primary
        m_primaryIndex = -1;

        // reset iterator
        m_currInput = m_logicalNames.begin();

        // start with calibration!
        m_instruct = eInstruction_Calibrate;

        // reset this flag (only used when configuring a dpad)
        m_DpadUsesPots = -1;    // unset
}



bool
Config::update
(
OUT config_status_t& status
)
{
        ASSERT(m_mgr, "null");
        ASSERT(m_device, "null");
        ASSERT(m_type, "null");
        status.clear();

        // get new state snapshot, look for differences
        device_state_t state;
        snapshotState(m_device, state);
        if (eInstruction_Calibrate != m_instruct) {
                // pots are (apparently) calibrated
                int br = buttonReleased(state);
                int mv = maxPotValue(state, s_buttonThreshold);

                if (br > -1 || mv > -1) {
                        //DPRINTF("button: %d  pot: %d", br, mv);

                        // handle release
                        this->handleRelease(br, mv, state);

                        // now set updated instructions
                        this->setInstruction();
                }
        }

        // update status based on current phase
        status.logical = this->getLogicalName();
        status.primary = m_primary;
        status.currStep = m_currStep * s_interleave + m_currSubstep;
        status.maxSteps = m_maxInputs * s_interleave;
        status.instruct = m_instruct;

        // we're done when we get an invalid instruction
        return (eInstruction_Invalid != m_instruct);
}



void
Config::calibrationComplete
(
void
)
{
        if (eInstruction_Calibrate != m_instruct) {
                DPRINTF("WARNING: not in calibration mode--why complete?");
                return;
        }

        // okay, exit calibration!
        m_currStep = 1;
        this->setInstruction();
}



smart_ptr<Map>
Config::getMapping
(
void
)
{
        DPRINTF("Caller is asking for mapping!");
        writeHashToStream(m_map, std::cerr);
        std::cerr << "\n";

        // construct parent datahash containing map
        smart_ptr<Datahash> parent = new Datahash;
        ASSERT(parent, "null");
        parent->insert("map", m_map);

        // create gamepad::Map object from parent datahash
        smart_ptr<Map> map = readMap(parent);
        ASSERT(map, "failed to read map from hash");

        return map;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Config -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

const char *
Config::getLogicalName
(
void
)
const
throw()
{
        if (m_logicalNames.end() == m_currInput) {
                return NULL;
        }
        return m_currInput->second.c_str();
}



void
Config::setInstruction
(
void
)
{
        // done?
        if (m_logicalNames.end() == m_currInput) {
                m_instruct = eInstruction_Invalid;
                return;
        }

        // okay, given current state, what should the user do?
        const char * logical = this->getLogicalName();
        ASSERT(logical, "null");
        //DPRINTF("setInstruction: %s", logical);
        eInputType type = m_type->getInputTypes(logical);
        if (eInput_Button & type) {
                m_instruct = eInstruction_ButtonPress;
                if (!m_sub) {
                        m_sub = new Datahash;
                        ASSERT(m_sub, "out of memory");
                        m_sub->insert("logical", logical);
                }
        } else if (eInput_Dpad & type) {
                switch (m_currSubstep) {
                case 0: 
                        m_instruct = eInstruction_DpadCenter;
                        m_DpadUsesPots = -1;    // unknown
                        m_sub = new Datahash;
                        ASSERT(m_sub, "out of memory");
                        m_sub->insert("logical", logical);
                        break;

                case 1:
                        m_instruct = eInstruction_DpadLeft;
                        break;

                case 2:
                        m_instruct = eInstruction_DpadCenter;
                        break;

                case 3:
                        m_instruct = eInstruction_DpadRight;
                        break;

                case 4:
                        m_instruct = eInstruction_DpadCenter;
                        break;

                case 5:
                        m_instruct = eInstruction_DpadUp;
                        break;

                case 6:
                        m_instruct = eInstruction_DpadCenter;
                        break;

                case 7:
                        m_instruct = eInstruction_DpadDown;
                        break;

                default:
                        ASSERT_THROW(false, "Bad substep: " << m_currSubstep);
                }
        } else if (eInput_Joystick & type) {
                switch (m_currSubstep) {
                case 0:
                        m_instruct = eInstruction_JoyCenter;
                        m_sub = new Datahash;
                        ASSERT(m_sub, "out of memory");
                        m_sub->insert("logical", logical);
                        break;

                case 1:
                        m_instruct = eInstruction_JoyLeft;
                        break;

                case 2:
                        m_instruct = eInstruction_JoyCenter;
                        break;

                case 3:
                        m_instruct = eInstruction_JoyUp;
                        break;

                default:
                        ASSERT_THROW(false, "bad substep: " << m_currSubstep);
                }
        } else if (eInput_Pot & type) {
                switch (m_currSubstep) {
                case 0:
                        m_instruct = eInstruction_PotCenter;
                        m_sub = new Datahash;
                        ASSERT(m_sub, "out of memory");
                        m_sub->insert("logical", logical);
                        break;

                case 1:
                        m_instruct = eInstruction_PotExtreme;
                        break;

                default:
                        ASSERT_THROW(false, "bad substep: " << m_currSubstep);
                }
        } else {
                ASSERT_THROW(false, "NYI");
        }
}



void
Config::handleRelease
(
IN int br,                              // button released
IN int mv,                              // pot with max value
IN const device_state_t& state          // new device state
)
{
        // handy data
        const char * logical = this->getLogicalName();
        if (!logical) {
                return;
        }
        const int bufsize = 16;
        char buffer[bufsize];

//      DPRINTF("handleRelease: %s", logical);

        // what were we waiting for?
        if (eInstruction_Calibrate == m_instruct) {
                // okay, calibrated!
                m_currInput = m_logicalNames.begin();
                m_currStep = 0;
                m_currSubstep = 0;
        } else if (eInstruction_ButtonPress == m_instruct) {
                eInputType intype = m_type->getInputTypes(logical);
                ASSERT(m_sub, "null");

                // is this button actually a potentiometer?
                if ((eInput_Pot & intype) &&
                    !(eInput_Pot & this->getConfigured(logical))){
                        if (mv < 0)
                                return;         // waiting for pot to change

                        DPRINTF("Logical button '%s' is physical pot %d",
                            logical, mv);

                        // already seen this?
                        if (!m_currSubstep &&
                            m_potsSeen.end() != m_potsSeen.find(mv)) {
                                DPRINTF("already seen this pot!");
                                return;
                        }
                        m_potsSeen[mv] = logical;
                        this->updateConfigured(logical, eInput_Pot);

                        smart_ptr<Datahash> pot = new Datahash;
                        ASSERT(pot, "out of memory");
                        pot->insert("logical", logical);
                        snprintf(buffer, bufsize, "%d", mv);
                        pot->insert("index", buffer);
                        m_map->insert("pot", pot);
                } 
                if (eInput_Button & intype) {
                        if (br < 0)
                                return;         // waiting for a button release
                        // we wanted a button press, and we got one!
                        DPRINTF("Logical button '%s' is physical button %d",
                            logical, br);

                        // already seen this?
                        if (!m_currSubstep &&
                            m_buttonsSeen.end() != m_buttonsSeen.find(br)) {
                                DPRINTF("Already seen this button!");
                                return;
                        }
                        m_buttonsSeen[br] = logical;
                        this->updateConfigured(logical, eInput_Button);

                        if (!strcmp(logical, m_primary)) {
                                m_primaryIndex = br;
                        }

                        snprintf(buffer, bufsize, "%d", br);
                        m_sub->insert("button", buffer);
                }

                // are we done?
                if (intype == this->getConfigured(logical)) {
                        // insert subhash
                        m_map->insert("button", m_sub);
                        m_sub = NULL;

                        // what's next?
                        ++m_currInput;
                        ++m_currStep;
                        m_currSubstep = 0;
                }
        } else if (eInstruction_DpadCenter == m_instruct) {
                if (m_primaryIndex != br)
                        return;
                m_state = state;
                ++m_currSubstep;
        } else if (eInstruction_DpadLeft == m_instruct ||
                   eInstruction_DpadRight == m_instruct ||
                   eInstruction_DpadUp == m_instruct ||
                   eInstruction_DpadDown == m_instruct) {
                if (m_primaryIndex != br)
                        return; // not the right button released

                // TODO: this is *horribly* messy.  Configuring a dpad requires
                //      maintaining a lot of state.  Also, after I built this
                //      routine to handle pot-based dpads, I discovered that
                //      Windows sometimes exposes dpads as buttons instead.  So
                //      this code tries to allow configuring dpads which are
                //      represented at the hardware layer by buttons OR pots.
                // Ideally, this code should be pulled out and restructured in
                //      a way that is remotely maintainable.

                int mp = maxPotChanged(m_state, state);
                if (mp < 0) {
                        // no pots changed--or many pots changed!

                        // see if any buttons are being held down instead
                        int bd = buttonDown(state);
                        if (-1 == m_DpadUsesPots) {
                                // we don't yet know if this dpad is driven by
                                //      button presses, or potentiometers
                                if (bd > -1) {
                                        // apparently, this dpad uses buttons
                                        m_sub->insert("type", "button");
                                        m_DpadUsesPots = 0;
                                }
                        }

                        // if we're not sure, or definitely using pots, go back
                        if (m_DpadUsesPots) {
                                --m_currSubstep;
                                return;
                        }

                        // okay, we're supposed to configure this dpad based on
                        //      button presses
                        DPRINTF("Button pressed: %d", bd);

                        // is this button taken?
                        map_int_t::iterator i = m_buttonsSeen.find(bd);
                        if (m_buttonsSeen.end() != i) {
                                DPRINTF("Already seen this button!");
                                DPRINTF("  button %d --> '%s'", bd, i->second.c_str());
                                --m_currStep;
                                return;
                        }
        
                        // update mapping sub-hash with button
                        const char * label = NULL;
                        if (eInstruction_DpadLeft == m_instruct) {
                                label = "left";
                        } else if (eInstruction_DpadRight == m_instruct) {
                                label = "right";
                        } else if (eInstruction_DpadUp == m_instruct) {
                                label = "up";
                        } else if (eInstruction_DpadDown == m_instruct) {
                                label = "down";
                        }
                        std::string full = logical;
                        full += label;
                        m_buttonsSeen[bd] = full;

                        DPRINTF("Dpad '%s': '%s' is button %d",
                            logical, label, bd);

                        ASSERT(m_sub, "null");
                        snprintf(buffer, bufsize, "%d", bd);
                        m_sub->insert(label, buffer);

                        // next!
                        if (eInstruction_DpadDown != m_instruct) {
                                ++m_currSubstep;
                        } else {
                                // this is Down: last substep!
                                m_map->insert("dpad", m_sub);
                                m_sub = NULL;

                                // next!
                                ++m_currInput;
                                ++m_currStep;
                                m_currSubstep = 0;
                        }
                        return;
                }

                // okay, we believe a pot changed.  Should we do anything?
                if (-1 == m_DpadUsesPots) {
                        // at the moment, it is uncertain whether this dpad uses
                        //      buttons or potentiometers at the device layer.
                        // we now decide that yes, this dpad uses potentiometers
                        m_DpadUsesPots = 1;
                        m_sub->insert("type", "pot");
                }
                if (!m_DpadUsesPots) {
                        // we're supposed to be using buttons!  Ignore pot
                        --m_currSubstep;
                        return;
                }

                // okay, configure this dpad based on the pot that changed
                map_int_t::const_iterator i = m_potsSeen.find(mp);
                bool sameAxis = false;
                if (m_potsSeen.end() != i) {
                        // okay, this is annoying.  Some controllers (xbox 360)
                        //   have 2 pots per dpad, others (playstation 3) have
                        //   4 pots per dpad.  And who knows what some adapters
                        //   will do!  So we may legitimately see duplicates,
                        //   although only for the same axis.
                        const char * other = i->second.c_str();
                        DPRINTF("Pot already in use by '%s'", other);
                        if (eInstruction_DpadLeft == m_instruct ||
                            eInstruction_DpadUp == m_instruct) {
                                // Left and Up shouldn't have pots in use
                                return;
                        }
                        if (eInstruction_DpadRight == m_instruct &&
                            notEqual(other, logical, "left")) {
                                // pot in use isn't the correct one
                                DPRINTF("Calibrating right, not left?");
                                return;
                        }
                        if (eInstruction_DpadDown == m_instruct &&
                            notEqual(other, logical, "up")) {
                                // not the correct one
                                DPRINTF("Calibrating down, not up?");
                                return;
                        }
                        // must be okay!
                        sameAxis = true;
                }
                const pot_value_t& pv = m_device->getPotValue(mp);
                const char * flipAxis = NULL;
                const char * label = NULL;
                if (eInstruction_DpadLeft == m_instruct) {
                        m_minValue = pv.value;
                        label = "left";
                } else if (eInstruction_DpadRight == m_instruct) {
                        if (sameAxis && pv.value < m_minValue) {
                                flipAxis = "flipX";
                        }
                        label = "right";
                } else if (eInstruction_DpadUp == m_instruct) {
                        m_minValue = pv.value;
                        label = "up";
                } else if (eInstruction_DpadDown == m_instruct) {
                        if (sameAxis && pv.value < m_minValue) {
                                flipAxis = "flipY";
                        }
                        label = "down";
                }
                std::string full = logical;
                full += label;
                m_potsSeen[mp] = full;

                DPRINTF("Dpad '%s': '%s' is potentiometer %d",
                    logical, label, mp);

                ASSERT(m_sub, "null");
                snprintf(buffer, bufsize, "%d", mp);
                m_sub->insert(label, buffer);

                if (flipAxis) {
                        DPRINTF("Flipping axis!  '%s'", flipAxis);
                        m_sub->insert(flipAxis, "true");
                }

                // next!
                if (eInstruction_DpadDown != m_instruct) {
                        ++m_currSubstep;
                } else {
                        // this is Down: last substep!
                        m_map->insert("dpad", m_sub);
                        m_sub = NULL;

                        // next!
                        ++m_currInput;
                        ++m_currStep;
                        m_currSubstep = 0;
                }
        } else if (eInstruction_JoyCenter == m_instruct) {
                if (m_primaryIndex != br)
                        return;
                m_state = state;
                ++m_currSubstep;
        } else if (eInstruction_JoyLeft == m_instruct) {
                if (m_primaryIndex != br) {
                        DPRINTF("Wrong button press?");
                        return;
                }
                int mp = maxPotChanged(m_state, state);
                if (mp < 0) {
                        DPRINTF("No change?  Step back...");
                        --m_currSubstep;        // back up
                        return;
                }
                if (m_potsSeen.end() != m_potsSeen.find(mp)) {
                        DPRINTF("Already seen pot %d", mp);
                        return;
                }
                m_potsSeen[mp] = logical;
                DPRINTF("Joystick '%s' x-axis is potentiometer %d",
                    logical, mp);
                ASSERT(m_sub, "null");
                snprintf(buffer, bufsize, "%d", mp);
                m_sub->insert("xAxis", buffer);
                ++m_currSubstep;        // next
        } else if (eInstruction_JoyUp == m_instruct) {
                if (m_primaryIndex != br)
                        return;
                int mp = maxPotChanged(m_state, state);
                if (mp < 0) {
                        --m_currSubstep;        // back up
                        return;
                }
                if (m_potsSeen.end() != m_potsSeen.find(mp)) {
                        DPRINTF("Already seen pot %d", mp);
                        return;
                }
                m_potsSeen[mp] = logical;
                DPRINTF("Joystick '%s' y-axis is potentiometer %d",
                    logical, mp);
                ASSERT(m_sub, "null");
                snprintf(buffer, bufsize, "%d", mp);
                m_sub->insert("yAxis", buffer);
                m_map->insert("joystick", m_sub);
                m_sub = NULL;

                // next input!
                ++m_currInput;
                ++m_currStep;
                m_currSubstep = 0;
        } else if (eInstruction_PotCenter == m_instruct) {
                if (m_primaryIndex != br)
                        return;

                // okay, snapshot state and move ahead
                m_state = state;
                m_currSubstep++;
        } else if (eInstruction_PotExtreme == m_instruct) {
                if (m_primaryIndex != br)
                        return;
                int mp = maxPotChanged(m_state, state);
                if (mp < 0)
                        return;
                if (m_potsSeen.end() != m_potsSeen.find(mp)) {
                        DPRINTF("Already seen pot %d", mp);
                        return;
                }
                m_potsSeen[mp] = logical;
                DPRINTF("Pot '%s' is potentiometer %d", logical, mp);
                ASSERT(m_sub, "null");
                snprintf(buffer, bufsize, "%d", mp);
                m_sub->insert("index", buffer);
                m_map->insert("pot", m_sub);
                m_sub = NULL;

                // next input!
                ++m_currInput;
                ++m_currStep;
                m_currSubstep = 0;
        } else {
                ASSERT_THROW(false, "NYI");
        }
}



int
Config::getConfigured
(
IN const char * logical
)
const
throw()
{
        ASSERT(logical, "null");

        map_logical_t::const_iterator i = m_configured.find(logical);
        if (m_configured.end() == i) {
                return 0;       // nothing configured!
        }
        return i->second;
}



void
Config::updateConfigured
(
IN const char * logical,
IN eInputType type
)
{
        ASSERT(logical, "null");

        map_logical_t::iterator i = m_configured.find(logical);
        if (m_configured.end() == i) {
                // not a recognized logical name--add this
                m_configured[logical] = type;
        } else {
                // update existing record
                int val = i->second;
                val |= type;
                m_configured[logical] = val;
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Configurator>
Configurator::create
(
IN smart_ptr<Manager>& mgr,
IN smart_ptr<SourceDevice>& device,
IN smart_ptr<Type>& type,
IN const char * name
)
{
        ASSERT(mgr, "null");
        ASSERT(device, "null");
        ASSERT(type, "null");
        ASSERT(name, "null");

        smart_ptr<Config> local = new Config;
        ASSERT(local, "out of memory");

        local->initialize(mgr, device, type, name);

        return local;
}



const char *
getInstructionToken
(
IN eInstruction instruct
)
{
        const instruct_rec_t * rec = getInstructionRecord(instruct);
        ASSERT(rec, "null");

        return rec->token;
}



};      // gamepad namespace