Inheritance diagram for Chesto::Element:

Collaboration diagram for Chesto::Element:

Public Types
typedef Element	super

Public Member Functions
virtual bool	process (InputEvents *event)
	process any input that is received for this element More...

virtual void	render (Element *parent)
	display the current state of the display More...

bool	onTouchDown (InputEvents *event)

bool	onTouchDrag (InputEvents *event)

bool	onTouchUp (InputEvents *event)

void	hide ()

void	unhide ()

void	renderBackground (bool fill=true)

void	addNode (std::unique_ptr< Element > node)

void	remove (Element *element)

void	removeAll ()

void	position (int x, int y)
	position the element More...

void	recalcPosition (Element *parent)

float	getEffectiveScale () const

CST_Rect	getBounds ()

CST_Renderer *	getRenderer ()

Element *	setPosition (int x, int y)

Element *	setAction (std::function< void()> func)

Element *	setAbsolute (bool isAbs)

template<typename T , typename... Args>
T *	createNode (Args &&... args)

Element *	constrain (int flags, int padding=0)

Element *	constrainToTarget (Element *target, int flags, int padding=0)

Element *	animate (int durationIn, std::function< void(float)> onStep, std::function< void()> onFinish)

Element *	moveToFront ()

Element *	setTouchable (bool touchable)

void	screenshot (std::string path)
	Take a screenshot of this element and its children, and save it to the given path. More...

Public Attributes
std::function< void()>	action = NULL
	the action to call (from binded callback) on touch or button selection https://stackoverflow.com/questions/14189440/c-class-member-callback-simple-examples More...

std::function< void(InputEvents *event)>	actionWithEvents = NULL

std::vector< std::unique_ptr< Element, std::function< void(Element *)> > >	elements
	visible GUI child elements of this element More...

float	scale = 1.0f

bool	touchable = false
	whether or not this element can be touched (highlights bounds) More...

bool	dragging = false
	whether or not this element is currently being dragged More...

bool	needsRedraw = false
	whether or not this element needs the screen redrawn next time it's processed More...

int	futureRedrawCounter = 0
	whether this element needs a redraw for the next X redraws (decreases each time) (0 is no redraws) More...

int	lastMouseY = 0
	the last Y, X coordinate of the mouse (from a drag probably) More...

int	lastMouseX = 0

bool	hasBackground = false

rgb	backgroundColor = {0, 0, 0}

int	backgroundOpacity = 0xff

bool	isAbsolute = false

Element *	parent = nullptr
	the parent element (reference only, not owned) More...

bool	hidden = false
	whether this element should skip rendering or not More...

bool	isProtected = false

int	elasticCounter = 0
	how much time is left in an elastic-type flick/scroll set by the last distance traveled in a scroll, and counts down every frame More...

int	width = 0
	width and height of this element (must be manually set, isn't usually calculated (but is in some cases, like text or images)) More...

int	height = 0

int	x = 0

int	y = 0

int	xAbs = 0

int	yAbs = 0

double	angle = 0
	rotation angle in degrees More...

int	cornerRadius = 0

int	tag = 0

std::vector< std::unique_ptr< Constraint > >	constraints

std::vector< std::unique_ptr< Animation > >	animations

bool	useColorMask = false
	whether or not to overlay a color mask on top of this element More...

CST_Color	maskColor = {0,0,0,0}
	The color to overlay on top. More...

Protected Member Functions
void	addStackMember (Element *element)

Detailed Description

Definition at line 28 of file Element.hpp.

Member Typedef Documentation

◆ super

typedef Element Chesto::Element::super

Definition at line 134 of file Element.hpp.

Constructor & Destructor Documentation

◆ Element()

Chesto::Element::Element ( )

Definition at line 24 of file Element.cpp.

{
    needsRedraw = true;
}

◆ ~Element()

Chesto::Element::~Element ( )

virtual

Definition at line 16 of file Element.cpp.

{
    // unique_ptrs will automatically cleaned up
    elements.clear();
    constraints.clear();
    animations.clear();
}

Member Function Documentation

◆ addNode()

void Chesto::Element::addNode ( std::unique_ptr< Element > node )

Definition at line 399 of file Element.cpp.

{
    if (!node) {
        #ifdef DEBUG
        printf("[Chesto] Warning: Attempted to add null node to %p\n", this);
        #endif
        return;
    }
    
    Element* rawPtr = node.get();
    
    // check if element already exists
    for (const auto& existing : elements) {
        if (existing.get() == rawPtr) {
            #ifdef DEBUG
            printf("[Chesto] Warning: Node %p already exists in parent %p\n", rawPtr, this);
            #endif
            return;
        }
    }
    
    rawPtr->parent = this;
    
    // transfers ownership and sets up safe deleter
    Element* ptr = node.release();
    elements.push_back(std::unique_ptr<Element, std::function<void(Element*)>>(
        ptr,
        safeElementDeleter
    ));
}

◆ addStackMember()

void Chesto::Element::addStackMember ( Element * element )

protected

Definition at line 430 of file Element.cpp.

{
    if (!element) return;
    
    // check if element already exists
    for (const auto& existing : elements) {
        if (existing.get() == element) {
            return;
        }
    }
    
    element->parent = this;
    element->isProtected = true; // Mark as protected
    
    // For protected (stack-allocated) elements, use the shared safe deleter
    // the deleter checks isProtected flag and skips deletion
    elements.push_back(std::unique_ptr<Element, std::function<void(Element*)>>(
        element,
        safeElementDeleter
    ));
}

◆ animate()

Element * Chesto::Element::animate	(	int	durationIn,
		std::function< void(float)>	onStep,
		std::function< void()>	onFinish
	)

Definition at line 507 of file Element.cpp.

  {
    animations.push_back(std::make_unique<Animation>(
        CST_GetTicks(), duration, onStep, onFinish)
    );
 
    return this;
}

◆ constrain()

Element * Chesto::Element::constrain	(	int	flags,
		int	padding = `0`
	)

Definition at line 494 of file Element.cpp.

{
    constraints.push_back(std::make_unique<Constraint>(flags, padding));
    return this;
}

◆ constrainToTarget()

Element * Chesto::Element::constrainToTarget	(	Element *	target,
		int	flags,
		int	padding = `0`
	)

Definition at line 500 of file Element.cpp.

{
    constraints.push_back(std::make_unique<Constraint>(flags, padding, std::vector<Element*>{target}));
    return this;
}

◆ createNode()

template<typename T , typename... Args>

T * Chesto::Element::createNode ( Args &&... args )

inline

Definition at line 163 of file Element.hpp.

                                  {
        auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
        T* rawPtr = ptr.get();
        addNode(std::move(ptr));
        return rawPtr;
    }

◆ getBounds()

CST_Rect Chesto::Element::getBounds ( )

Definition at line 228 of file Element.cpp.

{
    float effectiveScale = getEffectiveScale();
    return {
        .x = this->xAbs,
        .y = this->yAbs,
        .w = (int)(this->width * effectiveScale),
        .h = (int)(this->height * effectiveScale),
    };
}

◆ getEffectiveScale()

float Chesto::Element::getEffectiveScale ( ) const

Definition at line 223 of file Element.cpp.

                                       {
    // Combines global scale with per-element scale
    return RootDisplay::globalScale * this->scale;
}

◆ getRenderer()

CST_Renderer * Chesto::Element::getRenderer ( )

Definition at line 490 of file Element.cpp.

                                   {
    return RootDisplay::renderer;
}

◆ hide()

void Chesto::Element::hide ( )

inline

Definition at line 46 of file Element.hpp.

46{ this->hidden = true; }

Chesto::Element::hidden

bool hidden

whether this element should skip rendering or not

Definition: Element.hpp:119

◆ moveToFront()

Element * Chesto::Element::moveToFront ( )

Definition at line 520 of file Element.cpp.

                              {
    if (parent != NULL) {
        // lookup this element in parent's vector
        auto position = std::find_if(parent->elements.begin(), parent->elements.end(),
            [this](const std::unique_ptr<Element, std::function<void(Element*)>>& e) { 
                return e.get() == this; 
            });
        
        if (position != parent->elements.end()) {
            // move it to the end
            auto elem = std::move(*position);
            parent->elements.erase(position);
            parent->elements.push_back(std::move(elem));
        }
    }
    return this;
}

◆ onTouchDown()

bool Chesto::Element::onTouchDown ( InputEvents * event )

Definition at line 263 of file Element.cpp.

{
    if (!event->isTouchDown())
        return false;
 
    float effectiveScale = getEffectiveScale();
    int scaledWidth = (int)(this->width * effectiveScale);
    int scaledHeight = (int)(this->height * effectiveScale);
 
    if (!event->touchIn(this->xAbs, this->yAbs, scaledWidth, scaledHeight))
        return false;
 
    // mouse pushed down, set variable
    this->dragging = true;
    this->lastMouseY = event->yPos;
    this->lastMouseX = event->xPos;
 
    // turn on deep highlighting during a touch down
    if (this->touchable)
        this->elasticCounter = DEEP_HIGHLIGHT;
 
    return true;
}

◆ onTouchDrag()

bool Chesto::Element::onTouchDrag ( InputEvents * event )

Definition at line 287 of file Element.cpp.

{
    bool ret = false;
 
    if (!event->isTouchDrag())
        return false;
 
    float effectiveScale = getEffectiveScale();
    int scaledWidth = (int)(this->width * effectiveScale);
    int scaledHeight = (int)(this->height * effectiveScale);
 
    // if we're not in a deeplight (a touchdown event), draw our own drag highlight
    if (this->elasticCounter != DEEP_HIGHLIGHT) {
        if (event->touchIn(this->xAbs, this->yAbs, scaledWidth, scaledHeight)) {
            // if there's currently _no_ highlight, and we're in a drag event on this element,
            // so we should turn on the hover highlight
            this->elasticCounter = THICK_HIGHLIGHT;
            ret |= true;
 
            // play a hover sound and vibrate
            CST_LowRumble(event, 200);
 
            // change the cursor to a hand
            CST_SetCursor(CST_CURSOR_HAND);
        } else {
            auto initialElasticCounter = this->elasticCounter;
 
            // we're in a drag event, but not for this element
            this->elasticCounter = NO_HIGHLIGHT;
 
            if (initialElasticCounter != NO_HIGHLIGHT) {
                // change the cursor back to the arrow
                CST_SetCursor(CST_CURSOR_ARROW);
                ret |= true;
            }
 
        }
    }
 
    // minimum amount of wiggle allowed by finger before calling off a touch event
    int TRESHOLD = 40 * effectiveScale;
 
    // we've dragged out of the icon, invalidate the click by invoking onTouchUp early
    // check if we haven't drifted too far from the starting variable (treshold: 40)
    if (this->dragging && (abs(event->yPos - this->lastMouseY) >= TRESHOLD || abs(event->xPos - this->lastMouseX) >= TRESHOLD))
    {
        ret |= (this->elasticCounter > 0);
        auto prevElasticCounter = this->elasticCounter;
        this->elasticCounter = NO_HIGHLIGHT;
        if (prevElasticCounter != NO_HIGHLIGHT) {
            // change the cursor back to the arrow
            CST_SetCursor(CST_CURSOR_ARROW);
        }
    }
 
    return ret;
}

◆ onTouchUp()

bool Chesto::Element::onTouchUp ( InputEvents * event )

Definition at line 345 of file Element.cpp.

{
    if (!event->isTouchUp())
        return false;
 
    bool ret = false;
 
    float effectiveScale = getEffectiveScale();
    int scaledWidth = (int)(this->width * effectiveScale);
    int scaledHeight = (int)(this->height * effectiveScale);
 
    // ensure we were dragging first (originally checked the treshold above here, but now that actively invalidates it)
    if (this->dragging)
    {
        // check that this click is in the right coordinates for this square
        // and that a subscreen isn't already being shown
        // TODO: allow buttons to activae this too?
        if (event->touchIn(this->xAbs, this->yAbs, scaledWidth, scaledHeight))
        {
            // elasticCounter must be nonzero to allow a click through (highlight must be shown)
            if (this->elasticCounter > 0)
            {
                bool wasHighlighted = (this->elasticCounter > 0);
                
                this->dragging = false;
                this->elasticCounter = 0;
                
                // dear future reader: if you're getting a UAF here, try using RootDisplay::deferAction() to schedule your action to run outside of the event processing loop
                if (action != NULL) {
                    this->action();
                    return true;
                }
                if (actionWithEvents != NULL) {
                    this->actionWithEvents(event);
                    return true;
                }
                
                // If we get here, we had elasticCounter but no action
                ret |= wasHighlighted;
            }
        }
    }
 
    // release mouse
    this->dragging = false;
 
    // update if we were previously highlighted, cause we're about to remove it
    ret |= (this->elasticCounter > 0);
 
    this->elasticCounter = 0;
 
    return ret;
}

◆ position()

void Chesto::Element::position	(	int	x,
		int	y
	)

position the element

Definition at line 257 of file Element.cpp.

{
    this->x = x;
    this->y = y;
}

◆ process()

bool Chesto::Element::process ( InputEvents * event )

virtual

process any input that is received for this element

Reimplemented in Chesto::Button, Chesto::DropDown, Chesto::EKeyboard, Chesto::ListElement, Chesto::RootDisplay, Chesto::AlertDialog, Chesto::DropDownChoices, Chesto::Grid, and Chesto::NetImageElement.

Definition at line 29 of file Element.cpp.

{
    // whether or not we need to update the screen
    bool ret = false;
 
    // if we're hidden, don't process input
    if (hidden) return ret;
    
    if (parent) {
        this->recalcPosition(parent);
    }
 
    // if 3ds mock, ignore top screen inputs
#ifdef _3DS_MOCK
    if (event->touchIn(0, 0, 400, 240)) return ret;
#endif
 
    // do any touch down, drag, or up events
    if (touchable)
    {
        ret |= onTouchDown(event);
        ret |= onTouchDrag(event);
        ret |= onTouchUp(event);
        // if an action would modify or free elements before TouchUp fires, use RootDisplay::deferAction instead
    }
 
    // call process on subelements
    size_t elementCount = this->elements.size();
    for (size_t x = 0; x < elementCount; x++)
    {
        // ensure element still exists before trying to process it
        if (x < this->elements.size() && this->elements[x])
        {
            bool childHandled = this->elements[x]->process(event);
            ret |= childHandled;
 
            if (childHandled && this->elements.size() != elementCount) {
                // size changed while we were processing, break out
                break;
            }
        }
    }
 
    ret |= this->needsRedraw;
    this->needsRedraw = false;
 
    // if this variable is positive, decrease it, and force a redraw (acts like needsRedraw but over X redraws)
    if (futureRedrawCounter > 0) {
        futureRedrawCounter --;
        ret |= true;
    }
 
    if (RootDisplay::idleCursorPulsing) {
        // if we are using idle cursor pulsing, and this element's elastic counter is 0, force a redraw
        return ret | (this->elasticCounter > 0);
    }
 
    return ret;
}

References elasticCounter, elements, futureRedrawCounter, hidden, needsRedraw, parent, touchable, and Chesto::InputEvents::touchIn().

Referenced by Chesto::ListElement::process(), Chesto::RootDisplay::process(), Chesto::AlertDialog::process(), Chesto::Grid::process(), and Chesto::NetImageElement::process().

◆ recalcPosition()

void Chesto::Element::recalcPosition ( Element * parent )

Definition at line 177 of file Element.cpp.

                                            {
    // go through all constraints and apply them
    for (auto& constraint : constraints)
    {
        constraint->apply(this);
    }
 
    float effectiveScale = getEffectiveScale();
 
    // calculate any absolute x/y positions after constraints are applied
    if (parent && !isAbsolute)
    {
        if (constraints.empty()) {
            this->xAbs = parent->xAbs + (int)(this->x * effectiveScale);
            this->yAbs = parent->yAbs + (int)(this->y * effectiveScale);
        } else {
            this->xAbs = parent->xAbs + this->x;
            this->yAbs = parent->yAbs + this->y;
        }
    } else {
        // absolute positioning unaffected by scale or constraints
        this->xAbs = this->x;
        this->yAbs = this->y;
    }
 
    // go through all animations and apply them
    if (animations.size() > 0) {
        std::vector<size_t> toRemove;
        for (size_t i = 0; i < animations.size(); i++)
        {
            auto& animation = animations[i];
            // if there are any animations, we need to re-render
            needsRedraw = true;
 
            bool finished = animation->step();
            if (finished) {
                toRemove.push_back(i);
            }
        }
 
        for (auto it = toRemove.rbegin(); it != toRemove.rend(); ++it) {
            animations.erase(animations.begin() + *it);
        }
    }
}

◆ remove()

void Chesto::Element::remove ( Element * element )

Definition at line 453 of file Element.cpp.

{
    // single element remove
 
    auto position = std::find_if(elements.begin(), elements.end(),
        [element](const std::unique_ptr<Element, std::function<void(Element*)>>& e) { 
            return e.get() == element; 
        });
    if (position != elements.end())
        elements.erase(position);
}

◆ removeAll()

void Chesto::Element::removeAll ( )

Definition at line 465 of file Element.cpp.

{
    elements.clear();
    constraints.clear();
    animations.clear();
}

◆ render()

void Chesto::Element::render ( Element * parent )

virtual

display the current state of the display

Reimplemented in Chesto::Button, Chesto::EKeyboard, Chesto::ProgressBar, Chesto::RootDisplay, Chesto::Texture, Chesto::AlertDialog, Chesto::DropDownChoices, and Chesto::NetImageElement.

Definition at line 89 of file Element.cpp.

{   
    //if we're hidden, don't render
    if (hidden) return;
 
    // this needs to happen before any rendering
    this->recalcPosition(parent);
 
    // if we're in debug mode, draw an outline
    if (this->hasBackground) {
        // render the element background
        this->renderBackground(true);
    }
    else if (RootDisplay::isDebug) {
        backgroundColor = randomColor();
        this->renderBackground(false);
    }
 
    // go through every subelement and run render
    for (auto& subelement : elements)
    {
        subelement->render(this);
    }
 
    CST_Renderer* renderer = getRenderer();
 
    // if we're touchable, and we have some animation counter left, draw a rectangle+overlay
    if (this->touchable && this->elasticCounter > THICK_HIGHLIGHT)
    {
        float effectiveScale = getEffectiveScale();
        int scaledWidth = (int)(this->width * effectiveScale);
        int scaledHeight = (int)(this->height * effectiveScale);
        
        auto marginSpacing = cornerRadius > 0 ? 0 : 5;
        CST_Rect d = { this->xAbs - marginSpacing, this->yAbs - marginSpacing, scaledWidth + marginSpacing*2, scaledHeight + marginSpacing*2 };
        if (cornerRadius > 0) {
            // draw a rounded highlight instead
            CST_roundedBoxRGBA(renderer, d.x, d.y, d.x + d.w, d.y + d.h,
                cornerRadius, 0x10, 0xD9, 0xD9, 0x40);
        } else {
            CST_SetDrawBlend(renderer, true);
            CST_SetDrawColorRGBA(renderer, 0x10, 0xD9, 0xD9, 0x40);
            CST_FillRect(renderer, &d);
        }
    }
 
    if (this->touchable && this->elasticCounter > NO_HIGHLIGHT)
    {
        float effectiveScale = getEffectiveScale();
        int scaledWidth = (int)(this->width * effectiveScale);
        int scaledHeight = (int)(this->height * effectiveScale);
        
        auto marginSpacing = cornerRadius > 0 ? 0 : 5;
        CST_Rect d = { this->xAbs - marginSpacing, this->yAbs - marginSpacing, scaledWidth + marginSpacing*2, scaledHeight + marginSpacing*2 };
        if (this->elasticCounter == THICK_HIGHLIGHT)
        {
            int ticks = CST_GetTicks() / 100;
            int pulseState = ticks % 20;
            if (pulseState > 9) {
                pulseState = 19 - pulseState;
            }
 
            if (!RootDisplay::idleCursorPulsing) {
                // if we're not using idle cursor pulsing, just draw a simple rectangle
                pulseState = 0;
            }
 
            // make it a little thicker by drawing more rectangles TODO: better way to do this?
            auto decreaser = cornerRadius > 0 ? 0 : -2;
            for (int x = decreaser; x <= 3; x++)
            {
                // draw a rectangle with varying brightness depending on the pulse state
                int r = 0x10; //- 0x01 * pulseState;
                int g = 0xD9 - 0x01 * pulseState;
                int b = 0xD9 - 0x01 * pulseState;
                int edgeMod = x==1 ? 0 : abs(x); // slight bias towards the inner
                int a = fmax(0x0, 0xFF - 0x10 * pulseState * edgeMod);
                CST_roundedRectangleRGBA(renderer, d.x + x, d.y + x, d.x + d.w - x, d.y + d.h - x, cornerRadius, r, g, b, a);
            }
        } else {
            // simple rectangle, not pulsing
            CST_roundedRectangleRGBA(renderer, d.x, d.y, d.x + d.w, d.y + d.h, cornerRadius, 0x10, 0xD9, 0xD9, 0xFF);
            // and one inner rectangle too
            CST_roundedRectangleRGBA(renderer, d.x + 1, d.y + 1, d.x + d.w - 1, d.y + d.h - 1, cornerRadius, 0x10, 0xD9, 0xD9, 0xFF);
        }
    }
}

References elasticCounter, elements, hidden, parent, touchable, and width.

Referenced by Chesto::RootDisplay::render(), Chesto::Texture::render(), Chesto::AlertDialog::render(), Chesto::NetImageElement::render(), and screenshot().

◆ renderBackground()

void Chesto::Element::renderBackground ( bool fill = true )

Definition at line 239 of file Element.cpp.

                                        {
    CST_Renderer* renderer = getRenderer();
    CST_Rect bounds = getBounds();
    auto r = backgroundColor.r * 0xFF;
    auto g = backgroundColor.g * 0xFF;
    auto b = backgroundColor.b * 0xFF;
    
    if (cornerRadius > 0) {
        const auto renderRect = fill ? CST_roundedBoxRGBA : CST_roundedRectangleRGBA;
        renderRect(renderer, bounds.x, bounds.y, bounds.x + bounds.w, bounds.y + bounds.h,
            cornerRadius, backgroundColor.r * 0xFF, backgroundColor.g * 0xFF, backgroundColor.b * 0xFF, backgroundOpacity);
    } else {
        CST_SetDrawColorRGBA(renderer, r, g, b, backgroundOpacity);
        const auto renderRect = fill ? CST_FillRect : CST_DrawRect;
        renderRect(renderer, &bounds);
    }
}

◆ screenshot()

void Chesto::Element::screenshot ( std::string path )

Take a screenshot of this element and its children, and save it to the given path.

Definition at line 544 of file Element.cpp.

                                       {
    // render the webview to a target that can be saved (TARGET ACCESS)
    CST_Texture* target = SDL_CreateTexture(getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, width, height);
 
    // set the target texture
    SDL_SetRenderTarget(getRenderer(), target);
 
    // draw a white background first
    SDL_SetRenderDrawColor(getRenderer(), 255, 255, 255, 255);
    SDL_RenderClear(getRenderer());
 
    // render the texture
    render(parent);
 
    // reset the target texture
    SDL_SetRenderTarget(getRenderer(), NULL);
 
    // save the surface to the path
    CST_SavePNG(target, path.c_str());
}

References parent, render(), and width.

◆ setAbsolute()

Element * Chesto::Element::setAbsolute ( bool isAbs )

Definition at line 484 of file Element.cpp.

{
    isAbsolute = isAbs;
    return this;
}

◆ setAction()

Element * Chesto::Element::setAction ( std::function< void()> func )

Definition at line 478 of file Element.cpp.

{
    this->action = func;
    return this;
}

◆ setPosition()

Element * Chesto::Element::setPosition	(	int	x,
		int	y
	)

Definition at line 472 of file Element.cpp.

{
    this->position(x, y);
    return this;
}

◆ setTouchable()

Element * Chesto::Element::setTouchable ( bool touchable )

Definition at line 538 of file Element.cpp.

{
    this->touchable = touchable;
    return this;
}

◆ unhide()

void Chesto::Element::unhide ( )

inline

Definition at line 48 of file Element.hpp.

48{ this->hidden = false; }

Member Data Documentation

◆ action

std::function<void()> Chesto::Element::action = NULL

the action to call (from binded callback) on touch or button selection https://stackoverflow.com/questions/14189440/c-class-member-callback-simple-examples

Definition at line 55 of file Element.hpp.

◆ actionWithEvents

std::function<void(InputEvents* event)> Chesto::Element::actionWithEvents = NULL

Definition at line 56 of file Element.hpp.

◆ angle

double Chesto::Element::angle = 0

rotation angle in degrees

Definition at line 144 of file Element.hpp.

Referenced by Chesto::Texture::render().

◆ animations

std::vector<std::unique_ptr<Animation> > Chesto::Element::animations

Definition at line 176 of file Element.hpp.

◆ backgroundColor

rgb Chesto::Element::backgroundColor = {0, 0, 0}

Definition at line 107 of file Element.hpp.

◆ backgroundOpacity

int Chesto::Element::backgroundOpacity = 0xff

Definition at line 110 of file Element.hpp.

◆ constraints

std::vector<std::unique_ptr<Constraint> > Chesto::Element::constraints

Definition at line 171 of file Element.hpp.

◆ cornerRadius

int Chesto::Element::cornerRadius = 0

Definition at line 147 of file Element.hpp.

◆ dragging

bool Chesto::Element::dragging = false

whether or not this element is currently being dragged

Definition at line 92 of file Element.hpp.

◆ elasticCounter

int Chesto::Element::elasticCounter = 0

how much time is left in an elastic-type flick/scroll set by the last distance traveled in a scroll, and counts down every frame

Definition at line 129 of file Element.hpp.

Referenced by process(), and render().

◆ elements

std::vector<std::unique_ptr<Element, std::function<void(Element*)> > > Chesto::Element::elements

visible GUI child elements of this element

Definition at line 59 of file Element.hpp.

Referenced by process(), Chesto::DropDownChoices::process(), Chesto::Grid::process(), Chesto::Grid::refresh(), and render().

◆ futureRedrawCounter

int Chesto::Element::futureRedrawCounter = 0

whether this element needs a redraw for the next X redraws (decreases each time) (0 is no redraws)

Definition at line 98 of file Element.hpp.

Referenced by process().

◆ hasBackground

bool Chesto::Element::hasBackground = false

Definition at line 104 of file Element.hpp.

◆ height

int Chesto::Element::height = 0

Definition at line 132 of file Element.hpp.

◆ hidden

bool Chesto::Element::hidden = false

whether this element should skip rendering or not

Definition at line 119 of file Element.hpp.

Referenced by Chesto::AlertDialog::AlertDialog(), process(), Chesto::ListElement::process(), render(), Chesto::ProgressBar::render(), Chesto::Texture::render(), and Chesto::NetImageElement::render().

◆ isAbsolute

bool Chesto::Element::isAbsolute = false

Definition at line 113 of file Element.hpp.

◆ isProtected

bool Chesto::Element::isProtected = false

Definition at line 125 of file Element.hpp.

◆ lastMouseX

int Chesto::Element::lastMouseX = 0

Definition at line 101 of file Element.hpp.

◆ lastMouseY

int Chesto::Element::lastMouseY = 0

the last Y, X coordinate of the mouse (from a drag probably)

Definition at line 101 of file Element.hpp.

◆ maskColor

CST_Color Chesto::Element::maskColor = {0,0,0,0}

The color to overlay on top.

Definition at line 193 of file Element.hpp.

Referenced by Chesto::Texture::render().

◆ needsRedraw

bool Chesto::Element::needsRedraw = false

whether or not this element needs the screen redrawn next time it's processed

Definition at line 95 of file Element.hpp.

Referenced by process().

◆ parent

Element* Chesto::Element::parent = nullptr

the parent element (reference only, not owned)

Definition at line 116 of file Element.hpp.

Referenced by process(), render(), Chesto::ProgressBar::render(), Chesto::RootDisplay::render(), Chesto::Texture::render(), Chesto::NetImageElement::render(), and screenshot().

◆ scale

float Chesto::Element::scale = 1.0f

Definition at line 86 of file Element.hpp.

◆ tag

int Chesto::Element::tag = 0

Definition at line 150 of file Element.hpp.

◆ touchable

bool Chesto::Element::touchable = false

whether or not this element can be touched (highlights bounds)

Definition at line 89 of file Element.hpp.

Referenced by process(), and render().

◆ useColorMask

bool Chesto::Element::useColorMask = false

whether or not to overlay a color mask on top of this element

Definition at line 190 of file Element.hpp.

Referenced by Chesto::Texture::render().

◆ width

int Chesto::Element::width = 0

width and height of this element (must be manually set, isn't usually calculated (but is in some cases, like text or images))

Definition at line 132 of file Element.hpp.

Referenced by Chesto::AlertDialog::AlertDialog(), Chesto::Texture::loadPath(), Chesto::NetImageElement::NetImageElement(), Chesto::NetImageElement::process(), Chesto::Screen::rebuildUI(), render(), Chesto::ProgressBar::render(), Chesto::Texture::render(), Chesto::NetImageElement::render(), Chesto::Texture::resize(), screenshot(), and Chesto::TextElement::update().

◆ x

int Chesto::Element::x = 0

Definition at line 137 of file Element.hpp.

◆ xAbs

int Chesto::Element::xAbs = 0

Definition at line 141 of file Element.hpp.

◆ y

int Chesto::Element::y = 0

Definition at line 137 of file Element.hpp.

◆ yAbs

int Chesto::Element::yAbs = 0

Definition at line 141 of file Element.hpp.

The documentation for this class was generated from the following files:

src/Element.hpp
src/Element.cpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ super

Constructor & Destructor Documentation

◆ Element()

◆ ~Element()

Member Function Documentation

◆ addNode()

◆ addStackMember()

◆ animate()

◆ constrain()

◆ constrainToTarget()

◆ createNode()

◆ getBounds()

◆ getEffectiveScale()

◆ getRenderer()

◆ hide()

◆ moveToFront()

◆ onTouchDown()

◆ onTouchDrag()

◆ onTouchUp()

◆ position()

◆ process()

◆ recalcPosition()

◆ remove()

◆ removeAll()

◆ render()

◆ renderBackground()

◆ screenshot()

◆ setAbsolute()

◆ setAction()

◆ setPosition()

◆ setTouchable()

◆ unhide()

Member Data Documentation

◆ action

◆ actionWithEvents

◆ angle

◆ animations

◆ backgroundColor

◆ backgroundOpacity

◆ constraints

◆ cornerRadius

◆ dragging

◆ elasticCounter

◆ elements

◆ futureRedrawCounter

◆ hasBackground

◆ height

◆ hidden

◆ isAbsolute

◆ isProtected

◆ lastMouseX

◆ lastMouseY

◆ maskColor

◆ needsRedraw

◆ parent

◆ scale

◆ tag

◆ touchable

◆ useColorMask

◆ width

◆ x

◆ xAbs

◆ y

◆ yAbs