input_box.cpp

Go to the documentation of this file.

#include "./asw/modules/ui/input_box.h"
 
#include <SDL3/SDL.h>
#include <algorithm>
 
#include "./asw/modules/display.h"
#include "./asw/modules/draw.h"
#include "./asw/modules/util.h"
 
namespace {
// UTF-8 continuation bytes look like 10xxxxxx
bool is_continuation(char c)
{
    return (static_cast<unsigned char>(c) & 0xC0) == 0x80;
}
 
// Start of the character before pos
std::size_t prev_char(const std::string& s, std::size_t pos)
{
    if (pos == 0) {
        return 0;
    }
    --pos;
    while (pos > 0 && is_continuation(s[pos])) {
        --pos;
    }
    return pos;
}
 
// Start of the character after the one at pos
std::size_t next_char(const std::string& s, std::size_t pos)
{
    if (pos >= s.size()) {
        return s.size();
    }
    ++pos;
    while (pos < s.size() && is_continuation(s[pos])) {
        ++pos;
    }
    return pos;
}
} // namespace
 
asw::ui::InputBox::~InputBox()
{
    if (_focused) {
        SDL_StopTextInput(asw::display::get_window());
    }
}
 
void asw::ui::InputBox::on_focus_changed(Context& ctx, bool focused)
{
    (void)ctx;
 
    if (focused) {
        SDL_StartTextInput(asw::display::get_window());
        _cursor_pos = value.size();
    } else {
        SDL_StopTextInput(asw::display::get_window());
    }
}
 
bool asw::ui::InputBox::on_event(Context& ctx, const UIEvent& e)
{
    (void)ctx;
 
    // value is public and may have been shortened since the last event
    _cursor_pos = std::min(_cursor_pos, value.size());
 
    if (!enabled) {
        return false;
    }
 
    switch (e.type) {
    case UIEvent::Type::PointerDown: {
        // Root has already focused the box
        if (e.mouse_button != asw::input::MouseButton::Left) {
            return false;
        }
        _cursor_pos = value.size();
        return true;
    }
    case UIEvent::Type::TextInput: {
        value.insert(_cursor_pos, e.text);
        _cursor_pos += e.text.size();
        if (on_change) {
            on_change(value);
        }
        return true;
    }
    case UIEvent::Type::KeyDown: {
        if (e.key == asw::input::Key::Backspace) {
            if (_cursor_pos > 0) {
                // Whole characters, not single bytes of a UTF-8 sequence
                const auto start = prev_char(value, _cursor_pos);
                value.erase(start, _cursor_pos - start);
                _cursor_pos = start;
                if (on_change) {
                    on_change(value);
                }
            }
            return true;
        }
        if (e.key == asw::input::Key::Delete) {
            if (_cursor_pos < value.size()) {
                value.erase(_cursor_pos, next_char(value, _cursor_pos) - _cursor_pos);
                if (on_change) {
                    on_change(value);
                }
            }
            return true;
        }
        // At either end left and right fall through to move focus
        if (e.key == asw::input::Key::Left) {
            if (_cursor_pos == 0) {
                return false;
            }
            _cursor_pos = prev_char(value, _cursor_pos);
            return true;
        }
        if (e.key == asw::input::Key::Right) {
            if (_cursor_pos >= value.size()) {
                return false;
            }
            _cursor_pos = next_char(value, _cursor_pos);
            return true;
        }
        if (e.key == asw::input::Key::Home) {
            _cursor_pos = 0;
            return true;
        }
        if (e.key == asw::input::Key::End) {
            _cursor_pos = value.size();
            return true;
        }
        return false;
    }
    default:
        break;
    }
    return false;
}
 
void asw::ui::InputBox::draw(Context& ctx)
{
    constexpr float text_padding = 4.0F;
 
    const auto& s = get_style(ctx);
    const auto& f = pick_font(font, ctx.theme);
 
    // Background
    asw::draw::rect_fill(transform, enabled ? s.bg : s.bg_disabled);
 
    // Border
    if (s.border_width > 0.0F) {
        asw::draw::rect(
            transform, (_hovered && enabled) ? s.border_hover : s.border, s.border_width);
    }
 
    // Clip text to input bounds, inside any clip already set, which is put
    // back after
    SDL_Renderer* renderer = asw::display::get_renderer();
    const bool had_clip = SDL_RenderClipEnabled(renderer);
    SDL_Rect old_clip {};
    if (had_clip) {
        SDL_GetRenderClipRect(renderer, &old_clip);
    }
 
    const SDL_Rect box_clip {
        static_cast<int>(transform.position.x + text_padding),
        static_cast<int>(transform.position.y),
        static_cast<int>(transform.size.x - (text_padding * 2)),
        static_cast<int>(transform.size.y),
    };
    SDL_Rect clip = box_clip;
    const bool text_visible = !had_clip || SDL_GetRectIntersection(&box_clip, &old_clip, &clip);
    SDL_SetRenderClipRect(renderer, &clip);
 
    // Caret offset from the start of the text
    _cursor_pos = std::min(_cursor_pos, value.size());
    float caret_offset = 0.0F;
    if (_focused && _cursor_pos > 0 && f != nullptr) {
        // A view of the text before the caret, not a copy
        const std::string_view before_caret = std::string_view(value).substr(0, _cursor_pos);
        caret_offset = static_cast<float>(asw::util::get_text_size(f, before_caret).x);
    }
 
    // Scroll so the caret stays inside the box. The caret is 1 pixel wide, so
    // it needs that much room at the right edge.
    const float visible_width = std::max(transform.size.x - (text_padding * 2) - 1.0F, 0.0F);
    if (!_focused || value.empty() || f == nullptr) {
        _scroll = 0.0F;
    } else {
        const auto text_width = static_cast<float>(asw::util::get_text_size(f, value).x);
        _scroll = std::clamp(_scroll, caret_offset - visible_width, caret_offset);
        _scroll = std::clamp(_scroll, 0.0F, std::max(text_width - visible_width, 0.0F));
    }
 
    const float text_x = transform.position.x + text_padding - _scroll;
 
    // Text position (vertically centered)
    const auto& display_text = value.empty() ? placeholder : value;
    const auto display_color = value.empty() ? s.placeholder : s.text;
 
    if (text_visible && !display_text.empty() && f != nullptr) {
        const auto text_size = asw::util::get_text_size(f, display_text);
        const float text_y = transform.position.y + ((transform.size.y - text_size.y) / 2.0F);
        const asw::Vec2 text_pos { text_x, text_y };
 
        asw::draw::text(f, display_text, text_pos, display_color);
    }
 
    // Cursor
    if (text_visible && _focused && f != nullptr) {
        const float cursor_x = text_x + caret_offset;
 
        const auto text_height = asw::util::get_text_size(f, "|");
        const float cursor_y = transform.position.y
            + ((transform.size.y - static_cast<float>(text_height.y)) / 2.0F);
 
        asw::draw::line({ cursor_x, cursor_y },
            { cursor_x, cursor_y + static_cast<float>(text_height.y) }, s.caret);
    }
 
    // Put back the clip from before
    SDL_SetRenderClipRect(renderer, had_clip ? &old_clip : nullptr);
 
    Widget::draw(ctx);
}