textbox.cpp

Go to the documentation of this file.

/*
 * textbox.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 a text entry field.
 */

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

#include "dialog.h"

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


namespace dialog {


static const int s_max                          = 126;  // 2^N - 2

////////////////////////////////////////////////////////////////////////////////
//
//      Textbox -- class that implements the Element interface for text elements
//
////////////////////////////////////////////////////////////////////////////////

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

        // public class methods ------------------------------------------------
        void initialize(IN const Datahash * hash,
                                IN smart_ptr<Drawer>& drawer);

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

private:
        // private helper methods ----------------------------------------------

        // private member data -------------------------------------------------
        std::string             m_name;
        char                    m_value[s_max + 2];     // caret + null
        std::string             m_label;
        int                     m_max;
        int                     m_width;
        int                     m_height;
        int                     m_valueOffset;
        int                     m_size;
        int                     m_rise;
        int                     m_border;
        bool                    m_haveFocus;
        bool                    m_encrypt;
        smart_ptr<Drawer>       m_drawer;
};



Textbox::Textbox(void) throw()
{
        m_max = 0;
        m_haveFocus = false;
        m_size = 0;
        m_border = 0;
        m_value[0] = 0;
        m_encrypt = false;
}



void
Textbox::initialize
(
IN const Datahash * hash,
IN smart_ptr<Drawer>& drawer
)
{
        ASSERT(hash, "null");
        ASSERT(drawer, "null");

        m_drawer = drawer;
        m_name = getString(hash, "name");
        std::string value = getString(hash, "value");
        m_max = getInt(hash, "max");
        if (m_max < 1) {
                WAVE_EX(wex);
                wex << "Bad textbox max size: " << m_max;
        }
        if (m_max > s_max) {
                DPRINTF("Truncating textbox size!  Max is %d", s_max);
                m_max = s_max;
        }
        std::string enc = getOptionalString(hash, "encrypt", "");
        m_encrypt = ("true" == enc);

//      DPRINTF("name: %s", m_name.c_str());
//      DPRINTF("value: %s", value.c_str());
//      DPRINTF("max: %d", m_max);
//      DPRINTF("encrypt: %s", (m_encrypt ? "true" : "false"));

        m_label = m_name;
        m_label += ": ";

        // account for width of label
        font_size_t fs =
            m_drawer->getFontSizing(eElement_Textbox, m_label.c_str());
        m_width = fs.lead + fs.trail + 1;
        m_height = fs.rise + fs.drop + 1;
        m_rise = fs.rise;

        border_size_t bs = m_drawer->getBorderSizing(eElement_Textbox);
        m_border = bs.size;
        m_width += bs.size;
        m_valueOffset = m_width + bs.size;

        // account for width of (possible) value
        for (int i = 0; i < m_max; ++i) {
                m_value[i] = 'M';
        }
        m_value[m_max] = '|';
        m_value[m_max + 1] = 0;
//      DPRINTF("m_value = '%s'", m_value);

        fs = m_drawer->getFontSizing(eElement_Textbox, m_value);
        m_width += fs.lead + fs.trail + 1;
        m_width += 3 * bs.size;

        // copy in actual value
        strncpy(m_value, value.c_str(), m_max);
        m_value[m_max] = 0;     // force null-termination
        m_size = strlen(m_value);
//      DPRINTF("m_value = '%s'", m_value);
        ASSERT(m_size <= m_max, "Bad size?  %d vs max %d", m_size, m_max);

        // use largest height + rise values
        int height = fs.rise + fs.drop + 1;
        if (height > m_height) {
                m_height = height;
        }
        if (fs.rise > m_rise) {
                m_rise = fs.rise;
        }
        m_height += 2 * bs.size;        // account for border size
}



void
Textbox::draw
(
IN const point_t& offset
)
{
        ASSERT(m_drawer, "null");

        // draw label
        point_t pos(offset.x + m_border, offset.y + m_border + m_rise);
        m_drawer->drawString(eElement_Textbox, pos, m_label.c_str());

        // draw textbox
        if (m_haveFocus) {
                DPRINTF("TODO: focus?");
        }
        rect_t r(offset.x + m_valueOffset, offset.y,
            offset.x + m_width, offset.y + m_height);
        m_drawer->drawRectWithBorder(eElement_Textbox, r);

        // save if encrypted!
        // TODO: get rid of this!  Keep a display and actual separate...
        char save_val[s_max + 1];
        if (m_encrypt) {
                for (int i = 0; i < m_size; ++i) {
                        save_val[i] = m_value[i];
                        m_value[i] = '*';
                }
                save_val[m_size] = 0;
        }

        // draw value
        // TODO: blah!  draw caret separately, not by tweaking string
        bool showCaret = m_haveFocus && (time(NULL) % 2);
        if (showCaret) {
                m_value[m_size] = '|';
                m_value[m_size + 1] = 0;
        }

        pos.x = offset.x + m_valueOffset + m_border;
        pos.y = offset.y + m_border + m_rise;
        m_drawer->drawString(eElement_Textbox, pos, m_value);
        if (showCaret) {
                m_value[m_size] = 0;
        }

        // restore if encrypted!
        if (m_encrypt) {
                for (int i = 0; i < m_size; ++i) {
                        m_value[i] = save_val[i];
                }
                m_value[m_size] = 0;
        }
}



const char *
Textbox::keyboard
(
IN int key,
IN int mods
)
{
        char a = (char) key;

        if (8 == key || 127 == key) {
                // delete or backspace
                if (m_size > 0) {
                        m_size--;
                        m_value[m_size] = 0;
                }
        } else if (isalnum(a) || 32 == a) {
                // regular key
                if (m_size < m_max) {
                        m_value[m_size] = a;
                        ++m_size;
                        m_value[m_size] = 0;
                }
        } else if (13 == key) {
                // ENTER key pressed!
                return m_name.c_str();
        }

        // nothing submitted
        return NULL;
}



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

        // add our name: value pair
        std::string enc;
        const char * val = m_value;
        if (m_encrypt) {
                if (!key) {
                        WAVE_EX(wex);
                        wex << "Asked to encrypt, but no encryption key ";
                        wex << "provided.  textbox name: " << m_name;
                }
                enc = key->encrypt(m_value, m_max);
                val = enc.c_str();
        }
        data->insert(m_name, val);
}



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

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

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

        smart_ptr<Drawer> drawer = mgr->getDrawer();
        local->initialize(hash, drawer);

        return local;
}



};      // dialog namespace