gamepad-simple-element.cpp

Go to the documentation of this file.

/*
 * gamepad-simple-element.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 dialog Simple Rendering element
 */

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

#include "datahash/datahash_util.h"
#include "gamepad-vgfx/gamepad-vgfx.h"


namespace gamepad {


static const char * s_simpleElementName         = "gamepadVgfxSimple";

static const char * s_null                      = "(null)";


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


////////////////////////////////////////////////////////////////////////////////
//
//      Simple -- class that implements the dialog::Element interface
//
////////////////////////////////////////////////////////////////////////////////

class Simple : public dialog::Element {
public:
        // constructor, destructor ---------------------------------------------
        ~Simple(void) throw() { }

        // dialog::Element class interface methods -----------------------------
        int getWidth(void) { return m_width; }
        int getHeight(void) { return m_height; }
        void draw(IN const dialog::point_t& offset); 
        void cursor(IN const dialog::point_t& pos) { }
        const char * button(IN int button, IN int state,
                                IN const dialog::point_t& pos)
                                { return NULL; }
        void addData(IN crypto::DESKey * key, IO Datahash * data) { }

        // static factory methods ----------------------------------------------
        static smart_ptr<dialog::Element> create(IN Type * type,
                                IN const char * flash,
                                IN const char * pulse,
                                IN const char * direction,
                                IN smart_ptr<vgfx::Drawer>& drawer);

private:
        // private constructors ------------------------------------------------
        Simple(void) throw(); 

        // private typedefs ----------------------------------------------------

        // private helper methods ----------------------------------------------
        void initialize(IN Type * type,
                                IN const char * flash,
                                IN const char * pulse,
                                IN const char * direction,
                                IN smart_ptr<vgfx::Drawer>& drawer);

        // private member data -------------------------------------------------
        int                             m_width;
        int                             m_height;
        smart_ptr<TypeVgfxRenderer>     m_renderer;
        Type *                          m_type;
        std::string                     m_flash;
        std::string                     m_pulse;
        eDpad                           m_direction;
        int                             m_counter;
};



Simple::Simple
(
void
)
throw()
{
        m_type = NULL;

        m_width = 400;
        m_height = 300;

        m_counter = 0;

        m_direction = eDpad_Centered;
}



smart_ptr<dialog::Element>
Simple::create
(
IN Type * type,
IN const char * flash,
IN const char * pulse,
IN const char * direction,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(type, "null");
        // ASSERT(flash) -- can be null
        // ASSERT(pulse) -- can be null
        // ASSERT(direction) -- can be null
        ASSERT(drawer, "null");

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

        local->initialize(type, flash, pulse, direction, drawer);

        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Simple -- dialog::Element class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
Simple::draw
(
IN const dialog::point_t& offset
)
{
        ++m_counter;

        // update intensities
        if (s_null != m_flash) {
                int on = (m_counter / 20) % 2;
                float val = (on) ? 1.0 : 0.0;
                m_renderer->setIntensity(m_flash.c_str(), val);

                bool setPos = false;
                float x = 0.5;
                float y = 0.5;
                if (eDpad_Left & m_direction) {
                        setPos = true;
                        x = 0;
                }
                if (eDpad_Right & m_direction) {
                        setPos = true;
                        x = 1;
                }
                if (eDpad_Up & m_direction) {
                        setPos = true;
                        y = 0;
                }
                if (eDpad_Down & m_direction) {
                        setPos = true;
                        y = 1;
                }

                if (setPos) {
                        m_renderer->setPosition(m_flash.c_str(), x, y);
                }
        }

        if (s_null != m_pulse) {
                int q = (m_counter % 200) - 100;
                if (q < 0) {
                        q = -q;
                }
                m_renderer->setIntensity(m_pulse.c_str(), 0.01 * q);
        }

        // now draw
        m_renderer->draw(offset.x, offset.y, m_width, m_height);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Simple -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
Simple::initialize
(
IN Type * type,
IN const char * flash,
IN const char * pulse,
IN const char * direction,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(type, "null");
        // ASSERT(flash) -- can be null
        // ASSERT(pulse) -- can be null
        // ASSERT(direction) -- can be null
        ASSERT(drawer, "null");
        ASSERT(!m_type, "already have a type?");

        m_type = type;

        m_flash = (flash) ? flash : s_null;
        m_pulse = (pulse) ? pulse : s_null;

        DPRINTF("flash = %s", m_flash.c_str());
        DPRINTF("pulse = %s", m_pulse.c_str());

        if (direction) {
                if (!strcmp("up", direction)) {
                        m_direction = eDpad_Up;
                } else if (!strcmp("down", direction)) {
                        m_direction = eDpad_Down;
                } else if (!strcmp("left", direction)) {
                        m_direction = eDpad_Left;
                } else if (!strcmp("right", direction)) {
                        m_direction = eDpad_Right;
                } else {
                        DPRINTF("Unknown direction, ignoring: %s", direction);
                }
        }

        m_renderer = TypeVgfxRenderer::create(type, drawer);
        ASSERT(m_renderer, "null");
}



////////////////////////////////////////////////////////////////////////////////
//
//      SimpleFactory - class that implements the dialog::Factory interface
//                      for gamepad Testing elements
//
////////////////////////////////////////////////////////////////////////////////

class SimpleFactory : public dialog::Factory {
public:
        // constructor, destructor ---------------------------------------------
        ~SimpleFactory(void) throw() { }

        // dialog::Factory class interface methods -----------------------------
        smart_ptr<dialog::Element> createElement(IN const char * type,
                                IN dialog::Manager * mgr,
                                IN const Datahash * data);

        // static factory methods ----------------------------------------------
        static smart_ptr<dialog::Factory> create(IN smart_ptr<Manager>& mgr,
                                IN smart_ptr<vgfx::Drawer>& drawer) {
                        ASSERT(mgr, "null");
                        ASSERT(drawer, "null");
                        smart_ptr<SimpleFactory> local = new SimpleFactory;
                        ASSERT(local, "out of memory");
                        local->m_mgr = mgr;
                        local->m_drawer = drawer;
                        return local;
                }
private:
        // private constructors ------------------------------------------------
        SimpleFactory(void) throw() { }

        // private typedefs ----------------------------------------------------
        // private member data -------------------------------------------------
        smart_ptr<Manager>      m_mgr;
        smart_ptr<vgfx::Drawer> m_drawer;
};



////////////////////////////////////////////////////////////////////////////////
//
//      SimpleFactory -- dialog::Factory class interface methods
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<dialog::Element>
SimpleFactory::createElement
(
IN const char * type,
IN dialog::Manager * mgr,
IN const Datahash * data
)
{
        ASSERT(type, "null");
        ASSERT(mgr, "null");
        ASSERT(data, "null");

        const char * typeId = getString(data, "typeId");
        ASSERT(typeId, "null");
        smart_ptr<Type> gpType = m_mgr->getType(typeId);
        ASSERT_THROW(gpType, "Failed to retrieve gamepad type: " << typeId);

        const char * flash = getOptionalString(data, "flash", NULL);
        const char * pulse = getOptionalString(data, "pulse", NULL);
        const char * direction = getOptionalString(data, "direction", NULL);

        return Simple::create(gpType, flash, pulse, direction, m_drawer);
}




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

void
registerVgfxSimpleFactory
(
IN smart_ptr<Manager>& gamepadMgr,
IN dialog::Manager * dialogMgr,
IN smart_ptr<vgfx::Drawer>& drawer
)
{
        ASSERT(gamepadMgr, "null");
        ASSERT(dialogMgr, "null");
        ASSERT(drawer, "null");

        smart_ptr<dialog::Factory> factory =
            SimpleFactory::create(gamepadMgr, drawer);
        ASSERT(factory, "null");

        dialogMgr->registerFactory(s_simpleElementName, factory);
}



const char *
getVgfxSimpleElementName
(
void
)
throw()
{
        return s_simpleElementName;
}



};      // gamepad namespace