Inheritance diagram for Element:

Collaboration diagram for 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	append (Element *element)

void	remove (Element *element)

void	removeAll (bool moveToTrash=false)

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

void	recalcPosition (Element *parent)

CST_Rect	getBounds ()

CST_Renderer *	getRenderer ()

void	wipeAll (bool delSelf=false)

Element *	child (Element *child)

Element *	setPosition (int x, int y)

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

Element *	centerHorizontallyIn (Element *parent)

Element *	centerVerticallyIn (Element *parent)

Element *	centerIn (Element *parent)

Element *	setAbsolute (bool isAbs)

Element *	constrain (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< 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}

bool	isAbsolute = false

Element *	parent = NULL
	the parent element (can sometimes be null if it isn't set) 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	xOff = 0

int	yOff = 0

int	cornerRadius = 0

std::vector< Constraint * >	constraints

std::vector< 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...

Detailed Description

Definition at line 33 of file Element.hpp.

Member Typedef Documentation

◆ super

typedef Element Element::super

Definition at line 122 of file Element.hpp.

Constructor & Destructor Documentation

◆ Element()

Element::Element ( )

Definition at line 12 of file Element.cpp.

{
    needsRedraw = true;
}

◆ ~Element()

Element::~Element ( )

virtual

Definition at line 7 of file Element.cpp.

{
    removeAll();
}

Member Function Documentation

◆ animate()

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

Definition at line 422 of file Element.cpp.

  {
    animations.push_back(new Animation(
        CST_GetTicks(), duration, onStep, onFinish)
    );
 
    return this;
}

◆ append()

void Element::append ( Element * element )

Definition at line 328 of file Element.cpp.

{
    auto position = std::find(elements.begin(), elements.end(), element);
    if (position == elements.end()) {
        elements.push_back(element);
    }
}

◆ centerHorizontallyIn()

Element * Element::centerHorizontallyIn ( Element * parent )

Definition at line 389 of file Element.cpp.

{
    this->x = parent->width / 2 - this->width / 2;
    return this;
}

◆ centerIn()

Element * Element::centerIn ( Element * parent )

Definition at line 401 of file Element.cpp.

{
    return centerHorizontallyIn(parent)->centerVerticallyIn(parent);
}

◆ centerVerticallyIn()

Element * Element::centerVerticallyIn ( Element * parent )

Definition at line 395 of file Element.cpp.

{
    this->y = parent->height / 2 - this->height / 2;
    return this;
}

◆ child()

Element * Element::child ( Element * child )

Definition at line 369 of file Element.cpp.

{
    this->elements.push_back(child);
    child->parent = this;
    child->recalcPosition(this);
    return this;
}

◆ constrain()

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

Definition at line 416 of file Element.cpp.

{
    constraints.push_back(new Constraint(flags, padding));
    return this;
}

◆ getBounds()

CST_Rect Element::getBounds ( )

Definition at line 178 of file Element.cpp.

{
    return {
        .x = this->xAbs,
        .y = this->yAbs,
        .w = this->width,
        .h = this->height,
    };
}

◆ getRenderer()

CST_Renderer * Element::getRenderer ( )

Definition at line 412 of file Element.cpp.

                                   {
    return RootDisplay::renderer;
}

◆ hide()

void Element::hide ( )

inline

Definition at line 51 of file Element.hpp.

51{ this->hidden = true; }

Element::hidden

bool hidden

whether this element should skip rendering or not

Definition: Element.hpp:107

◆ moveToFront()

Element * Element::moveToFront ( )

Definition at line 435 of file Element.cpp.

                              {
    if (parent != NULL) {
        parent->remove(this);
        parent->child(this);
    }
    return this;
}

◆ onTouchDown()

bool Element::onTouchDown ( InputEvents * event )

Definition at line 212 of file Element.cpp.

{
    if (!event->isTouchDown())
        return false;
 
    if (!event->touchIn(this->xAbs, this->yAbs, this->width, this->height))
        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 Element::onTouchDrag ( InputEvents * event )

Definition at line 232 of file Element.cpp.

{
    bool ret = false;
 
    if (!event->isTouchDrag())
        return false;
 
    // 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, this->width, this->height)) {
            // 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 / SCALER / SCALER;
 
    // 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 Element::onTouchUp ( InputEvents * event )

Definition at line 286 of file Element.cpp.

{
    if (!event->isTouchUp())
        return false;
 
    bool ret = false;
 
    // 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, this->width, this->height))
        {
            // elasticCounter must be nonzero to allow a click through (highlight must be shown)
            if (this->elasticCounter > 0)
            {
                // invoke this element's action
                if (action != NULL) {
                    this->action();
                    ret |= true;
                }
                if (actionWithEvents != NULL) {
                    this->actionWithEvents(event);
                    ret |= true;
                }
            }
        }
    }
 
    // 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 Element::position	(	int	x,
		int	y
	)

position the element

Definition at line 206 of file Element.cpp.

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

◆ process()

bool Element::process ( InputEvents * event )

virtual

process any input that is received for this element

Reimplemented in Button, EKeyboard, ListElement, and RootDisplay.

Definition at line 17 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 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);
    }
 
    // call process on subelements
    for (int x = 0; x < this->elements.size(); x++)
        if (this->elements.size() > x && this->elements[x])
            ret |= this->elements[x]->process(event);
 
    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, touchable, and InputEvents::touchIn().

Referenced by Button::process(), ListElement::process(), and RootDisplay::process().

◆ recalcPosition()

void Element::recalcPosition ( Element * parent )

Definition at line 140 of file Element.cpp.

                                            {
    // calculate absolute x/y positions
    if (parent && !isAbsolute)
    {
        this->xAbs = parent->xAbs + this->x;
        this->yAbs = parent->yAbs + this->y;
    } else {
        this->xAbs = this->x;
        this->yAbs = this->y;
    }
 
    // go through all constraints and apply them
    for (Constraint* constraint : constraints)
    {
        constraint->apply(this);
    }
 
    // go through all animations and apply them
    // TODO: animations can modify the actual positions, which can mess up constraints
    if (animations.size() > 0) {
        std::vector<Animation*> toRemove;
        for (Animation* animation : animations)
        {
            // if there are any animations, we need to re-render
            needsRedraw = true;
 
            bool finished = animation->step();
            if (finished) {
                toRemove.push_back(animation);
            }
        }
        for (Animation* animation : toRemove) {
            animations.erase(std::remove(animations.begin(), animations.end(), animation), animations.end());
            delete animation;
        }
    }
}

◆ remove()

void Element::remove ( Element * element )

Definition at line 336 of file Element.cpp.

{
    auto position = std::find(elements.begin(), elements.end(), element);
    if (position != elements.end())
        elements.erase(position);
}

◆ removeAll()

void Element::removeAll ( bool moveToTrash = false )

Definition at line 356 of file Element.cpp.

{
    if (moveToTrash) {
        // store in a list for free-ing up memory later
        for (auto e : elements) {
            RootDisplay::mainDisplay->trash.push_back(e);
        }
    }
    elements.clear();
    constraints.clear(); // remove all constraints too
    animations.clear();
}

◆ render()

void Element::render ( Element * parent )

virtual

display the current state of the display

Reimplemented in Button, EKeyboard, NetImageElement, ProgressBar, RootDisplay, and Texture.

Definition at line 60 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 (Element* 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)
    {
        auto marginSpacing = cornerRadius > 0 ? 0 : 5;
        CST_Rect d = { this->xAbs - marginSpacing, this->yAbs - marginSpacing, this->width + marginSpacing*2, this->height + 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)
    {
        auto marginSpacing = cornerRadius > 0 ? 0 : 5;
        CST_Rect d = { this->xAbs - marginSpacing, this->yAbs - marginSpacing, this->width + marginSpacing*2, this->height + 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 Button::render(), EKeyboard::render(), RootDisplay::render(), Texture::render(), and screenshot().

◆ renderBackground()

void Element::renderBackground ( bool fill = true )

Definition at line 188 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, 0xFF);
    } else {
        CST_SetDrawColorRGBA(renderer, r, g, b, 0xFF);
        const auto renderRect = fill ? CST_FillRect : CST_DrawRect;
        renderRect(renderer, &bounds);
    }
}

◆ screenshot()

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

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

Definition at line 449 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 * Element::setAbsolute ( bool isAbs )

Definition at line 406 of file Element.cpp.

{
    isAbsolute = isAbs;
    return this;
}

◆ setAction()

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

Definition at line 383 of file Element.cpp.

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

◆ setPosition()

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

Definition at line 377 of file Element.cpp.

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

◆ setTouchable()

Element * Element::setTouchable ( bool touchable )

Definition at line 443 of file Element.cpp.

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

◆ unhide()

void Element::unhide ( )

inline

Definition at line 53 of file Element.hpp.

53{ this->hidden = false; }

◆ wipeAll()

void Element::wipeAll ( bool delSelf = false )

Definition at line 343 of file Element.cpp.

{
    // delete's this element's children, then itself
    for (auto child : elements) {
        child->wipeAll(true);
    }
    elements.clear();
 
    if (delSelf && !isProtected) {
        delete this;
    }
}

Member Data Documentation

◆ action

std::function<void()> 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 60 of file Element.hpp.

Referenced by Button::process().

◆ actionWithEvents

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

Definition at line 61 of file Element.hpp.

◆ angle

double Element::angle = 0

rotation angle in degrees

Definition at line 130 of file Element.hpp.

Referenced by Texture::render().

◆ animations

std::vector<Animation*> Element::animations

Definition at line 163 of file Element.hpp.

◆ backgroundColor

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

Definition at line 98 of file Element.hpp.

◆ constraints

std::vector<Constraint*> Element::constraints

Definition at line 159 of file Element.hpp.

◆ cornerRadius

int Element::cornerRadius = 0

Definition at line 136 of file Element.hpp.

◆ dragging

bool Element::dragging = false

whether or not this element is currently being dragged

Definition at line 83 of file Element.hpp.

◆ elasticCounter

int 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 117 of file Element.hpp.

Referenced by process(), and render().

◆ elements

std::vector<Element*> Element::elements

visible GUI child elements of this element

Definition at line 64 of file Element.hpp.

Referenced by process(), and render().

◆ futureRedrawCounter

int Element::futureRedrawCounter = 0

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

Definition at line 89 of file Element.hpp.

Referenced by process().

◆ hasBackground

bool Element::hasBackground = false

Definition at line 95 of file Element.hpp.

◆ height

int Element::height = 0

Definition at line 120 of file Element.hpp.

◆ hidden

bool Element::hidden = false

whether this element should skip rendering or not

Definition at line 107 of file Element.hpp.

Referenced by EKeyboard::process(), process(), ListElement::process(), Button::render(), EKeyboard::render(), render(), NetImageElement::render(), ProgressBar::render(), and Texture::render().

◆ isAbsolute

bool Element::isAbsolute = false

Definition at line 101 of file Element.hpp.

◆ isProtected

bool Element::isProtected = false

Definition at line 113 of file Element.hpp.

◆ lastMouseX

int Element::lastMouseX = 0

Definition at line 92 of file Element.hpp.

◆ lastMouseY

int Element::lastMouseY = 0

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

Definition at line 92 of file Element.hpp.

◆ maskColor

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

The color to overlay on top.

Definition at line 180 of file Element.hpp.

Referenced by Texture::render().

◆ needsRedraw

bool Element::needsRedraw = false

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

Definition at line 86 of file Element.hpp.

Referenced by process(), and InputEvents::processSDLEvents().

◆ parent

Element* Element::parent = NULL

the parent element (can sometimes be null if it isn't set)

Definition at line 104 of file Element.hpp.

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

◆ scale

float Element::scale = 1.0f

Definition at line 77 of file Element.hpp.

◆ touchable

bool Element::touchable = false

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

Definition at line 80 of file Element.hpp.

Referenced by process(), and render().

◆ useColorMask

bool Element::useColorMask = false

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

Definition at line 177 of file Element.hpp.

Referenced by Texture::render().

◆ width

int 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 120 of file Element.hpp.

Referenced by Texture::loadPath(), NetImageElement::NetImageElement(), EKeyboard::process(), Button::render(), EKeyboard::render(), render(), NetImageElement::render(), Texture::render(), Texture::resize(), screenshot(), and TextElement::update().

◆ x

int Element::x = 0

Definition at line 125 of file Element.hpp.

◆ xAbs

int Element::xAbs = 0

Definition at line 128 of file Element.hpp.

◆ xOff

int Element::xOff = 0

Definition at line 133 of file Element.hpp.

◆ y

int Element::y = 0

Definition at line 125 of file Element.hpp.

◆ yAbs

int Element::yAbs = 0

Definition at line 128 of file Element.hpp.

◆ yOff

int Element::yOff = 0

Definition at line 133 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

Detailed Description

Member Typedef Documentation

◆ super

Constructor & Destructor Documentation

◆ Element()

◆ ~Element()

Member Function Documentation

◆ animate()

◆ append()

◆ centerHorizontallyIn()

◆ centerIn()

◆ centerVerticallyIn()

◆ child()

◆ constrain()

◆ getBounds()

◆ getRenderer()

◆ hide()

◆ moveToFront()

◆ onTouchDown()

◆ onTouchDrag()

◆ onTouchUp()

◆ position()

◆ process()

◆ recalcPosition()

◆ remove()

◆ removeAll()

◆ render()

◆ renderBackground()

◆ screenshot()

◆ setAbsolute()

◆ setAction()

◆ setPosition()

◆ setTouchable()

◆ unhide()

◆ wipeAll()

Member Data Documentation

◆ action

◆ actionWithEvents

◆ angle

◆ animations

◆ backgroundColor

◆ constraints

◆ cornerRadius

◆ dragging

◆ elasticCounter

◆ elements

◆ futureRedrawCounter

◆ hasBackground

◆ height

◆ hidden

◆ isAbsolute

◆ isProtected

◆ lastMouseX

◆ lastMouseY

◆ maskColor

◆ needsRedraw

◆ parent

◆ scale

◆ touchable

◆ useColorMask

◆ width

◆ x

◆ xAbs

◆ xOff

◆ y

◆ yAbs

◆ yOff