container.cpp

Go to the documentation of this file.

/*
 * container.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 basic container object.
 */

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

#include "dialog.h"

#include "datahash/datahash_util.h"



namespace dialog {

static const int s_border                       = 2;


struct element_record_t {
        rect_t                  bounds;
        smart_ptr<Element>      element;
};


typedef std::vector<element_record_t> vec_element_t;



////////////////////////////////////////////////////////////////////////////////
//
//      Container -- container implementation class
//
////////////////////////////////////////////////////////////////////////////////

class Container : public Element {
public:
        Container(void) throw();
        ~Container(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN vec_element_t& children,
                                IN int width, IN int height);

        // dialog::Element class interface methods -----------------------------
        int getWidth(void);
        int getHeight(void);
        void draw(IN const point_t& offset);
        void cursor(IN const point_t& pos);
        Element * getFocus(IN const point_t& pos);
        const char * button(IN int button, IN int state, IN const point_t& pos);
        void addData(IN crypto::DESKey * desKey, IN Datahash * data);

private:
        // private helper methods ----------------------------------------------
        Element * getChild(IN const point_t& pos, OUT point_t& rel);
        rect_t getRect(IN const element_record_t& er);

        // private member data -------------------------------------------------
        int                     m_width;
        int                     m_height;
        vec_element_t           m_children;
        smart_ptr<Drawer>       m_drawer;
};



Container::Container(void)
throw()
{
        m_width = -1;
        m_height = -1;
}



void
Container::initialize
(
IN vec_element_t& children,
IN int width,
IN int height
)
{
        ASSERT(width > 0, "empty?");
        ASSERT(height > 0, "empty?");

        m_children = children;
        m_width = width;
        m_height = height;
}



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

int
Container::getWidth
(
void
)
{
        return m_width;
}


int
Container::getHeight
(
void
)
{
        return m_height;
}



void
Container::draw
(
IN const point_t& offset
)
{
        for (vec_element_t::iterator i = m_children.begin();
             i != m_children.end(); ++i) {
                element_record_t& er = *i;
                ASSERT(er.element, "null element in vector");

                // child is told to draw to correct global coordinates
                point_t border(s_border, s_border);
                er.element->draw(offset + er.bounds.getTopLeft() + border);
        }
}



void
Container::cursor
(
IN const point_t& pos
)
{
        point_t rel;
        Element * e = this->getChild(pos, rel);
        if (e) {
                e->cursor(rel);
        }
}



const char *
Container::button
(
IN int button,
IN int state,
IN const point_t& pos
)
{
        point_t rel;
        Element * e = this->getChild(pos, rel);
        return e ? e->button(button, state, rel) : NULL;
}



Element *
Container::getFocus
(
IN const point_t& pos
)
{
        //DPRINTF("Looking for focus at (%d, %d)", pos.x, pos.y);
        point_t rel;
        Element * e = this->getChild(pos, rel);
        //DPRINTF("  Found element: %p", e);
        return e ? e->getFocus(rel) : NULL;
}



void
Container::addData
(
IN crypto::DESKey * key,
IN Datahash * data
)
{
        // ASSERT(key) -- can be null
        ASSERT(data, "null");

        for (vec_element_t::iterator i = m_children.begin();
             i != m_children.end(); ++i) {
                element_record_t& er = *i;
                ASSERT(er.element, "null element in vector");

                // child can attach data
                er.element->addData(key, data);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      Container -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

Element *
Container::getChild
(
IN const point_t& pos,
OUT point_t& rel                        ///< child-relative coordinates
)
{
        rel.clear();

        for (vec_element_t::iterator i = m_children.begin();
             i != m_children.end(); ++i) {
                element_record_t& er = *i;
                ASSERT(er.element, "null element in vector");

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

                // convert to child-relative coordinates
                point_t border(s_border, s_border);
                rel = pos - er.bounds.getTopLeft() - border;
                return er.element;
        }

        // nothing found!
        return NULL;
}



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

smart_ptr<Element>
createContainerElement
(
IN Manager * mgr,
IN const Datahash * hash
)
{
        ASSERT(mgr, "null");
        ASSERT(hash, "null");

        vec_element_t children;

        // first, construct all child elements
        int maxW = 0;
        int maxH = 0;
        Datahash::iterator_t i;
        hash->getIterator("element", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                ASSERT_THROW(eHashDataType_Hash == phv->type,
                    "Bad datahash datatype (expected hash)");
                smart_ptr<Datahash> subhash = phv->hash;
                ASSERT(subhash, "null subhash");

                // construct this child tree
                element_record_t er;
                er.element = constructElementTree(mgr, subhash);
                ASSERT(er.element, "failed to create element subtree");

                // stash known size
                int w = er.element->getWidth();
                int h = er.element->getHeight();
                //DPRINTF("Element claims width is %d", w);
                if (w > maxW) {
                        maxW = w;
                }
                if (h > maxH) {
                        maxH = h;
                }
                er.bounds.set(0, 0, w, h);

                children.push_back(er);
        }

        // vertically or horizontally aligned?
        std::string s_align = getOptionalString(hash, "axis", "v");
        char align = 'v';
        if ("h" == s_align) {
                align = 'h';
        }

        // border settings?
        int borderX = getOptionalLong(hash, "borderX", s_border);
        int borderY = getOptionalLong(hash, "borderY", s_border);

        // width string?
        const char * widthString =
            getOptionalString(hash, "widthString", NULL);
        if (widthString) {
                // get drawer
                smart_ptr<Drawer> drawer = mgr->getDrawer();
                ASSERT(drawer, "null drawer?");

                font_size_t fs =
                    drawer->getFontSizing(eElement_Label, widthString);
                int width = fs.lead + fs.trail;
                if (width > maxW) {
                        maxW = width;
                }
        }

        // now loop again and determine proper x,y values
        int oldX = 0;
        int oldY = 0;
        for (vec_element_t::iterator i = children.begin(); i != children.end();
             ++i) {
                element_record_t& er = *i;

                if ('v' == align) {
                        int dx = (int) (0.5 * (maxW - er.bounds.right) + 0.5);
                        er.bounds.set(dx, oldY, er.bounds.right + dx,
                            er.bounds.bottom + oldY);
                        oldY = er.bounds.bottom;
                        oldY += borderY;
                } else {
                        int dy = (int) (0.5 * (maxH - er.bounds.bottom) + 0.5);
                        er.bounds.set(oldX, dy, er.bounds.right + oldX,
                            er.bounds.bottom + dy);
                        oldX = er.bounds.right;
                        oldX += borderX;
                }

                //er.bounds.dump("Child element");
        }

        // update max width, height
        if ('v' == align) {
                maxH = oldY;
                maxW += borderX;
        } else {
                maxW = oldX;
                maxH += borderY;
        }
        maxW += borderX;
        maxH += borderY;

        // create container
        smart_ptr<Container> local = new Container;
        ASSERT(local, "out of memory");

        local->initialize(children, maxW, maxH);

        return local;
}



};      // dialog namespace