Chesto::DropDownChoices Class Reference

Inheritance diagram for Chesto::DropDownChoices:

Collaboration diagram for Chesto::DropDownChoices:

Public Member Functions
	DropDownChoices (std::vector< std::pair< std::string, std::string > > choices, std::function< void(std::string)> onSelect, bool isDarkMode, std::string header="")
bool	process (InputEvents *event) override
	process any input that is received for this element More...
void	render (Element *parent) override
	display the current state of the display More...
void	rebuildUI () override
virtual void	rebuildUI ()=0
Public Member Functions inherited from Chesto::Element
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
int	curHighlighted = -1
Container *	container = nullptr
ListElement *	scrollList = nullptr
Public Attributes inherited from Chesto::Element
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...

Additional Inherited Members
Public Types inherited from Chesto::Element
typedef Element	super
Protected Member Functions inherited from Chesto::Screen
int	getScreenWidth () const
int	getScreenHeight () const
Protected Member Functions inherited from Chesto::Element
void	addStackMember (Element *element)

Detailed Description

Definition at line 43 of file DropDown.hpp.

Constructor & Destructor Documentation

DropDownChoices()

Chesto::DropDownChoices::DropDownChoices	(	std::vector< std::pair< std::string, std::string > >	choices,
		std::function< void(std::string)>	onSelect,
		bool	isDarkMode,
		std::string	header = ""
	)

Definition at line 45 of file DropDown.cpp.

  : choices(choices),
    onSelectCallback(onSelect),
    isDarkMode(isDarkMode),
    header(header)
{
    rebuildUI();
    
    int widestWidth = 0;
    for (const auto& choice : this->choices) {
        std::string displayText = choice.second.empty() ? "(empty)" : choice.second;
        
        auto choiceElement = std::make_unique<Button>(displayText, 0, isDarkMode, 20, 0);
        widestWidth = std::max(widestWidth, choiceElement->width);
        
        choiceElement->setAction([
            this, // Capture this to access onSelectCallback member
            choiceKey = choice.first
        ]() {
            // local copy is needed here to avoid it being destroyed after popScreen
            std::string choiceKeyCopy = choiceKey;
            
            // same as above?
            auto callbackCopy = this->onSelectCallback;
            
            // pop the dropdown screen (deletes 'this'!)
            RootDisplay::popScreen();
            
            // use local copies now
            if (callbackCopy) {
                callbackCopy(choiceKeyCopy);
            }
        });
        container->add(std::move(choiceElement));
    }
 
    // make each choice the same width (widest)
    for (const auto& child : container->elements) {
        if (auto buttonChild = dynamic_cast<Button*>(child.get())) {
            buttonChild->fixedWidth = widestWidth;
            buttonChild->updateBounds();
        }
    }
}

Member Function Documentation

process()

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

overridevirtual

process any input that is received for this element

Reimplemented from Chesto::Element.

Definition at line 156 of file DropDown.cpp.

                                                {
    // if we have an up or down button event, instead of scrolling the list element, move cursor selection within the container
    if (event->held(A_BUTTON) && this->curHighlighted >= 0 && this->curHighlighted < (int)container->elements.size()) {
        this->container->elements[this->curHighlighted]->action(); // fire that button's action
        return true;
    }
 
    if (event->held(B_BUTTON)) {
        // dismiss without a selection - pop this screen
        RootDisplay::popScreen();
        return true;
    }
 
    if (event->isTouch()) {
        // unhighlight whatever may be highlighted
        this->curHighlighted = -1;
    } else {
        if (event->isKeyDown() && event->held(UP_BUTTON | DOWN_BUTTON | LEFT_BUTTON | RIGHT_BUTTON)) {
            // Similar to HBAS's AppList navigation logic
            
            // look up whatever is currently chosen as the highlighted position
            // and remove its highlight
            if (curHighlighted >= 0 && curHighlighted < (int)container->elements.size() && container->elements[curHighlighted])
                container->elements[curHighlighted]->elasticCounter = NO_HIGHLIGHT;
 
            // adjust it by R for up and down
            this->curHighlighted += -1 * (event->held(UP_BUTTON)) + (event->held(DOWN_BUTTON));
 
            // don't let the cursor go out of bounds
            if (curHighlighted >= (int)container->elements.size()) curHighlighted = container->elements.size() - 1;
            if (curHighlighted < 0) curHighlighted = 0;
 
            // highlight the new element
            if (curHighlighted < (int)container->elements.size() && container->elements[curHighlighted])
                container->elements[curHighlighted]->elasticCounter = THICK_HIGHLIGHT;
 
            // Auto-scroll to keep highlighted element on screen (similar to AppList logic)
            if (curHighlighted >= 0 && curHighlighted < (int)container->elements.size() && container->elements[curHighlighted] && scrollList) {
                Element* curElement = container->elements[curHighlighted].get();
                
                // Calculate the y-position of the currently highlighted element on screen (accounting for scroll)
                // scrollList->y is the scroll offset, container->y is the initial position, curElement->y is relative to container
                int normalizedY = container->y + curElement->y + scrollList->y;
                
                // If element is going off the top of the screen, scroll down to keep it visible
                if (normalizedY < 50) {
                    event->wheelScroll = 1;
                }
                // If element is going off the bottom of the screen, scroll up to keep it visible
                else if (normalizedY + curElement->height > SCREEN_HEIGHT - 50) {
                    event->wheelScroll = -1;
                }
            }
 
            return true;
        }
    }
 
    return Screen::process(event);
}

References Chesto::Element::elements, and Chesto::InputEvents::held().

rebuildUI()

void Chesto::DropDownChoices::rebuildUI ( )

overridevirtual

Rebuild the entire UI for this screen. Called on initialization and whenever the screen needs to be reconstructed (e.g., theme changes, language changes).

Implementations should:

1. Call removeAll() to clear existing UI
2. Create all UI elements with std::make_unique
3. Configure elements (position, actions, etc.)
4. Transfer ownership via append(std::move(...))

Implements Chesto::Screen.

Definition at line 94 of file DropDown.cpp.

                                {
    removeAll();
    
    // Create a full-screen scrollable list to hold everything
    // TODO: a common way for Screen's to have all their content be scrollable without making a new element each time
    auto scrollContainer = std::make_unique<ListElement>();
    scrollContainer->width = SCREEN_WIDTH;
    scrollContainer->height = SCREEN_HEIGHT;
    scrollList = scrollContainer.get(); // Keep pointer for scrolling
    
    // overlay and shade bg color
    // also TODO: a common way to have the dim background exist and fade in
    auto overlay = createNode<Element>();
    overlay->width = SCREEN_WIDTH;
    overlay->height = SCREEN_HEIGHT;
    overlay->backgroundColor = fromRGB(0, 0, 0);
    overlay->backgroundOpacity = 0x70;
    overlay->cornerRadius = 1; // needed to force transparency
    overlay->hasBackground = true;
    
    // header text if specified
    if (!header.empty()) {
        auto headerText = std::make_unique<TextElement>(header.c_str(), 28);
        headerText->constrain(ALIGN_CENTER_HORIZONTAL);
        headerText->position(0, SCREEN_HEIGHT / 5 - 60);
        scrollContainer->addNode(std::move(headerText));
    }
    
    // vertical container for the choices
    auto containerPtr = std::make_unique<Container>(COL_LAYOUT, 20);
    container = containerPtr.get();
    
    // TODO: Chesto doesn't know about light/dark themes, these are hardcoded to match HBAS themes
    if (isDarkMode) {
        container->backgroundColor = fromRGB(0x2d, 0x2c, 0x31); // match theme dark background
    } else {
        container->backgroundColor = fromRGB(0xf5, 0xf5, 0xf5); // light gray for light mode
    }
    container->hasBackground = true;
 
    // center the container horizontally within our full screen overlay
    container->constrain(ALIGN_CENTER_HORIZONTAL);
    // position the start of the dropdown in the upper fifth of the screen
    container->y = SCREEN_HEIGHT / 5;
    
    scrollContainer->addNode(std::move(containerPtr));
 
    // not a part of the scrollable area
    auto backBtn = createNode<Button>(i18n("dropdown.back"), B_BUTTON, isDarkMode, 15);
    backBtn->constrain(ALIGN_BOTTOM | ALIGN_LEFT, 10);
    backBtn->setAction([]() {
        // hides the dropdown without any callback
        RootDisplay::popScreen();
    });
 
    addNode(std::move(scrollContainer));
}

render()

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

overridevirtual

display the current state of the display

Reimplemented from Chesto::Element.

Definition at line 152 of file DropDown.cpp.

                                            {
    super::render(parent);
}

Member Data Documentation

container

Container* Chesto::DropDownChoices::container = nullptr

Definition at line 57 of file DropDown.hpp.

curHighlighted

int Chesto::DropDownChoices::curHighlighted = -1

Definition at line 56 of file DropDown.hpp.

scrollList

ListElement* Chesto::DropDownChoices::scrollList = nullptr

Definition at line 58 of file DropDown.hpp.

---

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

• src/DropDown.hpp
• src/DropDown.cpp