Element.hpp

#pragma once
 
#include "InputEvents.hpp"
#include "colorspaces.hpp"
#include "DrawUtils.hpp"
#include "Animation.hpp"
 
#include <functional>
#include <vector>
#include <string>
 
#define DEEP_HIGHLIGHT 200
#define THICK_HIGHLIGHT 150
#define HIGHLIGHT 100
#define NO_HIGHLIGHT 0
 
#if defined(USE_RAMFS)
#define RAMFS "resin:/"
#else
#define RAMFS "resin/"
#endif
 
#if defined(_3DS) || defined(_3DS_MOCK)
#define SCALER 2
#elif defined(WII) || defined(WII_MOCK)
#define SCALER 1.5
#else
#define SCALER 1
#endif
 
class Constraint;
 
class Element
{
public:
    Element();
    virtual ~Element();
 
    virtual bool process(InputEvents* event);
 
    virtual void render(Element* parent);
 
    // invoked on touchdown/up events
    bool onTouchDown(InputEvents* event);
    bool onTouchDrag(InputEvents* event);
    bool onTouchUp(InputEvents* event);
 
    // hide the element
    void hide() { this->hidden = true; }
    // unhide the element
    void unhide() { this->hidden = false; }
 
    // render the element's background
    void renderBackground(bool fill = true);
 
    std::function<void()> action = NULL;
    std::function<void(InputEvents* event)> actionWithEvents = NULL;
 
    std::vector<Element*> elements;
 
    void append(Element* element);
    void remove(Element* element);
    void removeAll(bool moveToTrash = false);
 
    void position(int x, int y);
 
    // recalculate xAbs and yAbs based on the given parent
    void recalcPosition(Element* parent);
 
    // the scale of the element (and its subelements!)
    float scale = 1.0f;
 
    bool touchable = false;
 
    bool dragging = false;
 
    bool needsRedraw = false;
 
    int futureRedrawCounter = 0;
 
    int lastMouseY = 0, lastMouseX = 0;
 
    // whether this element has a background
    bool hasBackground = false;
 
    // the color of the background
    rgb backgroundColor = {0, 0, 0};
 
    // opacity of the background (0-255)
    int backgroundOpacity = 0xff;
 
    // if this element should ignore parent position and just position itself
    bool isAbsolute = false;
 
    Element* parent = NULL;
 
    bool hidden = false;
 
    // bounds on screen of this element
    CST_Rect getBounds();
 
    // whether or not this should be automatically free'd by wipeAll
    bool isProtected = false;
 
    int elasticCounter = 0;
 
    int width = 0, height = 0;
 
    typedef Element super;
 
    // position relative to parent (if given) or screen (NULL parent)
    int x = 0, y = 0;
 
    // actual onscreen position (calculated at render time)
    int xAbs = 0, yAbs = 0;
    double angle = 0;
 
    // x and y offsets (can be used for drawing relative to other elements)
    int xOff = 0, yOff = 0;
 
    // corner radius (when non-zero, backgrounds, textures, and rectangles are rounded)
    int cornerRadius = 0;
 
    // internal get current renderer or default one
    CST_Renderer* getRenderer();
 
    // delete this element's children, and their children, and so on
    // if you've been using `new` everywhere, calling this can make sense in your
    // top level component's destructor to free all the memory from that branch
    // (not automatically invoked in case implementor wants to manage it)
    void wipeAll(bool delSelf = false);
 
    // fun chain-able wrappers to some fields, returns back the same element
    Element* child(Element* child);
    Element* setPosition(int x, int y);
    Element* setAction(std::function<void()> func);
 
    // alignment chainers
    Element* centerHorizontallyIn(Element* parent);
    Element* centerVerticallyIn(Element* parent);
    Element* centerIn(Element* parent);
    Element* setAbsolute(bool isAbs);
 
    // constraints that can be added and used by positioning functions
    std::vector<Constraint*> constraints;
    Element* constrain(int flags, int padding = 0);
 
    // animations that can be added and will tween over time (and remove when finished)
    std::vector<Animation*> animations;
    Element* animate(
        int durationIn,
        std::function<void(float)> onStep,
        std::function<void()> onFinish
    );
 
    Element* moveToFront();
    Element* setTouchable(bool touchable);
 
    void screenshot(std::string path);
 
    bool useColorMask = false;
 
    CST_Color maskColor = {0,0,0,0};
 
    // a function to call to re-align according to all constraints
    // std::function<void()> alignmentCommands;
};