adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Trackball Pointer Mode & driver rewrite (#453)

Browse Source
This commit is contained in:
Shadowtrance
2026-01-24 02:30:13 +10:00
committed by GitHub
parent 01ffe420eb
commit b8214fd378
15 changed files with 850 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Source/Tactility.cpp
+6
View File
@@ -103,6 +103,9 @@ namespace app {
namespace systeminfo { extern const AppManifest manifest; }
namespace timedatesettings { extern const AppManifest manifest; }
namespace timezone { extern const AppManifest manifest; }
#if defined(ESP_PLATFORM) && defined(CONFIG_TT_DEVICE_LILYGO_TDECK)
namespace trackballsettings { extern const AppManifest manifest; }
#endif
namespace usbsettings { extern const AppManifest manifest; }
namespace wifiapsettings { extern const AppManifest manifest; }
namespace wificonnect { extern const AppManifest manifest; }
@@ -146,6 +149,9 @@ static void registerInternalApps() {
addAppManifest(app::systeminfo::manifest);
addAppManifest(app::timedatesettings::manifest);
addAppManifest(app::timezone::manifest);
#if defined(ESP_PLATFORM) && defined(CONFIG_TT_DEVICE_LILYGO_TDECK)
addAppManifest(app::trackballsettings::manifest);
#endif
addAppManifest(app::wifiapsettings::manifest);
addAppManifest(app::wificonnect::manifest);
addAppManifest(app::wifimanage::manifest);
Tactility/Source/app/keyboard/KeyboardSettings.cpp
+17 -46
View File
@@ -13,14 +13,21 @@ namespace keyboardbacklight {
bool setBrightness(uint8_t brightness);
}
namespace trackball {
void setEnabled(bool enabled);
}
namespace tt::app::keyboardsettings {
constexpr auto* TAG = "KeyboardSettings";
// Shared timeout values: 15s, 30s, 1m, 2m, 5m, Never (0)
static constexpr uint32_t TIMEOUT_VALUES_MS[] = {15000, 30000, 60000, 120000, 300000, 0};
static constexpr size_t TIMEOUT_DEFAULT_IDX = 2; // 1 minute
static uint32_t timeoutMsToIndex(uint32_t ms) {
for (size_t i = 0; i < sizeof(TIMEOUT_VALUES_MS) / sizeof(TIMEOUT_VALUES_MS[0]); ++i) {
if (TIMEOUT_VALUES_MS[i] == ms) return static_cast<uint32_t>(i);
}
return TIMEOUT_DEFAULT_IDX;
}
static void applyKeyboardBacklight(bool enabled, uint8_t brightness) {
keyboardbacklight::setBrightness(enabled ? brightness : 0);
}
@@ -30,7 +37,6 @@ class KeyboardSettingsApp final : public App {
settings::keyboard::KeyboardSettings kbSettings;
bool updated = false;
lv_obj_t* switchBacklight = nullptr;
lv_obj_t* switchTrackball = nullptr;
lv_obj_t* sliderBrightness = nullptr;
lv_obj_t* switchTimeoutEnable = nullptr;
lv_obj_t* timeoutDropdown = nullptr;
@@ -57,14 +63,6 @@ class KeyboardSettingsApp final : public App {
}
}
static void onTrackballSwitch(lv_event_t* e) {
auto* app = static_cast<KeyboardSettingsApp*>(lv_event_get_user_data(e));
bool enabled = lv_obj_has_state(app->switchTrackball, LV_STATE_CHECKED);
app->kbSettings.trackballEnabled = enabled;
app->updated = true;
trackball::setEnabled(enabled);
}
static void onTimeoutEnableSwitch(lv_event_t* e) {
auto* app = static_cast<KeyboardSettingsApp*>(lv_event_get_user_data(e));
bool enabled = lv_obj_has_state(app->switchTimeoutEnable, LV_STATE_CHECKED);
@@ -83,17 +81,16 @@ class KeyboardSettingsApp final : public App {
auto* app = static_cast<KeyboardSettingsApp*>(lv_event_get_user_data(event));
auto* dropdown = static_cast<lv_obj_t*>(lv_event_get_target(event));
uint32_t idx = lv_dropdown_get_selected(dropdown);
// Map dropdown index to ms: 0=15s,1=30s,2=1m,3=2m,4=5m,5=Never
static const uint32_t values_ms[] = {15000, 30000, 60000, 120000, 300000, 0};
if (idx < (sizeof(values_ms)/sizeof(values_ms[0]))) {
app->kbSettings.backlightTimeoutMs = values_ms[idx];
app->updated = true;
if (idx < (sizeof(TIMEOUT_VALUES_MS) / sizeof(TIMEOUT_VALUES_MS[0]))) {
app->kbSettings.backlightTimeoutMs = TIMEOUT_VALUES_MS[idx];
app->updated = true;
}
}
public:
void onShow(AppContext& app, lv_obj_t* parent) override {
kbSettings = settings::keyboard::loadOrGetDefault();
updated = false;
lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_row(parent, 0, LV_STATE_DEFAULT);
@@ -136,20 +133,6 @@ public:
if (!kbSettings.backlightEnabled) lv_obj_add_state(sliderBrightness, LV_STATE_DISABLED);
lv_obj_add_event_cb(sliderBrightness, onBrightnessChanged, LV_EVENT_VALUE_CHANGED, this);
// Trackball toggle
auto* tb_wrapper = lv_obj_create(main_wrapper);
lv_obj_set_size(tb_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(tb_wrapper, 0, LV_STATE_DEFAULT);
lv_obj_set_style_border_width(tb_wrapper, 0, LV_STATE_DEFAULT);
auto* tb_label = lv_label_create(tb_wrapper);
lv_label_set_text(tb_label, "Trackball");
lv_obj_align(tb_label, LV_ALIGN_LEFT_MID, 0, 0);
switchTrackball = lv_switch_create(tb_wrapper);
if (kbSettings.trackballEnabled) lv_obj_add_state(switchTrackball, LV_STATE_CHECKED);
lv_obj_align(switchTrackball, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(switchTrackball, onTrackballSwitch, LV_EVENT_VALUE_CHANGED, this);
// Backlight timeout enable
auto* to_enable_wrapper = lv_obj_create(main_wrapper);
lv_obj_set_size(to_enable_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
@@ -181,20 +164,7 @@ public:
lv_obj_set_style_border_width(timeoutDropdown, 1, LV_PART_MAIN);
lv_obj_add_event_cb(timeoutDropdown, onTimeoutChanged, LV_EVENT_VALUE_CHANGED, this);
// Initialize dropdown selection from settings
uint32_t ms = kbSettings.backlightTimeoutMs;
uint32_t idx = 2; // default 1 minute
if (ms == 15000) idx = 0;
else if (ms == 30000)
idx = 1;
else if (ms == 60000)
idx = 2;
else if (ms == 120000)
idx = 3;
else if (ms == 300000)
idx = 4;
else if (ms == 0)
idx = 5;
lv_dropdown_set_selected(timeoutDropdown, idx);
lv_dropdown_set_selected(timeoutDropdown, timeoutMsToIndex(kbSettings.backlightTimeoutMs));
if (!kbSettings.backlightTimeoutEnabled) {
lv_obj_add_state(timeoutDropdown, LV_STATE_DISABLED);
}
@@ -204,6 +174,7 @@ public:
if (updated) {
const auto copy = kbSettings;
getMainDispatcher().dispatch([copy]{ settings::keyboard::save(copy); });
updated = false;
}
}
};
Tactility/Source/app/trackball/TrackballSettings.cpp
+219
View File
@@ -0,0 +1,219 @@
#ifdef ESP_PLATFORM
#include <Tactility/Tactility.h>
#include <Tactility/settings/TrackballSettings.h>
#include <Tactility/Assets.h>
#include <Tactility/lvgl/Toolbar.h>
#include <lvgl.h>
// Forward declare driver functions
namespace trackball {
void setEnabled(bool enabled);
enum class Mode { Encoder, Pointer };
void setMode(Mode mode);
void setEncoderSensitivity(uint8_t sensitivity);
void setPointerSensitivity(uint8_t sensitivity);
}
namespace tt::app::trackballsettings {
constexpr auto* TAG = "TrackballSettings";
static trackball::Mode toDriverMode(settings::trackball::TrackballMode mode) {
switch (mode) {
case settings::trackball::TrackballMode::Encoder: return trackball::Mode::Encoder;
case settings::trackball::TrackballMode::Pointer: return trackball::Mode::Pointer;
}
return trackball::Mode::Encoder; // default
}
// Convert settings enum to dropdown index (dropdown order: Encoder=0, Pointer=1)
static uint32_t modeToDropdownIndex(settings::trackball::TrackballMode mode) {
switch (mode) {
case settings::trackball::TrackballMode::Encoder: return 0;
case settings::trackball::TrackballMode::Pointer: return 1;
}
return 0; // default to Encoder
}
class TrackballSettingsApp final : public App {
settings::trackball::TrackballSettings tbSettings;
bool updated = false;
lv_obj_t* switchTrackball = nullptr;
lv_obj_t* trackballModeDropdown = nullptr;
lv_obj_t* encoderSensitivitySlider = nullptr;
lv_obj_t* pointerSensitivitySlider = nullptr;
static void onTrackballSwitch(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
bool enabled = lv_obj_has_state(app->switchTrackball, LV_STATE_CHECKED);
app->tbSettings.trackballEnabled = enabled;
app->updated = true;
trackball::setEnabled(enabled);
// Enable/disable controls based on trackball state
if (enabled) {
if (app->trackballModeDropdown) lv_obj_clear_state(app->trackballModeDropdown, LV_STATE_DISABLED);
if (app->encoderSensitivitySlider) lv_obj_clear_state(app->encoderSensitivitySlider, LV_STATE_DISABLED);
if (app->pointerSensitivitySlider) lv_obj_clear_state(app->pointerSensitivitySlider, LV_STATE_DISABLED);
} else {
if (app->trackballModeDropdown) lv_obj_add_state(app->trackballModeDropdown, LV_STATE_DISABLED);
if (app->encoderSensitivitySlider) lv_obj_add_state(app->encoderSensitivitySlider, LV_STATE_DISABLED);
if (app->pointerSensitivitySlider) lv_obj_add_state(app->pointerSensitivitySlider, LV_STATE_DISABLED);
}
}
static void onTrackballModeChanged(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
uint32_t selected = lv_dropdown_get_selected(app->trackballModeDropdown);
// Validate selection matches expected enum values (dropdown order: Encoder=0, Pointer=1)
settings::trackball::TrackballMode mode;
switch (selected) {
case 0: mode = settings::trackball::TrackballMode::Encoder; break;
case 1: mode = settings::trackball::TrackballMode::Pointer; break;
default: return; // Invalid selection, ignore
}
app->tbSettings.trackballMode = mode;
app->updated = true;
// Apply mode change immediately
trackball::setMode(toDriverMode(mode));
}
static void onEncoderSensitivityChanged(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
int32_t value = lv_slider_get_value(app->encoderSensitivitySlider);
app->tbSettings.encoderSensitivity = static_cast<uint8_t>(value);
app->updated = true;
// Apply immediately
trackball::setEncoderSensitivity(static_cast<uint8_t>(value));
}
static void onPointerSensitivityChanged(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
int32_t value = lv_slider_get_value(app->pointerSensitivitySlider);
app->tbSettings.pointerSensitivity = static_cast<uint8_t>(value);
app->updated = true;
// Apply immediately
trackball::setPointerSensitivity(static_cast<uint8_t>(value));
}
public:
void onShow(AppContext& app, lv_obj_t* parent) override {
tbSettings = settings::trackball::loadOrGetDefault();
auto ui_scale = hal::getConfiguration()->uiScale;
updated = false;
lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_row(parent, 0, LV_STATE_DEFAULT);
lv_obj_t* toolbar = lvgl::toolbar_create(parent, app);
switchTrackball = lvgl::toolbar_add_switch_action(toolbar);
lv_obj_add_event_cb(switchTrackball, onTrackballSwitch, LV_EVENT_VALUE_CHANGED, this);
if (tbSettings.trackballEnabled) lv_obj_add_state(switchTrackball, LV_STATE_CHECKED);
auto* main_wrapper = lv_obj_create(parent);
lv_obj_set_flex_flow(main_wrapper, LV_FLEX_FLOW_COLUMN);
lv_obj_set_width(main_wrapper, LV_PCT(100));
lv_obj_set_flex_grow(main_wrapper, 1);
// Trackball mode dropdown
auto* tb_mode_wrapper = lv_obj_create(main_wrapper);
lv_obj_set_size(tb_mode_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(tb_mode_wrapper, 0, LV_STATE_DEFAULT);
lv_obj_set_style_border_width(tb_mode_wrapper, 0, LV_STATE_DEFAULT);
auto* tb_mode_label = lv_label_create(tb_mode_wrapper);
lv_label_set_text(tb_mode_label, "Mode");
lv_obj_align(tb_mode_label, LV_ALIGN_LEFT_MID, 0, 0);
trackballModeDropdown = lv_dropdown_create(tb_mode_wrapper);
lv_dropdown_set_options(trackballModeDropdown, "Encoder\nPointer");
lv_obj_align(trackballModeDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_set_style_border_color(trackballModeDropdown, lv_color_hex(0xFAFAFA), LV_PART_MAIN);
lv_obj_set_style_border_width(trackballModeDropdown, 1, LV_PART_MAIN);
lv_dropdown_set_selected(trackballModeDropdown, modeToDropdownIndex(tbSettings.trackballMode));
lv_obj_add_event_cb(trackballModeDropdown, onTrackballModeChanged, LV_EVENT_VALUE_CHANGED, this);
// Disable dropdown if trackball is disabled
if (!tbSettings.trackballEnabled) {
lv_obj_add_state(trackballModeDropdown, LV_STATE_DISABLED);
}
// Encoder sensitivity slider
auto* enc_sens_wrapper = lv_obj_create(main_wrapper);
lv_obj_set_size(enc_sens_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_style_pad_hor(enc_sens_wrapper, 0, LV_STATE_DEFAULT);
lv_obj_set_style_border_width(enc_sens_wrapper, 0, LV_STATE_DEFAULT);
if (ui_scale != hal::UiScale::Smallest) {
lv_obj_set_style_pad_ver(enc_sens_wrapper, 4, LV_STATE_DEFAULT);
}
auto* enc_sens_label = lv_label_create(enc_sens_wrapper);
lv_label_set_text(enc_sens_label, "Encoder Speed");
lv_obj_align(enc_sens_label, LV_ALIGN_LEFT_MID, 0, 0);
encoderSensitivitySlider = lv_slider_create(enc_sens_wrapper);
lv_slider_set_range(encoderSensitivitySlider, 1, 10);
lv_slider_set_value(encoderSensitivitySlider, tbSettings.encoderSensitivity, LV_ANIM_OFF);
lv_obj_set_width(encoderSensitivitySlider, LV_PCT(50));
lv_obj_align(encoderSensitivitySlider, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(encoderSensitivitySlider, onEncoderSensitivityChanged, LV_EVENT_VALUE_CHANGED, this);
if (!tbSettings.trackballEnabled) {
lv_obj_add_state(encoderSensitivitySlider, LV_STATE_DISABLED);
}
// Pointer sensitivity slider
auto* ptr_sens_wrapper = lv_obj_create(main_wrapper);
lv_obj_set_size(ptr_sens_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_style_pad_hor(ptr_sens_wrapper, 0, LV_STATE_DEFAULT);
lv_obj_set_style_border_width(ptr_sens_wrapper, 0, LV_STATE_DEFAULT);
if (ui_scale != hal::UiScale::Smallest) {
lv_obj_set_style_pad_ver(ptr_sens_wrapper, 4, LV_STATE_DEFAULT);
}
auto* ptr_sens_label = lv_label_create(ptr_sens_wrapper);
lv_label_set_text(ptr_sens_label, "Pointer Speed");
lv_obj_align(ptr_sens_label, LV_ALIGN_LEFT_MID, 0, 0);
pointerSensitivitySlider = lv_slider_create(ptr_sens_wrapper);
lv_slider_set_range(pointerSensitivitySlider, 1, 10);
lv_slider_set_value(pointerSensitivitySlider, tbSettings.pointerSensitivity, LV_ANIM_OFF);
lv_obj_set_width(pointerSensitivitySlider, LV_PCT(50));
lv_obj_align(pointerSensitivitySlider, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(pointerSensitivitySlider, onPointerSensitivityChanged, LV_EVENT_VALUE_CHANGED, this);
if (!tbSettings.trackballEnabled) {
lv_obj_add_state(pointerSensitivitySlider, LV_STATE_DISABLED);
}
}
void onHide(TT_UNUSED AppContext& app) override {
if (updated) {
const auto copy = tbSettings;
getMainDispatcher().dispatch([copy]{ settings::trackball::save(copy); });
updated = false;
}
}
};
extern const AppManifest manifest = {
.appId = "TrackballSettings",
.appName = "Trackball",
.appIcon = TT_ASSETS_APP_ICON_SETTINGS,
.appCategory = Category::Settings,
.createApp = create<TrackballSettingsApp>
};
}
#endif
Tactility/Source/settings/KeyboardSettings.cpp
+1 -6
View File
@@ -9,7 +9,6 @@ namespace tt::settings::keyboard {
constexpr auto* SETTINGS_FILE = "/data/settings/keyboard.properties";
constexpr auto* KEY_BACKLIGHT_ENABLED = "backlightEnabled";
constexpr auto* KEY_BACKLIGHT_BRIGHTNESS = "backlightBrightness";
constexpr auto* KEY_TRACKBALL_ENABLED = "trackballEnabled";
constexpr auto* KEY_BACKLIGHT_TIMEOUT_ENABLED = "backlightTimeoutEnabled";
constexpr auto* KEY_BACKLIGHT_TIMEOUT_MS = "backlightTimeoutMs";
@@ -21,15 +20,13 @@ bool load(KeyboardSettings& settings) {
auto bl_enabled = map.find(KEY_BACKLIGHT_ENABLED);
auto bl_brightness = map.find(KEY_BACKLIGHT_BRIGHTNESS);
auto tb_enabled = map.find(KEY_TRACKBALL_ENABLED);
auto bl_timeout_enabled = map.find(KEY_BACKLIGHT_TIMEOUT_ENABLED);
auto bl_timeout_ms = map.find(KEY_BACKLIGHT_TIMEOUT_MS);
settings.backlightEnabled = (bl_enabled != map.end()) ? (bl_enabled->second == "1" || bl_enabled->second == "true" || bl_enabled->second == "True") : true;
settings.backlightBrightness = (bl_brightness != map.end()) ? static_cast<uint8_t>(std::stoi(bl_brightness->second)) : 127;
settings.trackballEnabled = (tb_enabled != map.end()) ? (tb_enabled->second == "1" || tb_enabled->second == "true" || tb_enabled->second == "True") : true;
settings.backlightTimeoutEnabled = (bl_timeout_enabled != map.end()) ? (bl_timeout_enabled->second == "1" || bl_timeout_enabled->second == "true" || bl_timeout_enabled->second == "True") : true;
settings.backlightTimeoutMs = (bl_timeout_ms != map.end()) ? static_cast<uint32_t>(std::stoul(bl_timeout_ms->second)) : 30000; // Default 30 seconds
settings.backlightTimeoutMs = (bl_timeout_ms != map.end()) ? static_cast<uint32_t>(std::stoul(bl_timeout_ms->second)) : 60000; // Default 60 seconds
return true;
}
@@ -38,7 +35,6 @@ KeyboardSettings getDefault() {
return KeyboardSettings{
.backlightEnabled = true,
.backlightBrightness = 127,
.trackballEnabled = true,
.backlightTimeoutEnabled = true,
.backlightTimeoutMs = 60000 // 60 seconds default
};
@@ -56,7 +52,6 @@ bool save(const KeyboardSettings& settings) {
std::map<std::string, std::string> map;
map[KEY_BACKLIGHT_ENABLED] = settings.backlightEnabled ? "1" : "0";
map[KEY_BACKLIGHT_BRIGHTNESS] = std::to_string(settings.backlightBrightness);
map[KEY_TRACKBALL_ENABLED] = settings.trackballEnabled ? "1" : "0";
map[KEY_BACKLIGHT_TIMEOUT_ENABLED] = settings.backlightTimeoutEnabled ? "1" : "0";
map[KEY_BACKLIGHT_TIMEOUT_MS] = std::to_string(settings.backlightTimeoutMs);
return file::savePropertiesFile(SETTINGS_FILE, map);
Tactility/Source/settings/TrackballSettings.cpp
+86
View File
@@ -0,0 +1,86 @@
#include <Tactility/settings/TrackballSettings.h>
#include <Tactility/file/PropertiesFile.h>
#include <map>
#include <string>
#include <algorithm>
namespace tt::settings::trackball {
constexpr auto* SETTINGS_FILE = "/data/settings/trackball.properties";
constexpr auto* KEY_TRACKBALL_ENABLED = "trackballEnabled";
constexpr auto* KEY_TRACKBALL_MODE = "trackballMode";
constexpr auto* KEY_ENCODER_SENSITIVITY = "encoderSensitivity";
constexpr auto* KEY_POINTER_SENSITIVITY = "pointerSensitivity";
constexpr uint8_t MIN_ENCODER_SENSITIVITY = 1;
constexpr uint8_t MAX_ENCODER_SENSITIVITY = 10;
constexpr uint8_t MIN_POINTER_SENSITIVITY = 1;
constexpr uint8_t MAX_POINTER_SENSITIVITY = 10;
bool load(TrackballSettings& settings) {
std::map<std::string, std::string> map;
if (!file::loadPropertiesFile(SETTINGS_FILE, map)) {
return false;
}
auto tb_enabled = map.find(KEY_TRACKBALL_ENABLED);
auto tb_mode = map.find(KEY_TRACKBALL_MODE);
auto enc_sens = map.find(KEY_ENCODER_SENSITIVITY);
auto ptr_sens = map.find(KEY_POINTER_SENSITIVITY);
// Safe integer parsing without exceptions
auto safeParseUint8 = [](const std::string& str, uint8_t defaultVal) -> uint8_t {
if (str.empty()) return defaultVal;
unsigned int val = 0;
for (char c : str) {
if (c < '0' || c > '9') return defaultVal;
if (val > 25) return defaultVal; // Early exit: val*10+9 would exceed 255
val = val * 10 + (c - '0');
if (val > 255) return defaultVal;
}
return static_cast<uint8_t>(val);
};
auto isTrueValue = [](const std::string& s) {
return s == "1" || s == "true" || s == "True" || s == "TRUE";
};
settings.trackballEnabled = (tb_enabled != map.end()) ? isTrueValue(tb_enabled->second) : true;
settings.trackballMode = (tb_mode != map.end() && tb_mode->second == "1") ? TrackballMode::Pointer : TrackballMode::Encoder;
settings.encoderSensitivity = (enc_sens != map.end()) ? safeParseUint8(enc_sens->second, MIN_ENCODER_SENSITIVITY) : MIN_ENCODER_SENSITIVITY;
settings.pointerSensitivity = (ptr_sens != map.end()) ? safeParseUint8(ptr_sens->second, MAX_POINTER_SENSITIVITY) : MAX_POINTER_SENSITIVITY;
// Clamp values to valid ranges
settings.encoderSensitivity = std::clamp(settings.encoderSensitivity, MIN_ENCODER_SENSITIVITY, MAX_ENCODER_SENSITIVITY);
settings.pointerSensitivity = std::clamp(settings.pointerSensitivity, MIN_POINTER_SENSITIVITY, MAX_POINTER_SENSITIVITY);
return true;
}
TrackballSettings getDefault() {
return TrackballSettings{
.trackballEnabled = true,
.trackballMode = TrackballMode::Encoder,
.encoderSensitivity = MIN_ENCODER_SENSITIVITY,
.pointerSensitivity = MAX_POINTER_SENSITIVITY
};
}
TrackballSettings loadOrGetDefault() {
TrackballSettings s;
if (!load(s)) {
s = getDefault();
}
return s;
}
bool save(const TrackballSettings& settings) {
std::map<std::string, std::string> map;
map[KEY_TRACKBALL_ENABLED] = settings.trackballEnabled ? "1" : "0";
map[KEY_TRACKBALL_MODE] = (settings.trackballMode == TrackballMode::Pointer) ? "1" : "0";
map[KEY_ENCODER_SENSITIVITY] = std::to_string(std::clamp(settings.encoderSensitivity, MIN_ENCODER_SENSITIVITY, MAX_ENCODER_SENSITIVITY));
map[KEY_POINTER_SENSITIVITY] = std::to_string(std::clamp(settings.pointerSensitivity, MIN_POINTER_SENSITIVITY, MAX_POINTER_SENSITIVITY));
return file::savePropertiesFile(SETTINGS_FILE, map);
}
}