gamepad-config-dialog.cpp

Go to the documentation of this file.

/*
 * gamepad-config-dialog.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 conversation host.
 */

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

#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "dialog/request.h"
#include "gamepad-vgfx-element/gamepad-vgfx-element.h"
#include "i18n/i18n.h"


namespace gamepad {



static const char * s_defaultLocale     = "en_US.UTF-8";


static const char * s_widthString       = "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM";



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

static int
addHints
(
IN dialog::ContainerRequest& req,
IN i18n::Manager * mgr
)
{
        ASSERT(mgr, "null");

        const int bufsize = 32;
        char buffer[bufsize];

        int count = 0;
        for (int i = 1; ;++i, ++count) {
                snprintf(buffer, bufsize, "hint%d", i);
                const char * string = mgr->getString(buffer);
                if (!string)
                        break;
                req.addLabel(string);
        }

        return count;
}



static const char *
getTypeString
(
IN Manager * mgr,
IN const Type * type,
IN const std::string& locale,
OUT char * buffer,
IN int bufsize
)
{
        ASSERT(mgr, "null");
        ASSERT(type, "null");
        ASSERT(buffer, "null");
        ASSERT(bufsize > 0, "bad buffer size: %d", bufsize);

        smart_ptr<i18n::Manager> i18nMgr =
            getTypeLocaleMgr(type, locale.c_str(), s_defaultLocale,
                mgr->getDataDirectory()); 
        ASSERT(i18nMgr, "null");

        strncpy(buffer, i18n::getString(i18nMgr, "friendlyName"), bufsize);
        return buffer;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Host -- class that implements the gamepad::ConfigurationHost interface
//              to create a set of gamepad configuration dialogs.
//
////////////////////////////////////////////////////////////////////////////////

class Host : public converse::ConversationHost {
public:
        // constructor, destructor ---------------------------------------------
        ~Host(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<Manager>& mgr,
                                IN int gamepadId);

        // converse::ConversationHost class interface methods ------------------
        int getCurrentDialogIdTS(void);
        void handleReplyTS(IN int dialogId,
                                IN const Datahash * reply);
        std::string getDialogDataTS(void);
        bool updateState(void);

private:
        // private enums -------------------------------------------------------
        enum eDialog {
                eDialog_Done            = 0, // zero means quit dialog
                eDialog_ListPads        = 1, // first dialog: list gamepads
                eDialog_SelectSource    = 2, // allow player to select source
                eDialog_SelectType      = 3, // player selects gamepad type
                eDialog_Calibrate       = 4, // calibrating device
                eDialog_Config          = 5, // using configurator
                eDialog_Test            = 6, // testing a gamepad
                eDialog_DelConfirm      = 7, // really want to delete?
                eDialog_DelFail         = 8, // couldn't delete gamepad?

                // keep this last!
                eDialog_Invalid         = -1
        };

        // private helper methods ----------------------------------------------
        void verifyTypeMgr(void);

        // private member data -------------------------------------------------
        smart_ptr<Manager>      m_mgr;
        smart_ptr<SourceDevice> m_device;
        Type *                  m_type;
        smart_ptr<Configurator> m_config;
        smart_ptr<i18n::Manager> m_configMgr;
        smart_ptr<i18n::Manager> m_typeMgr;
        VecString               m_friendly;
        std::string             m_locale;
        std::string             m_direction;
        const char *            m_logical;      // current logical control
        eDialog                 m_dialogId;     // current dialog ID
        int                     m_currStep;
        int                     m_testingId;
        int                     m_counter;
        bool                    m_pulseMain;    // pulse main button?
};



void
Host::initialize
(
IN smart_ptr<Manager>& mgr,
IN int gamepadId
)
{
        ASSERT(mgr, "null");

        m_mgr = mgr;
        m_type = NULL;
        m_counter = 0;
        m_currStep = -1;
        m_testingId = -1;
        m_logical = NULL;
        m_pulseMain = false;

        const char * locale = i18n::getHostLocale();
        m_locale = (locale) ? locale : s_defaultLocale;

        // load i18n manager for basic config strings
        m_configMgr = getConfigLocaleMgr(m_locale.c_str(), s_defaultLocale,
            mgr->getDataDirectory());
        ASSERT(m_configMgr, "null");

        if (gamepadId >= 0) {
                m_dialogId = eDialog_Test;
                m_testingId = gamepadId;
        } else {
                m_dialogId = eDialog_ListPads;
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      Host -- converse::ConversationHost class interface methods
//
////////////////////////////////////////////////////////////////////////////////

int
Host::getCurrentDialogIdTS
(
void
)
{
        return m_dialogId;
}



void
Host::handleReplyTS
(
IN int dialogId,
IN const Datahash * reply
)
{
        ASSERT(reply, "null");

        DPRINTF("Got dialog reply for id=%d", dialogId);
        //dumpHash("Gamepad dialog reply", reply);
        if (dialogId != m_dialogId) {
                DPRINTF("Got response for wrong dialog id?");
                DPRINTF("My dialog id=%d", m_dialogId);
                return;
        }
        const char * value = getString(reply, "submit");

        if (eDialog_ListPads == m_dialogId) {
                if (!strncmp("test.", value, 5)) {
                        // player wants to test a gamepad!
                        int id = atoi(value + 5);
                        DPRINTF("User wants to test gamepad %d", id);
                        int nGamepads = m_mgr->getGamepadCount();
                        if (id < 0 || id >= nGamepads) {
                                m_testingId = -1;
                                m_dialogId = eDialog_ListPads;
                        } else {
                                m_dialogId = eDialog_Test;
                                m_testingId = id;
                        }
                } else if (!strcmp("newpad", value)) {
                        m_dialogId = eDialog_SelectSource;
                } else if (!strcmp("close", value)) {
                        m_dialogId = eDialog_Done;
                } else {
                        DPRINTF("Unknown reply submit: '%s'", value);
                        m_dialogId = eDialog_ListPads;
                }
        } else if (eDialog_SelectSource == m_dialogId) {
                if (!strcmp("home", value)) {
                        m_dialogId = eDialog_ListPads;
                } else if (!strncmp("src.", value, 4)) {
                        const char * id = value + 4;
                        DPRINTF("User wants source device with id='%s'", id);
                        smart_ptr<SourceDevice> device =
                            m_mgr->getSourceDeviceById(id);
                        if (!device) {
                                DPRINTF("Bad device?  id=%s", id);
                                m_dialogId = eDialog_ListPads;  // start over!
                                return;
                        }

                        // okay, remember this source device
                        m_device = device;

                        // next step: pick a gamepad type
                        m_dialogId = eDialog_SelectType;
                }
        } else if (eDialog_SelectType == m_dialogId) {
                if (!strcmp("src", value)) {
                        m_dialogId = eDialog_SelectSource;
                } else if (!strncmp("type.", value, 5)) {
                        const char * id = value + 5;
                        DPRINTF("User wants gamepad type with id='%s'", id);
                        smart_ptr<Type> type = m_mgr->getType(id);
                        if (!type) {
                                DPRINTF("Bad type?  id='%s'", id);
                                m_dialogId = eDialog_ListPads;  // start over!
                                return;
                        }

                        // okay, remember this type
                        m_type = type;

                        // load i18n manager for this type
                        this->verifyTypeMgr();

                        // next step: calibration!
                        m_dialogId = eDialog_Calibrate;
                        std::string name = "Gamepad: ";
                        name += m_type->getName();
                        name += ", Device: ";
                        name += m_device->getPublicName();
                        m_config = Configurator::create(m_mgr, m_device,
                            type, name.c_str());
                        ASSERT(m_config, "failed to create Configurator");
                        m_currStep = -1;
                        m_friendly.clear();
                }
        } else if (eDialog_Calibrate == m_dialogId) {
                ASSERT(m_config, "null");
                if (!strcmp("type", value)) {
                        // back up!
                        m_dialogId = eDialog_SelectType;
                        m_config = NULL;
                } else if (!strcmp("config", value)) {
                        // move forward...
                        m_dialogId = eDialog_Config;
                        m_config->calibrationComplete();
                }
        } else if (eDialog_Config == m_dialogId) {
                ASSERT(m_config, "null");
                if (!strcmp("calibrate", value)) {
                        // back up!
                        m_dialogId = eDialog_Calibrate;
                        m_config->reset();
                        m_friendly.clear();
                        m_currStep = -1;
                }
        } else if (eDialog_Test == m_dialogId) {
                if (!strcmp("home", value)) {
                        // back to home screen
                        m_dialogId = eDialog_ListPads;
                } else if (!strcmp("close", value)) {
                        m_dialogId = eDialog_Done;
                } else if (!strncmp("delete.", value, 7)) {
                        // delete this gamepad!
                        const char * id = value + 7;
                        DPRINTF("Want to delete gamepad with id='%s'", id);
                        m_dialogId = eDialog_DelConfirm;
                } else {
                        DPRINTF("Unrecognized submit: '%s'", value);
                }
        } else if (eDialog_DelConfirm == m_dialogId) {
                if (!strncmp("delete.", value, 7)) {
                        const char * id = value + 7;
                        if (m_mgr->deleteGamepad(id)) {
                                DPRINTF("Success!");
                                m_dialogId = eDialog_ListPads;
                        } else {
                                m_dialogId = eDialog_DelFail;
                        }
                } else {
                        m_dialogId = eDialog_ListPads;
                }
        } else if (eDialog_DelFail == m_dialogId) {
                if (!strcmp("home", value)) {
                        // back to home screen
                        m_dialogId = eDialog_ListPads;
                }
        } else {
                DPRINTF("Got reply for unknown dialog?");
                m_dialogId = eDialog_ListPads;
        }
}



std::string
Host::getDialogDataTS
(
void
)
{
        ASSERT(m_mgr, "null");
        ASSERT(m_configMgr, "null");

        const int bufsize = 256;
        char typeBuffer[bufsize];

        dialog::ContainerRequest req;
        if (eDialog_ListPads == m_dialogId) {
                // construct dialog showing all discovered gamepads
                req.addLabel(getString(m_configMgr, "gamepadList"));
                req.addLabel("");
                int N = m_mgr->getGamepadCount();
                if (N < 1) {
                        req.addLabel(getString(m_configMgr, "noGamepads"));
                } else {
                        for (int i = 0; i < N; ++i) {
                                smart_ptr<gamepad::Gamepad> pad =
                                    m_mgr->getGamepad(i);
                                if (!pad)
                                        continue;       // skip
                                const gamepad::Type * type = pad->getType();
                                if (!type) {
                                        DPRINTF("null gamepad type?");
                                        continue;       // skip
                                }

                                char buffer[bufsize];
                                snprintf(buffer, bufsize, "test.%d", i);
                                req.addButton(buffer,
                                    getTypeString(m_mgr, type, m_locale,
                                        typeBuffer, bufsize));
                        }
                }
                req.addLabel("");
                req.addButton("newpad", getString(m_configMgr, "newpad"));
                req.addLabel("");
                req.addButton("close", getString(m_configMgr, "closeMenu"));
                m_device = NULL;
                m_type = NULL;
        } else if (eDialog_SelectSource == m_dialogId) {
                // construct dialog showing all source devices
                int N = m_mgr->getSourceDeviceCount();
                if (N < 1) {
                        req.addLabel("No source devices found!");
                        req.addLabel("Please plug in a gamepad.");
                } else {
                        req.addLabel(getString(m_configMgr, "selectSource"));
                        req.addLabel(getString(m_configMgr, "selectSource2"));
                        req.addLabel("");
                        req.addLabel(getString(m_configMgr, "selectSource3"));
                        req.addLabel("");
                        for (int i = 0; i < N; ++i) {
                                smart_ptr<gamepad::SourceDevice> dev =
                                    m_mgr->getSourceDevice(i);
                                if (!dev)
                                        continue;       // skip
                                const char * name = dev->getPublicName();
                                std::string submit = "src.";
                                submit += dev->getUniqueId();
                                req.addButton(submit.c_str(), name);
                        }
                }
                req.addLabel("");
                req.addButton("home", getString(m_configMgr, "back"));
                m_device = NULL;
                m_type = NULL;
        } else if (eDialog_SelectType == m_dialogId) {
                ASSERT(m_device, "null");
                // construct dialog showing all gamepad types
                req.addLabel(getString(m_configMgr, "selectType"));
                req.addLabel("");
                int N = m_mgr->getTypeCount();
                if (N < 1) {
                        req.addLabel("No gamepad types supported!");
                        req.addLabel("This is a bug in the code");
                } else {
                        for (int i = 0; i < N; ++i) {
                                smart_ptr<Type> type = m_mgr->getType(i);
                                if (!type)
                                        continue;       // skip
                                std::string submit = "type.";
                                submit += type->getId();
                                req.addButton(submit.c_str(),
                                    getTypeString(m_mgr, type, m_locale,
                                        typeBuffer, bufsize));
                        }
                }
                req.addLabel("");
                req.addButton("src", getString(m_configMgr, "back"));
                m_type = NULL;
        } else if (eDialog_Calibrate == m_dialogId) {
                this->verifyTypeMgr();
                req.addLabel(getString(m_configMgr, "calibrating"));
                req.addLabel("");
                if (addHints(req, m_typeMgr) > 0) {
                        req.addLabel("");
                }

                req.addLabel(getString(m_configMgr, "calibrate"));
                req.addLabel(getString(m_configMgr, "pressNext"));

                req.addLabel("");
                dialog::ContainerRequest req2(dialog::ContainerRequest::eAxis_Horizontal);
                req2.addButton("type", getString(m_configMgr, "back"));
                req2.addButton("config", getString(m_configMgr, "next"));
                req.addContainer(req2);
        } else if (eDialog_Config == m_dialogId) {
                this->verifyTypeMgr();
                for (VecString::const_iterator i = m_friendly.begin();
                     i != m_friendly.end(); ++i) {
                        req.addLabel(i->c_str());
                }

                std::string custRequest = "element {\n";
                custRequest += "type ";
                custRequest += getVgfxSimpleElementName();
                custRequest += "\ntypeId ";
                custRequest += m_type->getId();
                if (m_logical) {
                        custRequest += "\nflash ";
                        custRequest += m_logical;
                        if (m_pulseMain) {
                                custRequest += "\npulse ";
                                custRequest += m_type->getMainButton();
                        }
                        if ("" != m_direction) {
                                custRequest += "\ndirection ";
                                custRequest += m_direction;
                        }
                }
                custRequest += "\n}\n";

                req.addCustom(custRequest.c_str());
                req.addWidthString(s_widthString);
                req.addButton("calibrate", getString(m_configMgr, "startOver"));
        } else if (eDialog_Test == m_dialogId && m_testingId >= 0) {
                this->verifyTypeMgr();
                req.addLabel(getString(m_configMgr, "testTitle"));
                req.addLabel(getString(m_typeMgr, "friendlyName"));
                req.addLabel("");
                req.addLabel(getString(m_configMgr, "testInstruct"));
                req.addLabel("");

                std::string custRequest = "element {\n";
                custRequest += "type ";
                custRequest += getVgfxTestElementName();
                custRequest += "\ngamepadId ";

                char buffer[bufsize];
                snprintf(buffer, bufsize, "%d", m_testingId);

                custRequest += buffer;
                custRequest += "\n}\n";

                req.addCustom(custRequest.c_str());

                dialog::ContainerRequest
                    req2(dialog::ContainerRequest::eAxis_Horizontal);
                req2.addButton("home", getString(m_configMgr, "back"));

                req2.addButton("close", getString(m_configMgr, "closeMenu"));
                smart_ptr<Gamepad> gp = m_mgr->getGamepad(m_testingId);
                if (gp) {
                        std::string delTag = "delete.";
                        delTag += gp->getId();
                        req2.addButton(delTag.c_str(),
                            getString(m_configMgr, "delete"));
                }
                req.addContainer(req2);
        } else if (eDialog_DelConfirm == m_dialogId) {
                req.addLabel(getString(m_configMgr, "delConfirm"));
                req.addLabel("");
                dialog::ContainerRequest
                    req2(dialog::ContainerRequest::eAxis_Horizontal);
                req2.addButton("home", getString(m_configMgr, "back"));
                smart_ptr<Gamepad> gp = m_mgr->getGamepad(m_testingId);
                if (gp) {
                        std::string delTag = "delete.";
                        delTag += gp->getId();
                        req2.addButton(delTag.c_str(),
                            getString(m_configMgr, "delete"));
                }
                req.addContainer(req2);
        } else if (eDialog_DelFail == m_dialogId) {
                req.addLabel(getString(m_configMgr, "delFail"));
                req.addLabel("");
                req.addButton("home", getString(m_configMgr, "back"));
        } else if (eDialog_Done == m_dialogId) {
                // do nothing
        } else {
                DPRINTF("ERROR: Bad dialog id: %d", m_dialogId);
                m_dialogId = eDialog_ListPads;
                return "";
        }

        // return whatever dialog we've constructed
        return req.get();
}



bool
Host::updateState
(
void
)
{
        // occasionally return true just to make sure we have correct state
        ++m_counter;
        if (0 == (m_counter % 128)) {
                return true;
        }
        if (!m_device)
                return false;   // nothing to do

        // have a configurator?
        if (m_config) {
                this->verifyTypeMgr();
                config_status_t status;
                if (!m_config->update(status)) {
                        DPRINTF("Done configuring this gamepad!");

                        // get mapping
                        smart_ptr<Map> map = m_config->getMapping();
                        ASSERT(map, "null mapping from configurator");

                        // reset our internal state
                        m_dialogId = eDialog_ListPads;
                        m_config = NULL;
                        m_friendly.clear();

                        // now create gamepad object
                        smart_ptr<Gamepad> gamepad;
                        Manager::eResult result =
                            m_mgr->createGamepad(m_device, map, gamepad);
                        if (Manager::eResult_Success != result) {
                                DPRINTF("Failed to create gamepad?");
                        } else {
                                DPRINTF("Success!");
                        }

                        // all done
                        return true;
                }

                // have we changed steps?
                if (m_currStep != status.currStep) {
                        m_logical = NULL;
                        m_pulseMain = false;
                        m_friendly.clear();
                        m_currStep = status.currStep;

                        // need to specify direction?
                        m_direction = "";
                        switch (status.instruct) {
                        case eInstruction_DpadLeft:
                        case eInstruction_JoyLeft:
                                m_direction = "left";
                                break;

                        case eInstruction_DpadUp:
                        case eInstruction_JoyUp:
                                m_direction = "up";
                                break;

                        case eInstruction_DpadRight:
                                m_direction = "right";
                                break;

                        case eInstruction_DpadDown:
                                m_direction = "down";
                                break;

                        default:        break;
                        }

                        // construct new friendly string
                        std::string friendly = "";
                        if (eInstruction_RequestControl & status.instruct) {
                                friendly =
                                    getString(m_typeMgr, status.logical);
                                friendly += ": ";
                                m_logical = status.logical;
                        }
                        const char * token =
                            getInstructionToken(status.instruct);
                        friendly += getString(m_configMgr, token);
                        m_friendly.push_back(friendly);
                        if (eInstruction_PressMainAction & status.instruct) {
                                m_friendly.push_back(
                                    getString(m_typeMgr, "pressMainAction"));
                                m_pulseMain = true;
                        }
                        return true;    // caller should refresh dialog!
                }
        }

        // default exit: no change
        return false;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Host -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
Host::verifyTypeMgr
(
void
)
{
        if (m_typeMgr)
                return;

        if (!m_type) {
                ASSERT(m_testingId >= 0, "no type and no testing id?");
                smart_ptr<Gamepad> gamepad = m_mgr->getGamepad(m_testingId);
                ASSERT_THROW(gamepad, "gamepad is now disconnected");
                m_type = gamepad->getType();
        }
        ASSERT(m_type, "null");
        m_typeMgr = getTypeLocaleMgr(m_type, m_locale.c_str(),
            s_defaultLocale, m_mgr->getDataDirectory());
        ASSERT(m_typeMgr, "null");
}



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

smart_ptr<converse::ConversationHost>
createConfigurationHost
(
IN smart_ptr<Manager>& mgr,
IN int gamepadId
)
{
        ASSERT(mgr, "null");

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

        local->initialize(mgr, gamepadId);

        return local;
}



};      // gamepad namespace