Widget.h

Go to the documentation of this file.

/*
 * Copyright 2014 (C) Yannick Pflanzer <neo-engine.de>
 *
 * This file is part of Neo2D.
 *
 * Neo2D is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Neo2D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Neo2D.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Diese Datei ist Teil von Neo2D.
 *
 * Neo2D ist Freie Software: Sie können es unter den Bedingungen
 * der GNU Lesser General Public License, wie von der Free Software Foundation,
 * Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren
 * veröffentlichten Version, weiterverbreiten und/oder modifizieren.
 *
 * Neo2D wird in der Hoffnung, dass es nützlich sein wird, aber
 * OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite
 * Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
 * Siehe die GNU Lesser General Public License für weitere Details.
 *
 * Sie sollten eine Kopie der GNU Lesser General Public License zusammen mit diesem
 * Programm erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>.
 */

#ifndef __WIDGET_H__
#define __WIDGET_H__

#include <NeoEngine.h>
#include <Neo2D.h>
#include <string>
#include <functional>

namespace Neo2D
{

using namespace Neo;
    
// Predefinition
#ifndef SWIG
class Widget;
#endif

//#if !defined(WIN32)
    //typedef void (*CALLBACK_FUNCTION)(Widget*, long int);
//#elif  !defined(SWIG)
//#define CALLBACK_FUNCTION void *
//#endif

typedef std::function<void (Widget*, long int)> NEO_CALLBACK_FUNCTION;

class NEO2D_EXPORT Widget
{
protected:
    float m_x, m_y;

    float m_rotation;

    unsigned int m_width, m_height;

    std::string m_label;

    Vector2 m_offset;

#ifndef SWIG
    NEO_CALLBACK_FUNCTION m_callback;
#endif

    String m_callbackScript;

    long int m_userData;

    bool m_visible;

    Vector2 m_scale;

    Vector2 m_flip;
    float m_fontSize;

    Widget* m_parent;
    
private:
    static void doNothing(Widget* w, long data) {}

    static void callScript(Widget* w, long data)
    {
        Neo::ScriptContext* script = Neo::NeoEngine::getInstance()->getScriptContext();
        script->callFunction(w->m_callbackScript.getSafeString());
    }

public:
    Widget(unsigned int x, unsigned int y, unsigned int width,
           unsigned int height, const char* label);
    Widget();

    void setParent(Widget* w) { m_parent = w; }
    Widget* getParent() { return m_parent; }
    
    float getFontSize() { return m_fontSize; }
    void setFontSize(float s) { m_fontSize = s; }

    void setOffset(Vector2 offset) { m_offset = offset; }
    Vector2 getOffset() { return m_offset; }

    void setSize(unsigned int w, unsigned int h) { m_width = w; m_height = h; }
    Vector2 getSize() { return Vector2(m_width, m_height); }
    
    virtual void draw() { draw(Vector2(0, 0)); }

    virtual void draw(Vector2 offset) { m_offset = offset; }

    virtual void update() = 0;

#ifndef SWIG
    void setCallback(NEO_CALLBACK_FUNCTION func) { m_callback = func; }
#endif

    void setScriptCallback(const char* name)
    {
        m_callbackScript = name;
        m_callback = Widget::callScript;
    }

#ifndef SWIG
    void setCallback(NEO_CALLBACK_FUNCTION func, long int data)
    {
        m_callback = func;
        m_userData = data;
    }
#endif

    long int getUserData() { return m_userData; }

    void setUserData(long int data) { m_userData = data; }

    const char* getLabel() { return m_label.c_str(); }

    void setLabel(const char* l) { m_label = l; }

    void setPosition(Vector2 pos)
    {
        m_x = pos.x;
        m_y = pos.y;
    }

    Vector2 getPosition() { return Vector2(m_x, m_y); }

    void setRotation(float rot) { m_rotation = rot; }

    float getRotation() { return m_rotation; }

    void translate(Vector2 vec)
    {
        m_x += vec.x;
        m_y += vec.y;
    }

    void rotate(float value) { m_rotation += value; }

    void doCallback();

    bool isVisible() { return m_visible; }

    void setVisible(bool v) { m_visible = v; }
    void setScale(Vector2 scale) { m_scale = scale; }
    Vector2 getScale() { return m_scale; }
    void setFlip(Vector2 flip) { m_flip = flip; }
    Vector2 getFlip() { return m_flip; }

    // For runtime identification
    const char* getStaticName() { return "Widget"; }

    virtual bool isMouseOver();
};
}
#endif