Modal

#include <Modal.hpp>

Inherits: Widget

A full-screen dimmed overlay with a centered content box.

Modal renders a semi-transparent backdrop and centers its content widget on screen. Press Escape to dismiss unless dismissable = false.

Public Methods

Return	Name	Description
	`Modal` `explicit`
`core::Size`	`measure` `virtual`	Measures how much space this widget needs.
`void`	`layout` `virtual`	Positions and sizes this widget and its children.
`bool`	`onEvent` `virtual`	Handles an input event.
`bool`	`isFocusable` `virtual` `const` `inline`	Returns whether this widget can receive keyboard focus.
`void`	`handleResize`
`std::vector< std::shared_ptr< Widget > >`	`getChildren` `virtual` `const` `inline`	Returns this widget’s children.

explicit

explicit Modal(std::shared_ptr< Widget > content, std::function< void()> onClose, bool dismissable)

measure

virtual

virtual core::Size measure(int availW, int availH)

Measures how much space this widget needs.

Called during the measurement pass to determine widget size requirements. Should return the preferred size based on available space.

Parameters

availW Maximum available width (may be ignored by widget)
availH Maximum available height (may be ignored by widget)

Returns

The Size this widget wants, or needs at minimum

layout

virtual

virtual void layout(int x, int y, int width, int height)

Positions and sizes this widget and its children.

Called after measurement to actually place the widget at a specific location. If your widget has children, you must call their layout() methods here.

Parameters

x The X coordinate for this widget
y The Y coordinate for this widget
width The width allocated to this widget
height The height allocated to this widget

onEvent

virtual

virtual bool onEvent(const core::events::Event & event)

Handles an input event.

Called by the framework to deliver an event to this widget. The default implementation runs any listeners registered via addEventListener(), then returns false. Subclasses (Button, Input, etc.) override this to add built-in behavior, and should call Widget::onEvent(event) first to give user listeners a chance to handle the event before the widget’s own logic.

Return true if the event was handled, false to let it bubble to the parent widget.

Parameters

event The input event

Returns

True if this widget (or one of its listeners) handled the event

isFocusable

virtual const inline

virtual inline bool isFocusable() const

Returns whether this widget can receive keyboard focus.

Widgets like Button and Input return true; containers return false.

Returns

True if this widget can be focused, false otherwise

handleResize

void handleResize(int termWidth, int termHeight)

getChildren

virtual const inline

virtual inline std::vector< std::shared_ptr< Widget > > getChildren() const

Returns this widget’s children.

Returns

Vector of child widgets (empty if no children)

Protected Methods

Return	Name	Description
`void`	`drawContent` `virtual`	Draws this widget’s content.

drawContent

virtual

virtual void drawContent(backend::Buffer & buf, core::Rect inner)

Draws this widget’s content.

Called by render() after background and borders are drawn. This is where you should draw your widget’s actual content. The inner rectangle accounts for borders and padding.

Parameters

buf The buffer to draw to
inner The inner rectangle (excluding border/padding)

Private Attributes

Return	Name	Description
`std::shared_ptr< core::Widget >`	`content`
`std::function< void()>`	`onClose`
`bool`	`dismissable`
`float`	`contentW`
`float`	`contentH`

content

std::shared_ptr< core::Widget > content

onClose

std::function< void()> onClose

dismissable

bool dismissable

contentW

float contentW = 0.5f

contentH

float contentH = 0.4f