OSDGUI.cc

Go to the documentation of this file.

#include "OSDGUI.hh"
 
#include "CommandException.hh"
#include "Display.hh"
#include "OSDRectangle.hh"
#include "OSDText.hh"
#include "OSDWidget.hh"
#include "TclObject.hh"
 
#include "StringOp.hh"
#include "one_of.hh"
#include "outer.hh"
 
#include <array>
#include <memory>
#include <utility>
 
namespace openmsx {
 
// class OSDGUI
 
OSDGUI::OSDGUI(CommandController& commandController, Display& display_)
        : display(display_)
        , osdCommand(commandController)
        , topWidget(display_)
{
}
 
void OSDGUI::refresh() const
{
        getDisplay().repaintDelayed(40000); // 25 fps
}
 
 
// class OSDCommand
 
OSDGUI::OSDCommand::OSDCommand(CommandController& commandController_)
        : Command(commandController_, "osd")
{
}
 
void OSDGUI::OSDCommand::execute(std::span<const TclObject> tokens, TclObject& result)
{
        checkNumArgs(tokens, AtLeast{2}, "subcommand ?arg ...?");
        executeSubCommand(tokens[1].getString(),
                "create",    [&]{ create(tokens, result); },
                "destroy",   [&]{ destroy(tokens, result); },
                "info",      [&]{ info(tokens, result); },
                "exists",    [&]{ exists(tokens, result); },
                "configure", [&]{ configure(tokens, result); });
}
 
void OSDGUI::OSDCommand::create(std::span<const TclObject> tokens, TclObject& result)
{
        checkNumArgs(tokens, AtLeast{4}, Prefix{2}, "type name ?property value ...?");
        std::string_view type = tokens[2].getString();
        const auto& fullname = tokens[3];
        auto fullnameStr = fullname.getString();
 
        auto& gui = OUTER(OSDGUI, osdCommand);
        auto& top = gui.getTopWidget();
        if (top.findByName(fullnameStr)) {
                throw CommandException(
                        "There already exists a widget with this name: ",
                        fullnameStr);
        }
 
        auto [parentName, childName] = StringOp::splitOnLast(fullnameStr, '.');
        auto* parent = childName.empty() ? &top : top.findByName(parentName);
        if (!parent) {
                throw CommandException(
                        "Parent widget doesn't exist yet:", parentName);
        }
 
        auto widget = create(type, fullname);
        auto* widget2 = widget.get();
        configure(*widget, tokens.subspan(4));
        top.addName(*widget);
        parent->addWidget(std::move(widget));
 
        result = fullname;
        if (widget2->isVisible()) {
                gui.refresh();
        }
}
 
std::unique_ptr<OSDWidget> OSDGUI::OSDCommand::create(
        std::string_view type, const TclObject& name) const
{
        auto& gui = OUTER(OSDGUI, osdCommand);
        if (type == "rectangle") {
                return std::make_unique<OSDRectangle>(gui.display, name);
        } else if (type == "text") {
                return std::make_unique<OSDText>(gui.display, name);
        } else {
                throw CommandException(
                        "Invalid widget type '", type, "', expected "
                        "'rectangle' or 'text'.");
        }
}
 
void OSDGUI::OSDCommand::destroy(std::span<const TclObject> tokens, TclObject& result)
{
        checkNumArgs(tokens, 3, "name");
        auto fullname = tokens[2].getString();
 
        auto& gui = OUTER(OSDGUI, osdCommand);
        auto& top = gui.getTopWidget();
        auto* widget = top.findByName(fullname);
        if (!widget) {
                // widget not found, not an error
                result = false;
                return;
        }
 
        auto* parent = widget->getParent();
        if (!parent) {
                throw CommandException("Can't destroy the top widget.");
        }
 
        if (widget->isVisible()) {
                gui.refresh();
        }
        top.removeName(*widget);
        parent->deleteWidget(*widget);
        result = true;
}
 
void OSDGUI::OSDCommand::info(std::span<const TclObject> tokens, TclObject& result)
{
        checkNumArgs(tokens, Between{2, 4}, Prefix{2}, "?name? ?property?");
        auto& gui = OUTER(OSDGUI, osdCommand);
        switch (tokens.size()) {
        case 2: {
                // list widget names
                result.addListElements(gui.getTopWidget().getAllWidgetNames());
                break;
        }
        case 3: {
                // list properties for given widget
                const auto& widget = getWidget(tokens[2].getString());
                result.addListElements(widget.getProperties());
                break;
        }
        case 4: {
                // get current value for given widget/property
                const auto& widget = getWidget(tokens[2].getString());
                widget.getProperty(tokens[3].getString(), result);
                break;
        }
        }
}
 
void OSDGUI::OSDCommand::exists(std::span<const TclObject> tokens, TclObject& result)
{
        checkNumArgs(tokens, 3, "name");
        auto& gui = OUTER(OSDGUI, osdCommand);
        auto* widget = gui.getTopWidget().findByName(tokens[2].getString());
        result = widget != nullptr;
}
 
void OSDGUI::OSDCommand::configure(std::span<const TclObject> tokens, TclObject& /*result*/)
{
        checkNumArgs(tokens, AtLeast{3}, "name ?property value ...?");
        auto& widget = getWidget(tokens[2].getString());
        configure(widget, tokens.subspan(3));
        if (widget.isVisible()) {
                auto& gui = OUTER(OSDGUI, osdCommand);
                gui.refresh();
        }
}
 
void OSDGUI::OSDCommand::configure(OSDWidget& widget, std::span<const TclObject> tokens) const
{
        if (tokens.size() & 1) {
                // odd number of extra arguments
                throw CommandException(
                        "Missing value for '", tokens.back().getString(), "'.");
        }
 
        auto& interp = getInterpreter();
        for (size_t i = 0; i < tokens.size(); i += 2) {
                const auto& propName = tokens[i + 0].getString();
                widget.setProperty(interp, propName, tokens[i + 1]);
        }
}
 
std::string OSDGUI::OSDCommand::help(std::span<const TclObject> tokens) const
{
        if (tokens.size() >= 2) {
                if (tokens[1] == "create") {
                        return
                          "osd create <type> <widget-path> [<property-name> <property-value>]...\n"
                          "\n"
                          "Creates a new OSD widget of given type. Path is a "
                          "hierarchical name for the widget (separated by '.'). "
                          "The parent widget for this new widget must already "
                          "exist.\n"
                          "Optionally you can set initial values for one or "
                          "more properties.\n"
                          "This command returns the path of the newly created "
                          "widget. This is path is again needed to configure "
                          "or to remove the widget. It may be useful to assign "
                          "this path to a variable.";
                } else if (tokens[1] == "destroy") {
                        return
                          "osd destroy <widget-path>\n"
                          "\n"
                          "Remove the specified OSD widget. Returns '1' on "
                          "success and '0' when widget couldn't be destroyed "
                          "because there was no widget with that name";
                } else if (tokens[1] == "info") {
                        return
                          "osd info [<widget-path> [<property-name>]]\n"
                          "\n"
                          "Query various information about the OSD status. "
                          "You can call this command with 0, 1 or 2 arguments.\n"
                          "Without any arguments, this command returns a list "
                          "of all existing widget IDs.\n"
                          "When a path is given as argument, this command "
                          "returns a list of available properties for that widget.\n"
                          "When both path and property name arguments are "
                          "given, this command returns the current value of "
                          "that property.";
                } else if (tokens[1] == "exists") {
                        return
                          "osd exists <widget-path>\n"
                          "\n"
                          "Test whether there exists a widget with given name. "
                          "This subcommand is meant to be used in scripts.";
                } else if (tokens[1] == "configure") {
                        return
                          "osd configure <widget-path> [<property-name> <property-value>]...\n"
                          "\n"
                          "Modify one or more properties on the given widget.";
                } else {
                        return "No such subcommand, see 'help osd'.";
                }
        } else {
                return
                  "Low level OSD GUI commands\n"
                  "  osd create <type> <widget-path> [<property-name> <property-value>]...\n"
                  "  osd destroy <widget-path>\n"
                  "  osd info [<widget-path> [<property-name>]]\n"
                  "  osd exists <widget-path>\n"
                  "  osd configure <widget-path> [<property-name> <property-value>]...\n"
                  "Use 'help osd <subcommand>' to see more info on a specific subcommand";
        }
}
 
void OSDGUI::OSDCommand::tabCompletion(std::vector<std::string>& tokens) const
{
        using namespace std::literals;
        auto& gui = OUTER(OSDGUI, osdCommand);
        if (tokens.size() == 2) {
                static constexpr std::array cmds = {
                        "create"sv, "destroy"sv, "info"sv, "exists"sv, "configure"sv
                };
                completeString(tokens, cmds);
        } else if ((tokens.size() == 3) && (tokens[1] == "create")) {
                static constexpr std::array types = {"rectangle"sv, "text"sv};
                completeString(tokens, types);
        } else if ((tokens.size() == 3) ||
                   ((tokens.size() == 4) && (tokens[1] == "create"))) {
                completeString(tokens, gui.getTopWidget().getAllWidgetNames());
        } else {
                try {
                        auto properties = [&] {
                                if (tokens[1] == "create") {
                                        auto widget = create(tokens[2], TclObject());
                                        return widget->getProperties();
                                } else if (tokens[1] == one_of("configure", "info")) {
                                        const auto& widget = getWidget(tokens[2]);
                                        return widget.getProperties();
                                } else {
                                        return std::span<const std::string_view>{};
                                }
                        }();
                        completeString(tokens, properties);
                } catch (MSXException&) {
                        // ignore
                }
        }
}
 
OSDWidget& OSDGUI::OSDCommand::getWidget(std::string_view name) const
{
        auto& gui = OUTER(OSDGUI, osdCommand);
        auto* widget = gui.getTopWidget().findByName(name);
        if (!widget) {
                throw CommandException("No widget with name ", name);
        }
        return *widget;
}
 
} // namespace openmsx