floating_textbox.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2006 - 2025
    by Joerg Hinrichs <joerg.hinrichs@alice-dsl.de>
    Copyright (C) 2003 by David White <dave@whitevine.net>
    Part of the Battle for Wesnoth Project https://www.wesnoth.org/
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY.
 
    See the COPYING file for more details.
*/
 
#include "floating_textbox.hpp"
 
#include "display_chat_manager.hpp"
#include "floating_label.hpp"
#include "font/standard_colors.hpp"
#include "game_display.hpp"
#include "preferences/preferences.hpp"
#include "video.hpp"
#include "log.hpp"
 
#include <SDL3/SDL_keyboard.h>
#include <ctime>
 
static lg::log_domain log_display("display");
#define ERR_DP LOG_STREAM(err, log_display)
 
namespace gui
{
floating_textbox::floating_textbox() :
    box_(nullptr),
    check_(nullptr),
    mode_(TEXTBOX_NONE),
    label_string_(),
    label_(0),
    command_history_()
{}
 
void floating_textbox::close()
{
    if(!active()) {
        return;
    }
 
    if(check_ != nullptr && mode_ == TEXTBOX_MESSAGE) {
        prefs::get().set_message_private(check_->checked());
    }
    box_.reset(nullptr);
    check_.reset(nullptr);
    font::remove_floating_label(label_);
    mode_ = TEXTBOX_NONE;
 
#if defined(__ANDROID__) || defined(__IPHONEOS__)
    // Hide onscreen keyboard
    SDL_StopTextInput(video::get_window());
#endif
}
 
void floating_textbox::update_location(game_display& gui)
{
    if(box_ == nullptr) {
        return;
    }
 
    const rect& area = gui.map_outside_area();
 
    const int border_size = 10;
 
#ifdef __ANDROID__
    // On Android the Onscreen keyboard hides this box if aligned to bottom,
    // so we align it to top instead.
    const int ypos = area.y + border_size - (check_ != nullptr ? check_->height() + border_size : 0);
#else
    const int ypos = area.y + area.h - 30 - (check_ != nullptr ? check_->height() + border_size : 0);
#endif
 
    if(label_ != 0) {
        font::remove_floating_label(label_);
    }
 
    font::floating_label flabel(label_string_);
    flabel.set_color(font::YELLOW_COLOR);
    flabel.set_position(area.x + border_size, ypos);
    flabel.set_alignment(font::LEFT_ALIGN);
    flabel.set_clip_rect(area);
 
    // This label should always be a single line and never wrap. Without explicitly setting -1, Pango
    // will measure it against a full-screen-wide wrap box (floating label's clip_rect width), and for
    // a pure RTL caption (eg Arabic, Hebrew) Pango inflates the measured width to practically the
    // entire screen width - therefore there is no room for the text-box and it appears as though it
    // doesn't work for RTL text. Refer GitHub #8673.
    flabel.set_width(-1);
 
    label_ = font::add_floating_label(flabel);
 
    if(label_ == 0) {
        return;
    }
 
    const rect& label_area = font::get_floating_label_rect(label_);
    const int textbox_width = area.w - label_area.w - border_size * 3;
 
    if(textbox_width <= 0) {
        font::remove_floating_label(label_);
        return;
    }
 
    if(box_ != nullptr) {
        const rect rect {
            area.x + label_area.w + border_size * 2
            , ypos
            , textbox_width
            , box_->height()
        };
 
        box_->set_location(rect);
    }
 
    if(check_ != nullptr) {
        check_->set_location(box_->location().x,box_->location().y + box_->location().h + border_size);
    }
}
 
void floating_textbox::show(
    gui::TEXTBOX_MODE mode, const std::string& label,
    const std::string& check_label, bool checked, game_display& gui)
{
    close();
 
    label_string_ = label;
    mode_ = mode;
 
    if(!check_label.empty()) {
        check_.reset(new gui::button(check_label,gui::button::TYPE_CHECK));
        check_->set_check(checked);
    }
 
    box_.reset(new gui::textbox(100,"",true,256,font::SIZE_NORMAL,0.8,0.6));
 
    update_location(gui);
 
#if defined(__ANDROID__) || defined(__IPHONEOS__)
    // Show onscreen keyboard
    SDL_StartTextInput(video::get_window());
#endif
}
 
void floating_textbox::tab(const std::set<std::string>& dictionary)
{
    if(active() == false) {
        return;
    }
 
    std::string text = box_->text();
    std::vector<std::string> matches(dictionary.begin(), dictionary.end());
    const bool line_start = utils::word_completion(text, matches);
 
    if(matches.empty()) {
        return;
    }
 
    if(matches.size() == 1 && mode_ == gui::TEXTBOX_MESSAGE) {
        text.append(line_start ? ": " : " ");
    } else if(matches.size() > 1) {
        std::string completion_list = utils::join(matches, " ");
        game_display::get_singleton()->get_chat_manager().add_chat_message(
            std::chrono::system_clock::now(), "", 0, completion_list, events::chat_handler::MESSAGE_PRIVATE, false);
    }
    box_->set_text(text);
}
 
void floating_textbox::memorize_command(const std::string& command)
{
    if(command.empty()) {
        return;
    }
 
    auto prev = std::find(command_history_.begin(), command_history_.end(), command);
 
    if(prev != command_history_.end()) {
        command_history_.erase(prev);
    }
    command_history_.emplace_back(command);
}
}