dialog.cpp

Go to the documentation of this file.

/*
 * dialog.cpp
 *
 * Copyright (C) 2008-2009  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 the simple dialog library.  See dialog.h
 */

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

#include "container.h"
#include "request.h"

#include "common/wave_ex.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "perf/perf.h"


namespace dialog {

/// \ingroup dialog
/*@{*/


// Manager interface destructor
Manager::~Manager(void) throw() { }

// Host interface destructor
Host::~Host(void) throw() { }


struct dialog_record_t {
        rect_t                  bounds;         // 2D bounding rect
        Host *                  host;           // can be null!  callbacks
        smart_ptr<Element>      root;
};


typedef std::map<std::string, dialog_record_t > dialog_map_t;


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

smart_ptr<Datahash>
ContainerRequest::getDatahash
(
void
)
{
        this->close();
        std::istringstream iss(this->get());

        return readHashFromStream("dialog", iss);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- implementation for the dialog::Manager interface
//
////////////////////////////////////////////////////////////////////////////////

class Mgr : public Manager {
public:
        ~Mgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<crypto::DESKey>& desKey,
                                IN smart_ptr<Drawer>& drawer);

        // dialog::Manager class interface methods -----------------------------
        smart_ptr<Drawer> getDrawer(void) { return m_drawer; }
        void registerFactory(IN const char * type,
                                IN smart_ptr<Factory>& factory);
        Factory * getFactory(IN const char * type);
        void display(IN int screen_w, IN int screen_h);
        void cursor(IN int x, IN int y);
        void button(IN int button, IN int state, IN int x, IN int y);
        void keyboard(IN int key, IN int mods);
        bool createDialog(IN const char * id,
                                IN int x, IN int y,
                                IN const Datahash * form,
                                IN Host * host);
        bool doesDialogExist(IN const char * id);
        void destroyDialog(IN const char * id);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<Factory> > factory_map_t;

        // private helper methods ----------------------------------------------
        dialog_record_t * getDialog(IN const char * id);
        void submit(IN const char * id, IN const char * result);

        // private member data -------------------------------------------------
        factory_map_t                   m_factories;
        dialog_map_t                    m_dialogs;
        rect_t                          m_viewport;
        std::string                     m_cursorTag;
        bool                            m_cursorDown;
        std::string                     m_dragId;
        point_t                         m_dragStart;
        Element *                       m_focus;        // keyboard focus
        std::string                     m_focusId;
        smart_ptr<crypto::DESKey>       m_desKey;
        smart_ptr<Drawer>               m_drawer;
};



void
Mgr::initialize
(
IN smart_ptr<crypto::DESKey>& desKey,
IN smart_ptr<Drawer>& drawer
)
{
        // ASSERT(desKey) -- can be null!
        m_desKey = desKey;

        ASSERT(drawer, "null");
        ASSERT(!m_drawer, "already have a drawer?");
        m_drawer = drawer;

        // nothing to do yet...
        m_cursorDown = false;
        m_cursorTag = "";
        m_dragId = "";
        m_focus = NULL;

        // register default types
        registerDefaultFactories(this);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- dialog::Manager class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
Mgr::registerFactory
(
IN const char * type,
IN smart_ptr<Factory>& factory
)
{
        ASSERT(type, "null");
        ASSERT(factory, "null");

        // don't worry about collisions--last one in wins
        m_factories[type] = factory;
}



void
Mgr::display
(
IN int screen_w,
IN int screen_h
)
{
        // loop through all dialogs and ask them to draw
        for (dialog_map_t::iterator i = m_dialogs.begin(); i != m_dialogs.end();
             ++i) {
                dialog_record_t& dr = i->second;
                ASSERT(dr.root, "null");

                // get this dialog's width and height
                int width = dr.bounds.right - dr.bounds.left;
                int height = dr.bounds.bottom - dr.bounds.top;

                // the x,y position we are talking about is the dialog's top
                //   left

                // minimum X: lesser of 0 or screen width - dialog width
                int minX = screen_w - width;
                if (minX > 0) {
                        minX = 0;
                }
                int minY = screen_h - height;
                if (minY > 0) {
                        minY = 0;
                }

                // clip!
                int dx, dy;
                dx = dy = 0;
                if (dr.bounds.left < minX) {
                        dx = minX - dr.bounds.left;
                }
                if (dr.bounds.top < minY) {
                        dy = minY - dr.bounds.top;
                }
                dr.bounds.shift(dx, dy);

                // maximum X: max of 0 or screen width - dialog width
                int maxX = screen_w - width;
                if (maxX < 0)
                        maxX = 0;
                int maxY = screen_h - height;
                if (maxY < 0)
                        maxY = 0;
                if (dr.bounds.left > maxX) {
                        dx = maxX - dr.bounds.left;
                }
                if (dr.bounds.top > maxY) {
                        dy = maxY - dr.bounds.top;
                }
                dr.bounds.shift(dx, dy);

                // give the entire dialog a common background
                m_drawer->drawRectWithBorder(eElement_Dialog, dr.bounds);

                // now ask elements to draw recursively
                dr.root->draw(dr.bounds.getTopLeft());
        }
}




void
Mgr::button
(
IN int button,
IN int state,
IN int x,
IN int y
)
{
        // is this a button we care about?
        //DPRINTF("button = %d", button);
        if (button)
                return;         // only care about first button

        point_t pos(x, y);

        const char * result = NULL;
        const char * id = NULL;
        for (dialog_map_t::iterator i = m_dialogs.begin(); i != m_dialogs.end();
             ++i) {
                dialog_record_t& dr = i->second;
                ASSERT(dr.root, "null");

                if (!dr.bounds.contains(pos))
                        continue;               // skip this one

                // convert to element coordinates
                result = dr.root->button(button, state,
                    pos - dr.bounds.getTopLeft());
                id = i->first.c_str();          // in bounding box

                // press down?  check focus
                if (!state) {
                        Element * focus =
                            dr.root->getFocus(pos - dr.bounds.getTopLeft());
                        DPRINTF("Focus: %p", m_focus);
                        if (focus) {
                                if (m_focus) {
                                        m_focus->notifyFocus(false);
                                }
                                m_focus = focus;
                                m_focus->notifyFocus(true);
                                m_focusId = id;
                        }
                }
        }

        // was this a release?
        if (state) {
                // yes, a release
                const char * oldTag = m_cursorTag.c_str();
                if (result && !strcmp(result, oldTag)) {
                        DPRINTF("Cursor down + up on same element!");
                        this->submit(id, result);
                }

                // clear out cursor state
                m_cursorTag = "";
                m_cursorDown = false;
                m_dragId = "";
        } else {
                // this was a cursor down
                m_cursorTag = result ? result : "";
                m_cursorDown = true;

                // nothing hit?  then it is a drag
                if (!result && id) {
                        m_dragId = id;
                        m_dragStart.set(x, y);
                }
        }

/*
        if (result) {
                DPRINTF("Got %s", result);
        }
 */
}



void
Mgr::cursor
(
IN int x,
IN int y
)
{
        // only care if we are dragging
        if (m_cursorDown && !m_dragId.empty()) {
                // dragging!
                point_t delta = point_t(x, y) - m_dragStart;
                m_dragStart.set(x, y);

                // look up record
                dialog_record_t * pdr = this->getDialog(m_dragId.c_str());
                if (!pdr) {
                        // gone?
                        m_dragId = "";
                } else {
                        pdr->bounds.shift(delta.x, delta.y);

                }
        }
}



void
Mgr::keyboard
(
IN int key,
IN int mods
)
{
        //DPRINTF("Got key=%d, mods=0x%08x", key, mods);
        if (m_focus) {
                DPRINTF("  Someone has focus!");
                const char * result = m_focus->keyboard(key, mods);
                if (result) {
                        DPRINTF("Submit after key event!  '%s'", result);
                        this->submit(m_focusId.c_str(), result);
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

dialog_record_t *
Mgr::getDialog
(
IN const char * id
)
{
        ASSERT(id, "null");

        dialog_map_t::iterator i = m_dialogs.find(id);
        if (m_dialogs.end() == i) {
                return NULL;            // not found
        }

        return &i->second;
}



void
Mgr::submit
(
IN const char * id,
IN const char * result
)
{
        ASSERT(id, "null");
        ASSERT(result, "null");

        dialog_record_t * pdr = this->getDialog(id);
        if (!pdr || !pdr->host)
                return;         // stale data???
        ASSERT(pdr->root, "null root");

        // need to notify host
        smart_ptr<Datahash> data = Datahash::create();
        ASSERT(data, "failed to create empty hash");
        data->insert("submit", result);
        pdr->root->addData(m_desKey, data);
        pdr->host->notifySubmit(id, data);

        // clear focus etc just in case
        m_focus = NULL;
        m_focusId = "";
}



/// creates a dialog at the specified x,y position (actual screen position
/// depends on where the client has positioned the DialogManager).
///
/// Returns false if the dialog cannot be constructed.  Typically this only
/// happens if the ID is itself invalid.
bool
Mgr::createDialog
(
IN const char * id,
IN int x,
IN int y,
IN const Datahash * data,
IN Host * host
)
{
        perf::Timer timer("createDialog");
        ASSERT(id, "null");
        ASSERT(data, "null");
        // ASSERT(host) -- we don't care!

        //DPRINTF("In createDialog()...");

        // valid id?
        if (!*id) {
                DPRINTF("Don't allow empty IDs...");
                return false;
        }

        // does this dialog already exist?
        // we don't care!  A duplicate request will take precedence
        // actually, we kind of care--if this is a duplicate, we'll use the
        //      existing xy coordinates
        dialog_record_t * pdr = this->getDialog(id);
        if (pdr) {
                // override what was passed in -- use existing xy instead
                x = pdr->bounds.left;
                y = pdr->bounds.top;
        }

        dialog_record_t dr;
        dr.host = host;
        dr.root = constructElementTree(this, data);
        ASSERT(dr.root, "failed to construct dialog element tree");

        // determine bounding rect
        int w = dr.root->getWidth();
        int h = dr.root->getHeight();
        ASSERT(w > 0 && h > 0, "Bad dialog width or height: %d x %d", w, h);
        dr.bounds.set(x, y, x + w, y + h);

        // save record
        m_dialogs[id] = dr;

        return true;
}



bool
Mgr::doesDialogExist
(
IN const char * id
)
{
        ASSERT(id, "null");

        return this->getDialog(id) ? true : false;
}



void
Mgr::destroyDialog
(
IN const char * id
)
{
        ASSERT(id, "null");

        dialog_map_t::iterator i = m_dialogs.find(id);
        if (m_dialogs.end() == i) {
                DPRINTF("No dialog to destroy!  Id='%s'", id);
                return;
        }

        // clear out focus, just in case
        m_focus = NULL;
        m_focusId = "";

        m_dialogs.erase(i);
}



Factory *
Mgr::getFactory
(
IN const char * type
)
{
        ASSERT(type, "null");

        factory_map_t::iterator i = m_factories.find(type);
        if (m_factories.end() == i) {
                DPRINTF("No factory found for dialog element type: '%s'", type);
                return NULL;
        }
        ASSERT(i->second, "null factory in map");
        return i->second;
}



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

smart_ptr<Manager>
Manager::create
(
IN smart_ptr<crypto::DESKey>& desKey,
IN smart_ptr<Drawer>& drawer
)
{
        // ASSERT(desKey) -- can be null
        ASSERT(drawer, "null");

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

        local->initialize(desKey, drawer);

        return local;
}



};      // dialog namespace