GamePlay/gameplay/src/Control.cpp

#include "Base.h"
#include "Control.h"

namespace gameplay
{
    Control::Control()
        : _id(""), _state(Control::STATE_NORMAL), _size(Vector2::zero()), _position(Vector2::zero()), _border(Vector2::zero()), _padding(Vector2::zero()),
          _autoWidth(true), _autoHeight(true), _dirty(true), _consumeTouchEvents(true)
    {
    }

    Control::Control(const Control& copy)
    {
    }

    Control::~Control()
    {
    }

    void Control::init(Theme::Style* style, Properties* properties)
    {
        _style = style;

        properties->getVector2("position", &_position);
        properties->getVector2("size", &_size);

        _state = Control::getStateFromString(properties->getString("state"));

        const char* id = properties->getId();
        if (id)
        {
            _id = id;
        }
    }

    const char* Control::getID()
    {
        return _id.c_str();
    }

    const Rectangle Control::getBounds(bool includePadding) const
    {
        // TODO
        return Rectangle();
    }

    void Control::setPosition(float x, float y)
    {
        _position.set(x, y);
    }

    const Vector2& Control::getPosition() const
    {
        return _position;
    }

    void Control::setSize(float width, float height)
    {
        _size.set(width, height);
    }

    const Vector2& Control::getSize() const
    {
        return _size;
    }

    void Control::setAutoSize(bool width, bool height)
    {
        _autoWidth = width;
        _autoHeight = height;
    }

    void Control::setStyle(Theme::Style* style)
    {
        _style = style;
    }

    Theme::Style* Control::getStyle() const
    {
        return _style;
    }

    void Control::setState(State state)
    {
        _state = state;
    }

    Control::State Control::getState()
    {
        return _state;
    }

    void Control::disable()
    {
        _state = STATE_DISABLED;
    }

    void Control::enable()
    {
        _state = STATE_NORMAL;
    }

    bool Control::isEnabled()
    {
        return _state != STATE_DISABLED;
    }

    Theme::Style::OverlayType Control::getOverlayType() const
    {
        switch (_state)
        {
        case Control::STATE_NORMAL:
            return Theme::Style::OVERLAY_NORMAL;
        case Control::STATE_FOCUS:
            return Theme::Style::OVERLAY_FOCUS;
        case Control::STATE_ACTIVE:
            return Theme::Style::OVERLAY_ACTIVE;
        case Control::STATE_DISABLED:
            return Theme::Style::OVERLAY_DISABLED;
        default:
            return Theme::Style::OVERLAY_NORMAL;
        }
    }

    void Control::setConsumeTouchEvents(bool consume)
    {
        _consumeTouchEvents = consume;
    }
    
    bool Control::getConsumeTouchEvents()
    {
        return _consumeTouchEvents;
    }

    bool Control::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
    {
        // Empty stub to be implemented by Button and its descendents.
        return _consumeTouchEvents;
    }

    void Control::keyEvent(Keyboard::KeyEvent evt, int key)
    {
    }

    void Control::update(const Vector2& position)
    {
    }

    void Control::drawBorder(SpriteBatch* spriteBatch, const Vector2& position)
    {
        Vector2 pos(position.x + _position.x, position.y + _position.y);

        // Get the border and background images for this control's current state.
        Theme::ContainerRegion* containerRegion = _style->getOverlay(getOverlayType())->getContainerRegion();
        if (containerRegion)
        {
            // Get the UVs.
            Theme::UVs topLeft, top, topRight, left, center, right, bottomLeft, bottom, bottomRight;
            topLeft = containerRegion->getUVs(Theme::ContainerRegion::TOP_LEFT);
            top = containerRegion->getUVs(Theme::ContainerRegion::TOP);
            topRight = containerRegion->getUVs(Theme::ContainerRegion::TOP_RIGHT);
            left = containerRegion->getUVs(Theme::ContainerRegion::LEFT);
            center = containerRegion->getUVs(Theme::ContainerRegion::CENTER);
            right = containerRegion->getUVs(Theme::ContainerRegion::RIGHT);
            bottomLeft = containerRegion->getUVs(Theme::ContainerRegion::BOTTOM_LEFT);
            bottom = containerRegion->getUVs(Theme::ContainerRegion::BOTTOM);
            bottomRight = containerRegion->getUVs(Theme::ContainerRegion::BOTTOM_RIGHT);

            // Calculate screen-space positions.
            Theme::Border border = containerRegion->getBorder();
            Theme::Padding padding = _style->getPadding();
            Vector4 borderColor = containerRegion->getColor();

            float midWidth = _size.x - border.left - border.right;
            float midHeight = _size.y - border.top - border.bottom;
            float midX = pos.x + border.left;
            float midY = pos.y + border.top;
            float rightX = pos.x + _size.x - border.right;
            float bottomY = pos.y + _size.y - border.bottom;

            // Draw themed border sprites.
            if (!border.left && !border.right && !border.top && !border.bottom)
            {
                // No border, just draw the image.
                spriteBatch->draw(pos.x, pos.y, _size.x, _size.y, center.u1, center.v1, center.u2, center.v2, borderColor);
            }
            else
            {
                if (border.left && border.top)
                    spriteBatch->draw(pos.x, pos.y, border.left, border.top, topLeft.u1, topLeft.v1, topLeft.u2, topLeft.v2, borderColor);
                if (border.top)
                    spriteBatch->draw(pos.x + border.left, pos.y, midWidth, border.top, top.u1, top.v1, top.u2, top.v2, borderColor);
                if (border.right && border.top)
                    spriteBatch->draw(rightX, pos.y, border.right, border.top, topRight.u1, topRight.v1, topRight.u2, topRight.v2, borderColor);
                if (border.left)
                    spriteBatch->draw(pos.x, midY, border.left, midHeight, left.u1, left.v1, left.u2, left.v2, borderColor);
                if (border.left && border.right && border.top && border.bottom)
                    spriteBatch->draw(pos.x + border.left, pos.y + border.top, _size.x - border.left - border.right, _size.y - border.top - border.bottom,
                        center.u1, center.v1, center.u2, center.v2, borderColor);
                if (border.right)
                    spriteBatch->draw(rightX, midY, border.right, midHeight, right.u1, right.v1, right.u2, right.v2, borderColor);
                if (border.bottom && border.left)
                    spriteBatch->draw(pos.x, bottomY, border.left, border.bottom, bottomLeft.u1, bottomLeft.v1, bottomLeft.u2, bottomLeft.v2, borderColor);
                if (border.bottom)
                    spriteBatch->draw(midX, bottomY, midWidth, border.bottom, bottom.u1, bottom.v1, bottom.u2, bottom.v2, borderColor);
                if (border.bottom && border.right)
                    spriteBatch->draw(rightX, bottomY, border.right, border.bottom, bottomRight.u1, bottomRight.v1, bottomRight.u2, bottomRight.v2, borderColor);
            }
        }
    }

    void Control::drawSprites(SpriteBatch* spriteBatch, const Vector2& position)
    {
    }

    void Control::drawText(const Vector2& position)
    {
    }

    bool Control::isDirty()
    {
        return _dirty;
    }

    Control::State Control::getStateFromString(const char* state)
    {
        if (!state)
        {
            return STATE_NORMAL;
        }

        if (strcmp(state, "STATE_NORMAL") == 0)
        {
            return STATE_NORMAL;
        }
        else if (strcmp(state, "STATE_ACTIVE") == 0)
        {
            return STATE_ACTIVE;
        }
        else if (strcmp(state, "STATE_FOCUS") == 0)
        {
            return STATE_FOCUS;
        }
        else if (strcmp(state, "STATE_DISABLED") == 0)
        {
            return STATE_DISABLED;
        }

        return STATE_NORMAL;
    }
}