admin/libvirtualhid
1
0 Fork 0
mirror of https://github.com/LizardByte/libvirtualhid.git synced 2026-10-23 03:27:34 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
libvirtualhid/tools/virtualhid_control.cpp
T

1885 lines
61 KiB
C++
Raw Permalink Blame History

/**
* @file tools/virtualhid_control.cpp
* @brief SDL3 and Dear ImGui UI for creating and testing libvirtualhid devices.
*/
// standard includes
#include <algorithm>
#include <array>
#include <cfloat>
#include <chrono>
#include <cstdint>
#include <exception>
#include <format>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
// third-party includes
#include <imgui.h>
#include <imgui_impl_sdl3.h>
#include <imgui_impl_sdlrenderer3.h>
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
// local includes
#include "virtualhid_control_model.hpp"
/**
* @brief Implementation of the diagnostic control application's UI.
*/
namespace lvh::tools::virtualhid_control::ui {
using lvh::tools::virtualhid_control::axis_choices;
using lvh::tools::virtualhid_control::axis_to_slider;
using lvh::tools::virtualhid_control::battery_choice_index;
using lvh::tools::virtualhid_control::battery_choices;
using lvh::tools::virtualhid_control::battery_state_name;
using lvh::tools::virtualhid_control::button_choices;
using lvh::tools::virtualhid_control::device_feature_summary;
using lvh::tools::virtualhid_control::device_type_choices;
using lvh::tools::virtualhid_control::device_type_name;
using lvh::tools::virtualhid_control::mouse_button_choices;
using lvh::tools::virtualhid_control::mouse_button_event;
using lvh::tools::virtualhid_control::mouse_event_for_action;
using lvh::tools::virtualhid_control::MouseControlAction;
using lvh::tools::virtualhid_control::node_kind_name;
using lvh::tools::virtualhid_control::normalized_license_key;
using lvh::tools::virtualhid_control::output_kind_name;
using lvh::tools::virtualhid_control::output_summary;
using lvh::tools::virtualhid_control::OutputLogEntry;
using lvh::tools::virtualhid_control::OutputState;
using lvh::tools::virtualhid_control::profile_choices;
using lvh::tools::virtualhid_control::profile_for_choice;
using lvh::tools::virtualhid_control::raw_hex;
using lvh::tools::virtualhid_control::slider_to_float;
using lvh::tools::virtualhid_control::trigger_to_slider;
using lvh::tools::virtualhid_control::update_visible_controls_for_profile;
struct ControlledGamepad: OutputState {
std::string profile_label;
std::unique_ptr<lvh::GamepadStateAdapter> adapter;
};
struct ControlledMouse {
std::string profile_label;
std::unique_ptr<lvh::Mouse> mouse;
std::array<bool, mouse_button_choices.size()> buttons {};
};
struct DeviceHandles {
std::vector<std::unique_ptr<lvh::GamepadStateAdapter>> gamepads;
std::vector<std::unique_ptr<lvh::Mouse>> mice;
};
struct ScheduledMouseEvent {
lvh::DeviceId device_id = 0;
lvh::MouseEvent event;
std::chrono::steady_clock::time_point due_at;
};
struct DeviceListItem {
lvh::DeviceId id = 0;
std::string label;
};
struct SelectedSnapshot {
bool has_device = false;
lvh::DeviceId id = 0;
lvh::DeviceType device_type = lvh::DeviceType::gamepad;
std::string profile_label;
lvh::DeviceProfile profile;
lvh::GamepadState state;
lvh::GamepadProfileSupport support;
std::array<bool, mouse_button_choices.size()> mouse_buttons {};
std::uint64_t submit_count = 0;
std::vector<lvh::DeviceNode> nodes;
std::vector<OutputLogEntry> outputs;
std::string state_text;
std::string output_text;
};
lvh::DeviceId first_device_id(
const std::map<lvh::DeviceId, ControlledGamepad> &gamepads,
const std::map<lvh::DeviceId, ControlledMouse> &mice
) {
if (gamepads.empty()) {
return mice.empty() ? 0 : mice.begin()->first;
}
if (mice.empty()) {
return gamepads.begin()->first;
}
return std::min(gamepads.begin()->first, mice.begin()->first);
}
class ScopedDisabled {
public:
explicit ScopedDisabled(bool disabled):
disabled_ {disabled} {
if (disabled_) {
ImGui::BeginDisabled();
}
}
ScopedDisabled(const ScopedDisabled &) = delete;
ScopedDisabled &operator=(const ScopedDisabled &) = delete;
~ScopedDisabled() {
if (disabled_) {
ImGui::EndDisabled();
}
}
private:
bool disabled_ = false;
};
void append_utf8(std::string &target, char32_t codepoint) {
if (codepoint <= 0x7F) {
target.push_back(static_cast<char>(codepoint));
} else if (codepoint <= 0x7FF) {
target.push_back(static_cast<char>(0xC0 | (codepoint >> 6U)));
target.push_back(static_cast<char>(0x80 | (codepoint & 0x3FU)));
} else if (codepoint <= 0xFFFF) {
target.push_back(static_cast<char>(0xE0 | (codepoint >> 12U)));
target.push_back(static_cast<char>(0x80 | ((codepoint >> 6U) & 0x3FU)));
target.push_back(static_cast<char>(0x80 | (codepoint & 0x3FU)));
} else {
target.push_back(static_cast<char>(0xF0 | (codepoint >> 18U)));
target.push_back(static_cast<char>(0x80 | ((codepoint >> 12U) & 0x3FU)));
target.push_back(static_cast<char>(0x80 | ((codepoint >> 6U) & 0x3FU)));
target.push_back(static_cast<char>(0x80 | (codepoint & 0x3FU)));
}
}
bool is_high_surrogate(char32_t codepoint) {
return codepoint >= 0xD800 && codepoint <= 0xDBFF;
}
bool is_low_surrogate(char32_t codepoint) {
return codepoint >= 0xDC00 && codepoint <= 0xDFFF;
}
char32_t next_wide_codepoint(std::wstring_view value, std::size_t &index) {
auto codepoint = static_cast<char32_t>(value[index]);
++index;
if constexpr (sizeof(wchar_t) == 2) {
if (is_high_surrogate(codepoint) && index < value.size()) {
const auto low = static_cast<char32_t>(value[index]);
if (is_low_surrogate(low)) {
++index;
return 0x10000 + ((codepoint - 0xD800) << 10U) + (low - 0xDC00);
}
}
}
return codepoint;
}
std::string to_utf8(std::wstring_view value) {
std::string result;
result.reserve(value.size());
std::size_t index = 0;
while (index < value.size()) {
append_utf8(result, next_wide_codepoint(value, index));
}
return result;
}
std::string output_line(const OutputLogEntry &entry) {
const auto &output = entry.output;
std::ostringstream line;
line << "#" << entry.sequence << " " << to_utf8(output_kind_name(output.kind))
<< " low=" << output.low_frequency_rumble
<< " high=" << output.high_frequency_rumble
<< " rgb=" << static_cast<unsigned>(output.red) << "," << static_cast<unsigned>(output.green) << ","
<< static_cast<unsigned>(output.blue);
if (!output.raw_report.empty()) {
line << " raw=" << to_utf8(raw_hex(output.raw_report));
}
return line.str();
}
void render_device_nodes(const SelectedSnapshot &selected) {
if (!selected.has_device) {
ImGui::TextDisabled("No selected device.");
return;
}
if (selected.nodes.empty()) {
ImGui::TextDisabled("No device nodes reported yet.");
return;
}
for (const auto &node : selected.nodes) {
const auto line = to_utf8(node_kind_name(node.kind)) + ": " + node.path;
ImGui::TextWrapped("%s", line.c_str());
}
}
void render_output_reports(const SelectedSnapshot &selected) {
if (!selected.has_device) {
ImGui::TextDisabled("No selected device.");
return;
}
if (selected.outputs.empty()) {
ImGui::TextDisabled("No output reports received.");
return;
}
for (const auto &entry : selected.outputs) {
const auto line = output_line(entry);
ImGui::TextWrapped("%s", line.c_str());
}
}
int scaled_window_dimension(int value, float scale) {
return std::max(value, static_cast<int>(static_cast<float>(value) * scale));
}
bool selected_battery_state_is_full(int state_index) {
return state_index >= 0 &&
static_cast<std::size_t>(state_index) < battery_choices.size() &&
battery_choices[static_cast<std::size_t>(state_index)].state == lvh::GamepadBatteryState::full;
}
std::string backend_text(const lvh::Runtime &runtime) {
const auto &caps = runtime.capabilities();
auto text = std::string {"Backend: "} + caps.backend_name;
text += caps.supports_gamepad ? " | gamepad available" : " | gamepad unavailable";
text += caps.supports_mouse ? " | mouse available" : " | mouse unavailable";
text += caps.supports_output_reports ? " | output reports available" : " | output reports unavailable";
return text;
}
struct LicenseSnapshot {
bool broker_supported = false;
bool broker_available = false;
bool licensed = false;
std::string plan_name = "Unavailable";
std::string customer_email;
std::string state_text = "License broker unavailable.";
std::string message;
std::string purchase_url;
std::string manage_account_url;
std::uint32_t active_devices = 0;
std::uint32_t free_limit = 0;
std::uint32_t activation_limit = 0;
std::uint32_t activation_usage = 0;
};
bool open_url(std::string_view url, std::string &error) {
if (url.empty()) {
error = "URL is not configured.";
return false;
}
if (SDL_OpenURL(std::string {url}.c_str())) {
return true;
}
error = SDL_GetError();
if (error.empty()) {
error = "Unable to open URL.";
}
return false;
}
std::string license_state_name(lvh::LicenseState state) {
using enum lvh::LicenseState;
switch (state) {
case unlicensed:
return "Unlicensed";
case licensed:
return "Licensed";
case expired:
return "Expired";
case disabled:
return "Disabled";
case invalid:
return "Invalid";
case unavailable:
default:
return "Unavailable";
}
}
LicenseSnapshot license_snapshot_from(const lvh::LicenseResult &result) {
const auto &status = result.license;
LicenseSnapshot snapshot;
snapshot.broker_supported = status.state != lvh::LicenseState::unavailable;
snapshot.broker_available = status.service_available;
snapshot.licensed = status.licensed();
snapshot.plan_name = status.plan_name;
snapshot.customer_email = status.customer_email;
snapshot.message = status.message.empty() ? result.status.message() : status.message;
snapshot.purchase_url = status.purchase_url;
snapshot.manage_account_url = status.manage_account_url;
snapshot.active_devices = status.active_devices;
snapshot.activation_limit = status.activation_limit;
snapshot.activation_usage = status.activation_usage;
const auto state = license_state_name(status.state);
snapshot.state_text = state;
if (!snapshot.plan_name.empty() && snapshot.plan_name != state) {
snapshot.state_text += " | " + snapshot.plan_name;
}
snapshot.state_text += std::format(" | active devices {}", status.active_devices);
if (status.licensed()) {
snapshot.state_text += " / unlimited";
} else {
snapshot.state_text += " | license required";
}
if (status.activation_limit > 0U) {
snapshot.state_text += std::format(" | machine limit {}", status.activation_limit);
}
return snapshot;
}
LicenseSnapshot license_snapshot_from(const lvh::LicenseResult &result, std::string &error) {
error = result.status.ok() ? std::string {} : result.status.message();
return license_snapshot_from(result);
}
/**
* @brief Display license status and manage machine activation on Windows and macOS.
*/
class LicensePanel {
public:
LicensePanel() {
refresh();
}
void refresh() {
std::string ignored;
apply_result(lvh::get_license_status(), ignored);
}
template<typename ErrorHandler>
void render(ErrorHandler show_error) {
ImGui::TextUnformatted("License");
ImGui::TextWrapped("%s", snapshot_.state_text.c_str());
if (!snapshot_.customer_email.empty()) {
ImGui::TextWrapped("%s", snapshot_.customer_email.c_str());
}
if (!snapshot_.message.empty()) {
ImGui::TextWrapped("%s", snapshot_.message.c_str());
}
#if defined(_WIN32) || defined(__APPLE__)
ImGui::TextUnformatted("License key");
ImGui::InputText("##license-key", license_key_input_.data(), license_key_input_.size());
{
const auto license_key = normalized_license_key(license_key_input_.data());
ScopedDisabled disabled {license_key.empty()};
if (ImGui::Button("Activate license", {-FLT_MIN, 0.0F})) {
activate(license_key, show_error);
}
}
{
ScopedDisabled disabled {!snapshot_.broker_available};
if (ImGui::Button("Refresh", {-FLT_MIN, 0.0F})) {
validate(show_error);
}
if (ImGui::Button("Deactivate this machine", {-FLT_MIN, 0.0F})) {
deactivate(show_error);
}
}
#else
if (ImGui::Button("Refresh", {-FLT_MIN, 0.0F})) {
refresh_and_report(show_error);
}
#endif
{
ScopedDisabled disabled {buy_url_.empty()};
if (ImGui::Button("Buy license", {-FLT_MIN, 0.0F})) {
open_configured_url(buy_url_, show_error);
}
}
{
ScopedDisabled disabled {manage_account_url_.empty()};
if (ImGui::Button("Manage account", {-FLT_MIN, 0.0F})) {
open_configured_url(manage_account_url_, show_error);
}
}
}
template<typename CreateHandler>
void render_create_button(CreateHandler create_device) const {
#if defined(_WIN32)
ScopedDisabled disabled {!snapshot_.broker_available || !snapshot_.licensed};
#endif
if (ImGui::Button("Create", {-FLT_MIN, 0.0F})) {
create_device();
}
}
private:
void apply_result(const lvh::LicenseResult &result, std::string &error) {
snapshot_ = license_snapshot_from(result, error);
buy_url_ = snapshot_.purchase_url;
manage_account_url_ = snapshot_.manage_account_url;
}
template<typename ErrorHandler>
void refresh_and_report(ErrorHandler &show_error) {
std::string error;
apply_result(lvh::get_license_status(), error);
if (!error.empty()) {
show_error(error);
}
}
template<typename ErrorHandler>
void open_configured_url(const std::string &url, ErrorHandler &show_error) const {
std::string error;
if (!open_url(url, error)) {
show_error(error);
}
}
#if defined(_WIN32) || defined(__APPLE__)
template<typename ErrorHandler>
void activate(std::string_view license_key, ErrorHandler &show_error) {
std::string error;
apply_result(lvh::activate_license(license_key), error);
if (!error.empty()) {
show_error(error);
} else {
license_key_input_.fill('\0');
}
}
template<typename ErrorHandler>
void validate(ErrorHandler &show_error) {
std::string error;
apply_result(lvh::validate_license(), error);
if (!error.empty()) {
show_error(error);
}
}
template<typename ErrorHandler>
void deactivate(ErrorHandler &show_error) {
std::string error;
apply_result(lvh::deactivate_license(), error);
if (!error.empty()) {
show_error(error);
}
}
#endif
LicenseSnapshot snapshot_;
#if defined(_WIN32) || defined(__APPLE__)
std::array<char, 128> license_key_input_ {};
#endif
std::string buy_url_;
std::string manage_account_url_;
};
class ErrorPanel {
public:
void show(std::string_view message) {
message_ = message.empty() ? "Operation failed." : std::string {message};
open_popup_ = true;
}
void render() {
if (open_popup_) {
ImGui::OpenPopup("Error");
open_popup_ = false;
}
if (ImGui::BeginPopupModal("Error", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextWrapped("%s", message_.c_str());
if (ImGui::Button("OK", {120.0F, 0.0F})) {
message_.clear();
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}
private:
std::string message_;
bool open_popup_ = false;
};
class DevicePanel {
public:
void refresh_license() {
license_panel_.refresh();
}
lvh::DeviceType current_device_type() const {
const auto *choice = current_device_type_choice();
return choice == nullptr ? lvh::DeviceType::gamepad : choice->type;
}
std::optional<lvh::DeviceProfile> current_profile() const {
const auto *choice = current_profile_choice();
if (choice == nullptr) {
return std::nullopt;
}
return profile_for_choice(*choice);
}
const lvh::tools::virtualhid_control::ProfileChoice *selected_profile_choice() const {
return current_profile_choice();
}
std::optional<lvh::DeviceProfile> control_profile(const SelectedSnapshot &selected) const {
if (selected.has_device) {
return selected.profile;
}
if (current_device_type() == lvh::DeviceType::mouse) {
return lvh::profiles::mouse();
}
return current_profile();
}
template<typename CreateHandler, typename ResetHandler, typename RemoveHandler, typename RemoveAllHandler, typename ErrorHandler>
void render(
const std::vector<DeviceListItem> &devices,
lvh::DeviceId &selected_id,
CreateHandler create_device,
ResetHandler reset_device,
RemoveHandler remove_device,
RemoveAllHandler remove_all_devices,
ErrorHandler show_error
) {
license_panel_.render(show_error);
ImGui::Separator();
render_device_type_selector();
render_profile_selector();
license_panel_.render_create_button(create_device);
render_device_list(devices, selected_id);
render_device_actions(devices.empty(), selected_id, reset_device, remove_device, remove_all_devices);
}
private:
const lvh::tools::virtualhid_control::DeviceTypeChoice *current_device_type_choice() const {
if (device_type_index_ >= device_type_choices.size()) {
return nullptr;
}
return &device_type_choices[device_type_index_];
}
const lvh::tools::virtualhid_control::ProfileChoice *current_profile_choice() const {
if (profile_index_ >= profile_choices.size()) {
return nullptr;
}
return &profile_choices[profile_index_];
}
void render_device_type_selector() {
ImGui::TextUnformatted("Device type");
const auto *choice = current_device_type_choice();
if (const auto preview = choice == nullptr ? std::string {"Select device type"} : to_utf8(choice->label); !ImGui::BeginCombo("##device-type", preview.c_str())) {
return;
}
for (std::size_t index = 0; index < device_type_choices.size(); ++index) {
render_device_type_option(index);
}
ImGui::EndCombo();
}
void render_device_type_option(std::size_t index) {
const auto label = to_utf8(device_type_choices[index].label);
const auto selected = index == device_type_index_;
if (ImGui::Selectable(label.c_str(), selected)) {
device_type_index_ = index;
}
if (selected) {
ImGui::SetItemDefaultFocus();
}
}
void render_profile_selector() {
ImGui::TextUnformatted("Profile");
if (current_device_type() != lvh::DeviceType::gamepad) {
ImGui::TextUnformatted("Generic five-button mouse");
return;
}
const auto *choice = current_profile_choice();
if (const auto preview = choice == nullptr ? std::string {"Select profile"} : to_utf8(choice->label); !ImGui::BeginCombo("##profile", preview.c_str())) {
return;
}
for (std::size_t index = 0; index < profile_choices.size(); ++index) {
render_profile_option(index);
}
ImGui::EndCombo();
}
void render_profile_option(std::size_t index) {
const auto label = to_utf8(profile_choices[index].label);
const auto selected = index == profile_index_;
if (ImGui::Selectable(label.c_str(), selected)) {
profile_index_ = index;
}
if (selected) {
ImGui::SetItemDefaultFocus();
}
}
void render_device_list(const std::vector<DeviceListItem> &devices, lvh::DeviceId &selected_id) const {
ImGui::Spacing();
ImGui::TextUnformatted("Devices");
if (!ImGui::BeginListBox("##devices", {-FLT_MIN, 150.0F})) {
return;
}
if (devices.empty()) {
ImGui::TextDisabled("No devices");
}
for (const auto &device : devices) {
if (ImGui::Selectable(device.label.c_str(), selected_id == device.id)) {
selected_id = device.id;
}
}
ImGui::EndListBox();
}
template<typename ResetHandler, typename RemoveHandler, typename RemoveAllHandler>
void render_device_actions(
bool devices_empty,
lvh::DeviceId selected_id,
ResetHandler reset_device,
RemoveHandler remove_device,
RemoveAllHandler remove_all_devices
) const {
{
ScopedDisabled disabled {selected_id == 0};
if (ImGui::Button("Reset", {-FLT_MIN, 0.0F})) {
reset_device();
}
if (ImGui::Button("Remove selected", {-FLT_MIN, 0.0F})) {
remove_device();
}
}
{
ScopedDisabled disabled {devices_empty};
if (ImGui::Button("Remove all", {-FLT_MIN, 0.0F})) {
remove_all_devices();
}
}
}
LicensePanel license_panel_;
std::size_t device_type_index_ = 0;
std::size_t profile_index_ = 3;
};
class MouseControlPanel {
public:
template<typename SubmitHandler>
void tick(SubmitHandler submit_event) {
dispatch_due_events(submit_event);
}
template<typename SubmitHandler>
void render(const SelectedSnapshot &selected, SubmitHandler submit_event) {
using enum MouseControlAction;
ImGui::TextWrapped(
"Keyboard control: use Tab or arrow keys to highlight a control, then Space or Enter to activate it. "
"Mouse buttons remain pressed only while the activation key is held."
);
ImGui::SliderInt("Movement step", &motion_step_, 1, 500);
ImGui::SliderInt("Scroll step", &scroll_step_, 1, 1200);
ImGui::Checkbox("Delayed browser test", &delayed_test_);
if (ImGui::IsItemDeactivatedAfterEdit()) {
release_active_buttons(submit_event);
cancel_all_scheduled_events(submit_event);
}
if (delayed_test_) {
render_delayed_test_controls(submit_event);
}
ImGui::TextUnformatted("Relative movement");
if (ImGui::BeginTable("mouse-motion", 4, ImGuiTableFlags_SizingStretchSame)) {
render_action_button(selected, "Move left", move_left, submit_event);
render_action_button(selected, "Move up", move_up, submit_event);
render_action_button(selected, "Move down", move_down, submit_event);
render_action_button(selected, "Move right", move_right, submit_event);
ImGui::EndTable();
}
ImGui::TextUnformatted("Buttons (momentary)");
if (ImGui::BeginTable("mouse-buttons", 3, ImGuiTableFlags_SizingStretchSame)) {
for (std::size_t index = 0; index < mouse_button_choices.size(); ++index) {
render_button_control(selected, index, submit_event);
}
ImGui::EndTable();
}
ImGui::TextUnformatted("Wheel");
if (ImGui::BeginTable("mouse-wheel", 4, ImGuiTableFlags_SizingStretchSame)) {
render_action_button(selected, "Pan left", pan_left, submit_event);
render_action_button(selected, "Wheel up", wheel_up, submit_event);
render_action_button(selected, "Wheel down", wheel_down, submit_event);
render_action_button(selected, "Pan right", pan_right, submit_event);
ImGui::EndTable();
}
}
void forget_device(lvh::DeviceId id) {
std::erase_if(scheduled_events_, [id](const ScheduledMouseEvent &event) {
return event.device_id == id;
});
for (std::size_t index = 0; index < active_device_ids_.size(); ++index) {
if (active_device_ids_[index] == id) {
button_active_[index] = false;
active_device_ids_[index] = 0;
}
}
}
void reset() {
button_active_.fill(false);
active_device_ids_.fill(0);
scheduled_events_.clear();
}
private:
template<typename SubmitHandler>
void render_delayed_test_controls(SubmitHandler submit_event) {
ImGui::SliderInt("Delay (seconds)", &delay_seconds_, 1, 10);
ImGui::TextWrapped(
"Activate an action, then switch to the browser before the delay expires. Button actions send one "
"press-and-release click. Keep the pointer over the browser test target."
);
render_scheduled_status(submit_event);
}
template<typename SubmitHandler>
void render_scheduled_status(SubmitHandler submit_event) {
if (scheduled_events_.empty()) {
ImGui::TextDisabled("No browser-test action queued.");
return;
}
const auto next = std::ranges::min_element(scheduled_events_, {}, &ScheduledMouseEvent::due_at);
const auto remaining = std::max(
std::chrono::duration<float> {next->due_at - std::chrono::steady_clock::now()}.count(),
0.0F
);
ImGui::TextColored(
{1.0F, 0.8F, 0.2F, 1.0F},
"Browser-test input queued: switch windows now (%.1f s).",
remaining
);
if (ImGui::Button("Cancel queued input")) {
cancel_all_scheduled_events(submit_event);
}
}
template<typename SubmitHandler>
void render_action_button(
const SelectedSnapshot &selected,
const char *label,
MouseControlAction action,
SubmitHandler submit_event
) {
ImGui::TableNextColumn();
ScopedDisabled disabled {!selected.has_device || selected.device_type != lvh::DeviceType::mouse};
if (!ImGui::Button(label, {-FLT_MIN, 30.0F})) {
return;
}
const auto event = mouse_event_for_action(action, motion_step_, scroll_step_);
if (delayed_test_) {
schedule_event(selected.id, event);
} else {
submit_event(selected.id, event);
}
}
template<typename SubmitHandler>
void render_button_control(const SelectedSnapshot &selected, std::size_t index, SubmitHandler submit_event) {
ImGui::TableNextColumn();
ImGui::PushID(static_cast<int>(index));
const auto pressed = selected.has_device && selected.device_type == lvh::DeviceType::mouse &&
selected.mouse_buttons[index];
if (pressed) {
ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetStyleColorVec4(ImGuiCol_ButtonActive));
}
auto clicked = false;
auto active = false;
{
ScopedDisabled disabled {!selected.has_device || selected.device_type != lvh::DeviceType::mouse};
const auto label = to_utf8(mouse_button_choices[index].label);
clicked = ImGui::Button(label.c_str(), {-FLT_MIN, 30.0F});
active = ImGui::IsItemActive();
}
if (delayed_test_ && clicked) {
schedule_click(selected.id, mouse_button_choices[index].button);
} else if (!delayed_test_) {
update_active_button(selected.id, index, active, submit_event);
}
if (pressed) {
ImGui::PopStyleColor();
}
ImGui::PopID();
}
template<typename SubmitHandler>
void update_active_button(lvh::DeviceId selected_id, std::size_t index, bool active, SubmitHandler submit_event) {
if (button_active_[index] == active) {
return;
}
button_active_[index] = active;
if (active) {
active_device_ids_[index] = selected_id;
submit_event(selected_id, mouse_button_event(mouse_button_choices[index].button, true));
return;
}
const auto device_id = active_device_ids_[index];
active_device_ids_[index] = 0;
submit_event(device_id, mouse_button_event(mouse_button_choices[index].button, false));
}
void schedule_event(lvh::DeviceId id, const lvh::MouseEvent &event) {
if (id == 0) {
return;
}
scheduled_events_.push_back({
.device_id = id,
.event = event,
.due_at = std::chrono::steady_clock::now() + std::chrono::seconds {delay_seconds_},
});
}
void schedule_click(lvh::DeviceId id, lvh::MouseButton button) {
if (id == 0) {
return;
}
const auto press_at = std::chrono::steady_clock::now() + std::chrono::seconds {delay_seconds_};
scheduled_events_.push_back({
.device_id = id,
.event = mouse_button_event(button, true),
.due_at = press_at,
});
scheduled_events_.push_back({
.device_id = id,
.event = mouse_button_event(button, false),
.due_at = press_at + std::chrono::milliseconds {100},
});
}
template<typename SubmitHandler>
void dispatch_due_events(SubmitHandler submit_event) {
const auto now = std::chrono::steady_clock::now();
auto iter = scheduled_events_.begin();
while (iter != scheduled_events_.end()) {
if (iter->due_at > now) {
++iter;
continue;
}
const auto event = *iter;
iter = scheduled_events_.erase(iter);
submit_event(event.device_id, event.event);
}
}
template<typename SubmitHandler>
void release_active_buttons(SubmitHandler submit_event) {
for (std::size_t index = 0; index < button_active_.size(); ++index) {
if (!button_active_[index]) {
continue;
}
submit_event(
active_device_ids_[index],
mouse_button_event(mouse_button_choices[index].button, false)
);
button_active_[index] = false;
active_device_ids_[index] = 0;
}
}
template<typename SubmitHandler>
void cancel_all_scheduled_events(SubmitHandler submit_event) {
std::vector<ScheduledMouseEvent> releases;
for (const auto &event : scheduled_events_) {
if (event.event.kind == lvh::MouseEventKind::button && !event.event.pressed) {
releases.push_back(event);
}
}
scheduled_events_.clear();
for (const auto &release : releases) {
submit_event(release.device_id, release.event);
}
}
std::array<bool, mouse_button_choices.size()> button_active_ {};
std::array<lvh::DeviceId, mouse_button_choices.size()> active_device_ids_ {};
int motion_step_ = 25;
int scroll_step_ = 120;
bool delayed_test_ = false;
int delay_seconds_ = 3;
std::vector<ScheduledMouseEvent> scheduled_events_;
};
int axis_position(const SelectedSnapshot &selected, std::size_t index) {
if (!selected.has_device) {
return 0;
}
switch (index) {
case 0:
return axis_to_slider(selected.state.left_stick.x);
case 1:
return axis_to_slider(selected.state.left_stick.y);
case 2:
return axis_to_slider(selected.state.right_stick.x);
case 3:
return axis_to_slider(selected.state.right_stick.y);
case 4:
return trigger_to_slider(selected.state.left_trigger);
case 5:
return trigger_to_slider(selected.state.right_trigger);
default:
return 0;
}
}
class ControlApp {
public:
ControlApp() {
lvh::RuntimeOptions options;
options.backend = lvh::BackendKind::platform_default;
runtime_ = lvh::Runtime::create(options);
}
~ControlApp() noexcept {
try {
close_all_devices();
} catch (const std::exception &ex) {
SDL_Log("Failed to close virtual devices: %s", ex.what());
} catch (...) {
SDL_Log("Failed to close virtual devices.");
}
}
ControlApp(const ControlApp &) = delete;
ControlApp &operator=(const ControlApp &) = delete;
void tick() {
mouse_control_panel_.tick([this](lvh::DeviceId id, const lvh::MouseEvent &event) {
submit_mouse_event(id, event);
});
}
void render() {
const auto devices = snapshot_devices();
const auto selected = snapshot_selected_device();
const auto &io = ImGui::GetIO();
ImGui::SetNextWindowPos({0.0F, 0.0F});
ImGui::SetNextWindowSize(io.DisplaySize);
constexpr auto window_flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoBringToFrontOnFocus;
ImGui::Begin("libvirtualhid control", nullptr, window_flags);
const auto backend = backend_text(*runtime_);
ImGui::TextWrapped("%s", backend.c_str());
ImGui::Separator();
const auto create_device = [this] {
create_selected_device();
};
const auto reset_device = [this] {
reset_selected_device();
};
const auto remove_device = [this] {
remove_selected_device();
};
const auto remove_all = [this] {
remove_all_devices();
};
const auto show_error = [this](std::string_view message) {
error_panel_.show(message);
};
const auto render_devices = [this, &devices, &create_device, &reset_device, &remove_device, &remove_all, &show_error] {
device_panel_.render(
devices,
selected_id_,
create_device,
reset_device,
remove_device,
remove_all,
show_error
);
};
if (ImGui::GetContentRegionAvail().x < 760.0F) {
render_devices();
ImGui::Separator();
render_control_panel(selected);
} else if (ImGui::BeginTable("control-layout", 2, ImGuiTableFlags_Resizable | ImGuiTableFlags_BordersInnerV)) {
ImGui::TableSetupColumn("Devices", ImGuiTableColumnFlags_WidthFixed, 220.0F);
ImGui::TableSetupColumn("Controls", ImGuiTableColumnFlags_WidthStretch);
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
render_devices();
ImGui::TableSetColumnIndex(1);
render_control_panel(selected);
ImGui::EndTable();
}
error_panel_.render();
ImGui::End();
}
private:
std::vector<DeviceListItem> snapshot_devices() const {
std::vector<DeviceListItem> result;
std::lock_guard lock {mutex_};
result.reserve(devices_.size() + mice_.size());
for (const auto &[id, device] : devices_) {
result.push_back({.id = id, .label = std::format("#{} {}", id, device.profile_label)});
}
for (const auto &[id, device] : mice_) {
result.push_back({.id = id, .label = std::format("#{} {}", id, device.profile_label)});
}
std::ranges::sort(result, {}, &DeviceListItem::id);
return result;
}
SelectedSnapshot snapshot_selected_device() const {
std::lock_guard lock {mutex_};
SelectedSnapshot snapshot;
if (const auto *device = selected_device_locked(); device != nullptr && device->adapter != nullptr && device->adapter->gamepad() != nullptr) {
const auto *gamepad = device->adapter->gamepad();
snapshot.has_device = true;
snapshot.id = gamepad->device_id();
snapshot.device_type = lvh::DeviceType::gamepad;
snapshot.profile_label = device->profile_label;
snapshot.profile = gamepad->profile();
snapshot.state = device->adapter->state();
snapshot.support = device->adapter->support();
snapshot.submit_count = gamepad->submit_count();
snapshot.nodes = gamepad->device_nodes();
snapshot.outputs = device->outputs;
snapshot.output_text = to_utf8(output_summary(*device, snapshot.profile));
std::ostringstream state;
state << snapshot.profile_label << " #" << snapshot.id << "\n"
<< to_utf8(device_type_name(snapshot.profile.device_type)) << " | " << snapshot.profile.name << "\n"
<< "L(" << snapshot.state.left_stick.x << ", " << snapshot.state.left_stick.y << ") "
<< "R(" << snapshot.state.right_stick.x << ", " << snapshot.state.right_stick.y << ") "
<< "LT " << snapshot.state.left_trigger << " RT " << snapshot.state.right_trigger << "\n";
if (snapshot.state.battery) {
state << "Battery " << to_utf8(battery_state_name(snapshot.state.battery->state)) << " "
<< static_cast<unsigned>(snapshot.state.battery->percentage) << "% | ";
} else {
state << "Battery unset | ";
}
state << snapshot.submit_count << " submits";
snapshot.state_text = state.str();
return snapshot;
}
const auto *device = selected_mouse_locked();
if (device == nullptr || device->mouse == nullptr) {
return snapshot;
}
snapshot.has_device = true;
snapshot.id = device->mouse->device_id();
snapshot.device_type = lvh::DeviceType::mouse;
snapshot.profile_label = device->profile_label;
snapshot.profile = device->mouse->profile();
snapshot.mouse_buttons = device->buttons;
snapshot.submit_count = device->mouse->submit_count();
snapshot.nodes = device->mouse->device_nodes();
snapshot.output_text = "Output: mouse is input-only.";
std::ostringstream state;
state << snapshot.profile_label << " #" << snapshot.id << "\n"
<< to_utf8(device_type_name(snapshot.profile.device_type)) << " | " << snapshot.profile.name << "\n"
<< snapshot.submit_count << " submits";
#if defined(_WIN32)
state << "\n"
<< (snapshot.nodes.empty() ? "SendInput fallback (no HID device node)" : "Driver-backed HID mouse");
#endif
snapshot.state_text = state.str();
return snapshot;
}
void render_control_panel(const SelectedSnapshot &selected) {
const auto profile = device_panel_.control_profile(selected);
if (selected.has_device) {
ImGui::TextWrapped("%s", selected.state_text.c_str());
} else {
ImGui::TextUnformatted("No device selected.");
}
if (profile) {
const auto feature_text = to_utf8(device_feature_summary(*profile));
ImGui::TextWrapped("%s", feature_text.c_str());
} else {
ImGui::TextDisabled("No profile selected.");
}
ImGui::Separator();
if (const auto device_type = selected.has_device ? selected.device_type : device_panel_.current_device_type(); device_type == lvh::DeviceType::mouse) {
mouse_control_panel_.render(selected, [this](lvh::DeviceId id, const lvh::MouseEvent &event) {
submit_mouse_event(id, event);
});
} else {
render_button_controls(selected, profile);
ImGui::Separator();
render_axis_controls(selected);
ImGui::Separator();
render_battery_controls(selected, profile);
}
ImGui::Separator();
render_output_controls(selected);
}
void render_button_controls(
const SelectedSnapshot &selected,
const std::optional<lvh::DeviceProfile> &profile
) {
ImGui::Checkbox("Lock buttons", &lock_buttons_);
if (ImGui::IsItemDeactivatedAfterEdit()) {
handle_button_lock_changed();
}
std::array<bool, button_choices.size()> visible_buttons {};
auto battery_visible = false;
if (profile) {
update_visible_controls_for_profile(*profile, visible_buttons, battery_visible);
}
if (!selected.has_device || lock_buttons_) {
button_active_.fill(false);
}
const auto column_count = ImGui::GetContentRegionAvail().x < 480.0F ? 3 : 4;
if (ImGui::BeginTable("buttons", column_count, ImGuiTableFlags_SizingStretchSame)) {
for (std::size_t index = 0; index < button_choices.size(); ++index) {
if (!visible_buttons[index]) {
continue;
}
render_button_control(selected, index);
}
ImGui::EndTable();
}
}
void render_button_control(const SelectedSnapshot &selected, std::size_t index) {
ImGui::TableNextColumn();
ImGui::PushID(static_cast<int>(index));
const auto pressed = selected.has_device && selected.state.buttons.test(button_choices[index].button);
if (pressed) {
ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetStyleColorVec4(ImGuiCol_ButtonActive));
}
{
ScopedDisabled disabled {!selected.has_device};
const auto label = to_utf8(button_choices[index].label);
if (const auto clicked = ImGui::Button(label.c_str(), {-FLT_MIN, 30.0F}); lock_buttons_ && clicked) {
toggle_selected_button(index);
}
if (!lock_buttons_) {
const auto active = ImGui::IsItemActive() && ImGui::IsMouseDown(ImGuiMouseButton_Left);
if (button_active_[index] != active) {
button_active_[index] = active;
set_selected_button(index, active);
}
}
}
if (pressed) {
ImGui::PopStyleColor();
}
ImGui::PopID();
}
void render_axis_controls(const SelectedSnapshot &selected) {
ImGui::TextUnformatted("Axes");
if (ImGui::BeginTable("axes", 2, ImGuiTableFlags_SizingStretchSame)) {
for (std::size_t index = 0; index < axis_choices.size(); ++index) {
ImGui::TableNextColumn();
ImGui::PushID(static_cast<int>(index));
const auto label = to_utf8(axis_choices[index].label);
ImGui::TextUnformatted(label.c_str());
auto position = axis_position(selected, index);
{
ScopedDisabled disabled {!selected.has_device};
if (ImGui::SliderInt("##axis", &position, axis_choices[index].minimum, axis_choices[index].maximum)) {
set_selected_axis(index, position);
}
}
ImGui::PopID();
}
ImGui::EndTable();
}
}
void render_battery_controls(
const SelectedSnapshot &selected,
const std::optional<lvh::DeviceProfile> &profile
) {
auto visible_buttons = std::array<bool, button_choices.size()> {};
auto battery_visible = false;
if (profile) {
update_visible_controls_for_profile(*profile, visible_buttons, battery_visible);
}
if (!battery_visible) {
return;
}
ImGui::TextUnformatted("Battery");
const auto enabled = selected.has_device && selected.support.supports_battery;
if (selected.state.battery) {
battery_state_index_ = battery_choice_index(selected.state.battery->state);
battery_percentage_ = selected.state.battery->percentage;
}
if (selected_battery_state_is_full(battery_state_index_)) {
battery_percentage_ = 100;
}
{
ScopedDisabled disabled {!enabled};
if (const auto state_label = to_utf8(battery_choices[static_cast<std::size_t>(battery_state_index_)].label); ImGui::BeginCombo("State", state_label.c_str())) {
for (std::size_t index = 0; index < battery_choices.size(); ++index) {
const auto label = to_utf8(battery_choices[index].label);
const auto selected_state = static_cast<int>(index) == battery_state_index_;
if (ImGui::Selectable(label.c_str(), selected_state)) {
battery_state_index_ = static_cast<int>(index);
battery_percentage_ = selected_battery_state_is_full(battery_state_index_) ? 100 : battery_percentage_;
set_selected_battery_from_controls();
}
if (selected_state) {
ImGui::SetItemDefaultFocus();
}
}
ImGui::EndCombo();
}
{
ScopedDisabled percentage_disabled {selected_battery_state_is_full(battery_state_index_)};
if (ImGui::SliderInt("Percentage", &battery_percentage_, 0, 100)) {
set_selected_battery_from_controls();
}
}
}
{
ScopedDisabled disabled {!enabled || !selected.state.battery.has_value()};
if (ImGui::Button("Clear battery")) {
clear_selected_battery();
}
}
}
void render_output_controls(const SelectedSnapshot &selected) const {
ImGui::TextWrapped("%s", selected.has_device ? selected.output_text.c_str() : "Output: no selected device.");
if (ImGui::BeginTable("diagnostics", 2, ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_SizingStretchSame)) {
ImGui::TableSetupColumn("Device nodes");
ImGui::TableSetupColumn("Output reports");
ImGui::TableHeadersRow();
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
if (ImGui::BeginChild("device-nodes", {0.0F, 170.0F}, ImGuiChildFlags_Borders)) {
render_device_nodes(selected);
}
ImGui::EndChild();
ImGui::TableSetColumnIndex(1);
if (ImGui::BeginChild("output-reports", {0.0F, 170.0F}, ImGuiChildFlags_Borders)) {
render_output_reports(selected);
}
ImGui::EndChild();
ImGui::EndTable();
}
}
void create_selected_device() {
if (device_panel_.current_device_type() == lvh::DeviceType::mouse) {
create_mouse();
} else {
create_gamepad();
}
}
void create_gamepad() {
const auto *choice = device_panel_.selected_profile_choice();
if (choice == nullptr) {
error_panel_.show("Select a profile first.");
return;
}
const auto profile = profile_for_choice(*choice);
if (!profile) {
error_panel_.show("Could not create the selected profile.");
return;
}
lvh::CreateGamepadOptions options;
options.profile = *profile;
options.metadata.global_index = static_cast<int>(next_metadata_index_++);
options.metadata.client_relative_index = 0;
options.metadata.client_type = choice->client_type;
options.metadata.has_motion_sensors = profile->capabilities.supports_motion;
options.metadata.has_touchpad = profile->capabilities.supports_touchpad;
options.metadata.has_rgb_led = profile->capabilities.supports_rgb_led;
options.metadata.has_battery = profile->capabilities.supports_battery;
options.metadata.stable_id = std::format("libvirtualhid-control-{}", options.metadata.global_index);
auto created = lvh::GamepadStateAdapter::create(*runtime_, options);
if (!created) {
error_panel_.show(created.status.message());
return;
}
const auto *gamepad = created.adapter->gamepad();
if (gamepad == nullptr) {
error_panel_.show("Created gamepad handle is missing.");
return;
}
const auto id = gamepad->device_id();
created.adapter->set_output_callback([this, id](const lvh::GamepadOutput &output) {
record_output(id, output);
});
ControlledGamepad device;
device.profile_label = to_utf8(choice->label);
device.adapter = std::move(created.adapter);
{
std::lock_guard lock {mutex_};
devices_[id] = std::move(device);
}
selected_id_ = id;
device_panel_.refresh_license();
}
void create_mouse() {
lvh::CreateMouseOptions options;
options.profile = lvh::profiles::mouse();
options.stable_id = std::format("libvirtualhid-control-mouse-{}", next_metadata_index_++);
auto created = runtime_->create_mouse(options);
if (!created) {
error_panel_.show(created.status.message());
return;
}
const auto id = created.mouse->device_id();
ControlledMouse device;
device.profile_label = "Mouse";
device.mouse = std::move(created.mouse);
{
std::lock_guard lock {mutex_};
mice_[id] = std::move(device);
}
selected_id_ = id;
device_panel_.refresh_license();
}
void reset_selected_device() {
auto status = lvh::OperationStatus::success();
auto reset_id = lvh::DeviceId {0};
{
std::lock_guard lock {mutex_};
reset_id = selected_id_;
if (auto *device = selected_device_locked(); device != nullptr) {
status = device->adapter->set_state({});
} else if (auto *mouse = selected_mouse_locked(); mouse != nullptr) {
for (std::size_t index = 0; index < mouse->buttons.size(); ++index) {
if (!mouse->buttons[index]) {
continue;
}
const auto release_status = mouse->mouse->button(mouse_button_choices[index].button, false);
if (release_status.ok()) {
mouse->buttons[index] = false;
} else if (status.ok()) {
status = release_status;
}
}
} else {
return;
}
}
button_active_.fill(false);
mouse_control_panel_.forget_device(reset_id);
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void remove_selected_device() {
std::unique_ptr<lvh::GamepadStateAdapter> adapter;
std::unique_ptr<lvh::Mouse> mouse;
auto removed_id = lvh::DeviceId {0};
{
std::lock_guard lock {mutex_};
if (selected_id_ == 0) {
return;
}
removed_id = selected_id_;
if (const auto gamepad_iter = devices_.find(selected_id_); gamepad_iter != devices_.end()) {
adapter = std::move(gamepad_iter->second.adapter);
devices_.erase(gamepad_iter);
} else if (const auto mouse_iter = mice_.find(selected_id_); mouse_iter != mice_.end()) {
mouse = std::move(mouse_iter->second.mouse);
mice_.erase(mouse_iter);
} else {
return;
}
selected_id_ = first_device_id(devices_, mice_);
}
button_active_.fill(false);
mouse_control_panel_.forget_device(removed_id);
auto status = lvh::OperationStatus::success();
if (adapter != nullptr) {
status = adapter->close();
} else if (mouse != nullptr) {
status = mouse->close();
}
if (!status.ok()) {
error_panel_.show(status.message());
}
device_panel_.refresh_license();
}
void remove_all_devices() {
const auto handles = take_all_devices();
button_active_.fill(false);
mouse_control_panel_.reset();
close_devices(handles, true);
device_panel_.refresh_license();
}
void submit_mouse_event(lvh::DeviceId id, const lvh::MouseEvent &event) {
auto status = lvh::OperationStatus::success();
{
std::lock_guard lock {mutex_};
const auto iter = mice_.find(id);
if (iter == mice_.end() || iter->second.mouse == nullptr) {
return;
}
auto &device = iter->second;
status = device.mouse->submit(event);
if (status.ok() && event.kind == lvh::MouseEventKind::button) {
for (std::size_t index = 0; index < mouse_button_choices.size(); ++index) {
if (mouse_button_choices[index].button == event.button) {
device.buttons[index] = event.pressed;
break;
}
}
}
}
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void toggle_selected_button(std::size_t index) {
auto pressed = false;
{
std::lock_guard lock {mutex_};
const auto *device = selected_device_locked();
if (device == nullptr || index >= button_choices.size()) {
return;
}
pressed = !device->adapter->state().buttons.test(button_choices[index].button);
}
set_selected_button(index, pressed);
}
void set_selected_button(std::size_t index, bool pressed) {
auto status = lvh::OperationStatus::success();
{
std::lock_guard lock {mutex_};
auto *device = selected_device_locked();
if (device == nullptr || index >= button_choices.size()) {
return;
}
status = device->adapter->set_button(button_choices[index].button, pressed);
}
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void handle_button_lock_changed() {
button_active_.fill(false);
if (lock_buttons_) {
return;
}
auto status = lvh::OperationStatus::success();
{
std::lock_guard lock {mutex_};
auto *device = selected_device_locked();
if (device == nullptr) {
return;
}
auto state = device->adapter->state();
state.buttons.clear();
status = device->adapter->set_state(state);
}
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void set_selected_axis(std::size_t index, int position) {
auto status = lvh::OperationStatus::success();
{
std::lock_guard lock {mutex_};
auto *device = selected_device_locked();
if (device == nullptr) {
return;
}
auto state = device->adapter->state();
const auto value = slider_to_float(position);
switch (index) {
case 0:
state.left_stick.x = value;
status = device->adapter->set_left_stick(state.left_stick);
break;
case 1:
state.left_stick.y = value;
status = device->adapter->set_left_stick(state.left_stick);
break;
case 2:
state.right_stick.x = value;
status = device->adapter->set_right_stick(state.right_stick);
break;
case 3:
state.right_stick.y = value;
status = device->adapter->set_right_stick(state.right_stick);
break;
case 4:
status = device->adapter->set_left_trigger(value);
break;
case 5:
status = device->adapter->set_right_trigger(value);
break;
default:
break;
}
}
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void set_selected_battery_from_controls() {
if (battery_state_index_ < 0 || static_cast<std::size_t>(battery_state_index_) >= battery_choices.size()) {
return;
}
lvh::GamepadBattery battery;
battery.state = battery_choices[static_cast<std::size_t>(battery_state_index_)].state;
if (battery.state == lvh::GamepadBatteryState::full) {
battery_percentage_ = 100;
}
battery.percentage = static_cast<std::uint8_t>(std::clamp(battery_percentage_, 0, 100));
auto status = lvh::OperationStatus::success();
{
std::lock_guard lock {mutex_};
auto *device = selected_device_locked();
if (device == nullptr) {
return;
}
status = device->adapter->set_battery(battery);
}
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void clear_selected_battery() {
auto status = lvh::OperationStatus::success();
{
std::lock_guard lock {mutex_};
auto *device = selected_device_locked();
if (device == nullptr) {
return;
}
status = device->adapter->clear_battery();
}
if (!status.ok()) {
error_panel_.show(status.message());
}
}
void record_output(lvh::DeviceId id, const lvh::GamepadOutput &output) {
std::lock_guard lock {mutex_};
const auto iter = devices_.find(id);
if (iter == devices_.end()) {
return;
}
lvh::tools::virtualhid_control::record_output(
iter->second,
output,
next_output_sequence_,
max_output_events_
);
}
void close_all_devices() {
const auto handles = take_all_devices();
close_devices(handles, false);
}
DeviceHandles take_all_devices() {
DeviceHandles handles;
std::lock_guard lock {mutex_};
for (auto &[id, device] : devices_) {
handles.gamepads.push_back(std::move(device.adapter));
}
for (auto &[id, device] : mice_) {
handles.mice.push_back(std::move(device.mouse));
}
devices_.clear();
mice_.clear();
selected_id_ = 0;
return handles;
}
void close_devices(const DeviceHandles &handles, bool report_errors) {
std::optional<std::string> first_error;
for (const auto &adapter : handles.gamepads) {
if (adapter) {
if (const auto status = adapter->close(); !status.ok() && report_errors && !first_error) {
first_error = std::string {status.message()};
}
}
}
for (const auto &mouse : handles.mice) {
if (mouse) {
if (const auto status = mouse->close(); !status.ok() && report_errors && !first_error) {
first_error = std::string {status.message()};
}
}
}
if (first_error) {
error_panel_.show(*first_error);
}
}
ControlledGamepad *selected_device_locked() {
if (selected_id_ == 0) {
return nullptr;
}
const auto iter = devices_.find(selected_id_);
if (iter == devices_.end()) {
return nullptr;
}
return &iter->second;
}
const ControlledGamepad *selected_device_locked() const {
if (selected_id_ == 0) {
return nullptr;
}
const auto iter = devices_.find(selected_id_);
if (iter == devices_.end()) {
return nullptr;
}
return &iter->second;
}
ControlledMouse *selected_mouse_locked() {
if (selected_id_ == 0) {
return nullptr;
}
const auto iter = mice_.find(selected_id_);
if (iter == mice_.end()) {
return nullptr;
}
return &iter->second;
}
const ControlledMouse *selected_mouse_locked() const {
if (selected_id_ == 0) {
return nullptr;
}
const auto iter = mice_.find(selected_id_);
if (iter == mice_.end()) {
return nullptr;
}
return &iter->second;
}
std::unique_ptr<lvh::Runtime> runtime_;
mutable std::mutex mutex_;
std::map<lvh::DeviceId, ControlledGamepad> devices_;
std::map<lvh::DeviceId, ControlledMouse> mice_;
lvh::DeviceId selected_id_ = 0;
bool lock_buttons_ = false;
std::array<bool, button_choices.size()> button_active_ {};
int battery_state_index_ = battery_choice_index(lvh::GamepadBatteryState::full);
int battery_percentage_ = 100;
std::uint64_t next_metadata_index_ = 0;
std::uint64_t next_output_sequence_ = 1;
DevicePanel device_panel_;
MouseControlPanel mouse_control_panel_;
ErrorPanel error_panel_;
static constexpr std::size_t max_output_events_ = 50;
};
int run_control_ui() {
if (!SDL_Init(SDL_INIT_VIDEO)) {
SDL_Log("SDL_Init failed: %s", SDL_GetError());
return 1;
}
auto main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
if (main_scale <= 0.0F) {
main_scale = 1.0F;
}
constexpr auto base_width = 860;
constexpr auto base_height = 760;
constexpr auto minimum_width = 600;
constexpr auto minimum_height = 700;
const auto window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
auto *window = SDL_CreateWindow(
"libvirtualhid control",
scaled_window_dimension(base_width, main_scale),
scaled_window_dimension(base_height, main_scale),
window_flags
);
if (window == nullptr) {
SDL_Log("SDL_CreateWindow failed: %s", SDL_GetError());
SDL_Quit();
return 1;
}
if (!SDL_SetWindowMinimumSize(
window,
scaled_window_dimension(minimum_width, main_scale),
scaled_window_dimension(minimum_height, main_scale)
)) {
SDL_Log("SDL_SetWindowMinimumSize failed: %s", SDL_GetError());
}
auto *renderer = SDL_CreateRenderer(window, nullptr);
if (renderer == nullptr) {
SDL_Log("SDL_CreateRenderer failed: %s", SDL_GetError());
SDL_DestroyWindow(window);
SDL_Quit();
return 1;
}
SDL_SetRenderVSync(renderer, 1);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
SDL_ShowWindow(window);
IMGUI_CHECKVERSION();
ImGui::CreateContext();
auto &io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
// The tool creates virtual gamepads that SDL can see, so gamepad navigation would feed back into the UI.
io.IniFilename = nullptr;
ImGui::StyleColorsDark();
auto &style = ImGui::GetStyle();
style.ScaleAllSizes(main_scale);
style.FontScaleDpi = main_scale;
ImGui_ImplSDL3_InitForSDLRenderer(window, renderer);
ImGui_ImplSDLRenderer3_Init(renderer);
ControlApp app;
auto done = false;
while (!done) {
SDL_Event event;
while (SDL_PollEvent(&event)) {
ImGui_ImplSDL3_ProcessEvent(&event);
if (event.type == SDL_EVENT_QUIT) {
done = true;
}
if (event.type == SDL_EVENT_WINDOW_CLOSE_REQUESTED && event.window.windowID == SDL_GetWindowID(window)) {
done = true;
}
}
app.tick();
if ((SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED) != 0U) {
SDL_Delay(10);
continue;
}
ImGui_ImplSDLRenderer3_NewFrame();
ImGui_ImplSDL3_NewFrame();
ImGui::NewFrame();
app.render();
ImGui::Render();
SDL_SetRenderScale(renderer, io.DisplayFramebufferScale.x, io.DisplayFramebufferScale.y);
SDL_SetRenderDrawColorFloat(renderer, 0.08F, 0.08F, 0.09F, 1.0F);
SDL_RenderClear(renderer);
ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), renderer);
SDL_RenderPresent(renderer);
}
ImGui_ImplSDLRenderer3_Shutdown();
ImGui_ImplSDL3_Shutdown();
ImGui::DestroyContext();
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
} // namespace lvh::tools::virtualhid_control::ui
/**
* @brief Run the libvirtualhid diagnostic control UI.
* @return Process exit code.
*/
int main(int, char **) {
return lvh::tools::virtualhid_control::ui::run_control_ui();
}
Reference in new issue View Git Blame Copy Permalink