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

Trackball rewrite (#600)

Browse Source 
- Implement generic trackball settings
- Refactor T-Deck trackball driver into generic driver at `Drivers/gpio-trackball-module`
- Automatically bind/unbind trackball devices with LVGL
- Automatically load settings for trackball devices on boot
This commit is contained in:
Ken Van Hoeylandt
2026-07-30 13:38:19 +02:00
committed by GitHub
parent de6fc3b346
commit c729e8340f
39 changed files with 1194 additions and 666 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Source/app/trackball/TrackballSettings.cpp
+81 -45
View File
@@ -1,59 +1,61 @@
#ifdef ESP_PLATFORM
#include <lvgl.h>
#include <lvgl/devices/device_context.h>
#include <lvgl/devices/trackball.h>
#include <lvgl/icons/shared.h>
#include <lvgl/lvgl.h>
#include <Tactility/Tactility.h>
#include <tactility/drivers/trackball.h>
#include <Tactility/Assets.h>
#include <Tactility/settings/TrackballSettings.h>
#include <Tactility/lvgl/Toolbar.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);
}
#include <Tactility/Tactility.h>
namespace tt::app::trackballsettings {
constexpr auto* TAG = "TrackballSettings";
static trackball::Mode toDriverMode(settings::trackball::TrackballMode mode) {
// Convert mode to dropdown index (dropdown order: Encoder=0, Pointer=1)
static uint32_t modeToDropdownIndex(LvglTrackballMode 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;
case LVGL_TRACKBALL_MODE_ENCODER: return 0;
case LVGL_TRACKBALL_MODE_POINTER: return 1;
}
return 0; // default to Encoder
}
class TrackballSettingsApp final : public App {
settings::trackball::TrackballSettings tbSettings;
LvglTrackballSettings tbSettings;
bool updated = false;
// The trackball indev currently bound by lvgl_devices_attach() at LVGL startup, if any -
// there's at most one at a time (see devices.c), so "first active trackball device" reduces
// to whatever is already attached.
lv_indev_t* trackballIndev = nullptr;
lv_obj_t* switchTrackball = nullptr;
lv_obj_t* trackballModeDropdown = nullptr;
lv_obj_t* encoderSensitivitySlider = nullptr;
lv_obj_t* pointerSensitivitySlider = nullptr;
void applyLive() {
if (trackballIndev == nullptr) {
return;
}
lvgl_lock();
lvgl_trackball_set_settings(trackballIndev, &tbSettings);
if (tbSettings.mode == LVGL_TRACKBALL_MODE_POINTER) {
lvgl_trackball_set_cursor_image(trackballIndev, TT_ASSETS_UI_CURSOR);
}
lvgl_unlock();
}
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->tbSettings.enabled = enabled;
app->updated = true;
trackball::setEnabled(enabled);
app->applyLive();
// Enable/disable controls based on trackball state
if (enabled) {
@@ -72,38 +74,57 @@ class TrackballSettingsApp final : public App {
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;
LvglTrackballMode mode;
switch (selected) {
case 0: mode = settings::trackball::TrackballMode::Encoder; break;
case 1: mode = settings::trackball::TrackballMode::Pointer; break;
case 0: mode = LVGL_TRACKBALL_MODE_ENCODER; break;
case 1: mode = LVGL_TRACKBALL_MODE_POINTER; break;
default: return; // Invalid selection, ignore
}
app->tbSettings.trackballMode = mode;
app->tbSettings.mode = mode;
app->updated = true;
// Apply mode change immediately
trackball::setMode(toDriverMode(mode));
app->applyLive();
}
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->tbSettings.encoder_sensitivity = static_cast<uint8_t>(value);
app->updated = true;
// Apply immediately
trackball::setEncoderSensitivity(static_cast<uint8_t>(value));
app->applyLive();
}
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->tbSettings.pointer_sensitivity = static_cast<uint8_t>(value);
app->updated = true;
// Apply immediately
trackball::setPointerSensitivity(static_cast<uint8_t>(value));
app->applyLive();
}
static lv_indev_t* findFirstTrackballIndev() {
lv_indev_t* indev = lv_indev_get_next(nullptr);
while (indev != nullptr) {
void* driver_data = lv_indev_get_driver_data(indev);
if (driver_data) {
LvglDeviceContext* context = static_cast<LvglDeviceContext*>(driver_data);
if (context->device) {
const DeviceType* device_type = device_get_type(context->device);
if (device_type == &TRACKBALL_TYPE) {
return indev;
}
}
}
indev = lv_indev_get_next(indev);
}
return nullptr;
}
public:
@@ -111,15 +132,32 @@ public:
tbSettings = settings::trackball::loadOrGetDefault();
auto ui_density = lvgl_get_ui_density();
updated = false;
trackballIndev = findFirstTrackballIndev();
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);
if (trackballIndev == nullptr) {
auto* wrapper = lv_obj_create(parent);
lv_obj_set_width(wrapper, LV_PCT(100));
lv_obj_set_flex_grow(wrapper, 1);
lv_obj_set_flex_flow(wrapper, LV_FLEX_FLOW_COLUMN);
lv_obj_set_flex_align(wrapper, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
auto* label = lv_label_create(wrapper);
lv_label_set_text(label, "No trackball device found");
return;
}
// The live indev may still be running with lvgl_trackball_settings_get_default() (it's
// bound at LVGL startup before persisted settings are known) - bring it in line with what
// this screen is about to display.
applyLive();
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);
if (tbSettings.enabled) 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);
@@ -139,11 +177,11 @@ public:
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_dropdown_set_selected(trackballModeDropdown, modeToDropdownIndex(tbSettings.trackballMode));
lv_dropdown_set_selected(trackballModeDropdown, modeToDropdownIndex(tbSettings.mode));
lv_obj_add_event_cb(trackballModeDropdown, onTrackballModeChanged, LV_EVENT_VALUE_CHANGED, this);
// Disable dropdown if trackball is disabled
if (!tbSettings.trackballEnabled) {
if (!tbSettings.enabled) {
lv_obj_add_state(trackballModeDropdown, LV_STATE_DISABLED);
}
@@ -162,12 +200,12 @@ public:
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_slider_set_value(encoderSensitivitySlider, tbSettings.encoder_sensitivity, 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) {
if (!tbSettings.enabled) {
lv_obj_add_state(encoderSensitivitySlider, LV_STATE_DISABLED);
}
@@ -186,12 +224,12 @@ public:
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_slider_set_value(pointerSensitivitySlider, tbSettings.pointer_sensitivity, 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) {
if (!tbSettings.enabled) {
lv_obj_add_state(pointerSensitivitySlider, LV_STATE_DISABLED);
}
}
@@ -214,5 +252,3 @@ extern const AppManifest manifest = {
};
}
#endif