element.cpp

Go to the documentation of this file.

/*
 * element.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.
 *
 *
 * Central parsing and registry for dialog elements.
 */

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

#include "common/wave_ex.h"

#include "datahash/datahash_util.h"

#include "perf/perf.h"


namespace dialog {


Factory::~Factory(void) throw() { }

// Element base class implementation
Element::~Element(void) throw() { }


const char *
Element::keyboard
(
IN int key,
IN int mods
)
{
        // nothing to do!
        return NULL;
}



Element *
Element::getFocus
(
IN const point_t& pos
)
{
        return NULL;    // no one gets focus
}



void
Element::notifyFocus
(
IN bool haveFocus
)
{
}



void
Element::addData
(
IN crypto::DESKey * key,
IN Datahash * data
)
{
        // nothing to do
}



typedef smart_ptr<Element> (*construct_fn_t)(IN Manager * mgr,
                                IN const Datahash * hash);


struct type_entry_t {
        const char *            name;           // type name
        construct_fn_t          fn;             // constructor
};


#define DECLARE_FN( type )                                              \
        smart_ptr<Element> create ## type ## Element (                  \
                IN Manager * mgr,                                       \
                IN const Datahash * hash );

DECLARE_FN(Button)
DECLARE_FN(Container)
DECLARE_FN(Label)
DECLARE_FN(Textbox)



static const type_entry_t entries[] = {

        { "button",             createButtonElement },
        { "container",          createContainerElement },
        { "label",              createLabelElement },
        { "textbox",            createTextboxElement },

        // must be last
        { NULL, NULL }
};


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

static construct_fn_t
getFn
(
IN const char * type_name
)
{
        ASSERT(type_name, "null");

        for (const type_entry_t * p = entries; p->name; ++p) {
                if (!strcmp(p->name, type_name)) {
                        return p->fn;
                }
        }

        // not found!
        return NULL;
}



////////////////////////////////////////////////////////////////////////////////
//
//      DFactory -- default dialog::Factory object
//
////////////////////////////////////////////////////////////////////////////////

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

        // public class methods ------------------------------------------------
        void initialize(void) throw() { }

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



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

        // see if we've got this registered in our table of base objects
        construct_fn_t fn = getFn(type);
        ASSERT_THROW(fn, "No default construction function for element type: "
            << type);
        return fn(mgr, data);
}



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

smart_ptr<Element>
constructElementTree
(
IN Manager * mgr,
IN const Datahash * hash
)
{
        perf::Timer timer("constructElementTree");
        ASSERT(mgr, "null");
        ASSERT(hash, "null");

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

        // Get the type, and its registered constructor
        const char * type = getString(hash, "type");
        // DPRINTF("Constructing element of type '%s'", type);
        Factory * factory = mgr->getFactory(type);
        ASSERT_THROW(factory,
            "No factory registered for dialog element of type '" <<
            type << "'");

        return factory->createElement(type, mgr, hash);
}



smart_ptr<Factory>
getDefaultFactory
(
void
)
{
        smart_ptr<DFactory> local = new DFactory;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



void
registerDefaultFactories
(
IN Manager * mgr
)
{
        ASSERT(mgr, "null");

        smart_ptr<Factory> factory = getDefaultFactory();
        ASSERT(factory, "null");

        for (const type_entry_t * p = entries; p->name; ++p) {
                mgr->registerFactory(p->name, factory);
        }
}



};      // dialog namespace