feat: New advanced joystick mode on radio, improvements to Companion and Simulator joystick support (#3111)

* Allow switches on the connected radio to control switches in the simulator via the joystick interface.

* Merge configurable radio joystick interface from banyaszg.

* Add two more 'axis' channels to companion.

* Fix 6POS from USB joystick to simulator.

* Reduce data size.

* Fix build error on B&W radios.

* Add 'Companion' button mode to work with the button logic in the Companion app.

* Build Companion joystick setup layout at runtime.
Change #define names for simulator joystick.
Allow 15 axes and 32 buttons.
Initial support for trim sliders.

* Remove custom joystick button type for companion - use 3 buttons per switch in companion to control simulator switch state.

* Fix joystick constructor calls parameters. Connect some radio joystick trims to simulator widgets.

* Restore 'companion' button type to reduce number of buttons needed. Make trims work via buttons in USB joystick.

* Connect joystick trim buttons to simulator widgets.

* Use companion source names for trims.

* Add encode / decode of usb joystick custom settings to Companion.

* Convert to lvgl layouts.
Update language files.

* Fix generated YAML storage files.

* Fix initialisation error when editing button channel. Cleanup code.

* Fix rebase.

* Fix refresh of joystick channel list view after editing an entry.
Companion joystick config window uses two columns.

* Fix vertical joystick inversion bug.
Change stick axis labels.

---------

Co-authored-by: Phil Mitchell <phil.a.mitchell@gmail.com>
This commit is contained in:
philmoz
2023-03-22 10:31:29 +10:00
committed by GitHub
co-authored by Phil Mitchell
parent a1178f83a6
commit 661657feca
81 changed files with 3501 additions and 572 deletions
+3
View File
@@ -131,6 +131,9 @@ void menuModelSensor(event_t event);
void menuModelDisplay(event_t event);
void menuModelTemplates(event_t event);
void menuModelGVarOne(event_t event);
#if defined(USBJ_EX)
void menuModelUSBJoystick(event_t event);
#endif
static const MenuHandlerFunc menuTabModel[] = {
menuModelSelect,
+68 -1
View File
@@ -22,6 +22,10 @@
#include "opentx.h"
#include "mixer_scheduler.h"
#if defined(USBJ_EX)
#include "usb_joystick.h"
#endif
#if !defined(EEPROM)
#include "storage/sdcard_common.h"
#include "storage/modelslist.h"
@@ -193,6 +197,15 @@ enum MenuModelSetupItems {
ITEM_MODEL_SETUP_TRAINER_CHANNELS,
ITEM_MODEL_SETUP_TRAINER_PPM_PARAMS,
#endif
#if defined(USBJ_EX)
ITEM_MODEL_SETUP_USBJOYSTICK_LABEL,
ITEM_MODEL_SETUP_USBJOYSTICK_MODE,
ITEM_MODEL_SETUP_USBJOYSTICK_IF_MODE,
ITEM_MODEL_SETUP_USBJOYSTICK_CIRC_CUTOUT,
ITEM_MODEL_SETUP_USBJOYSTICK_CH_BUTTON,
ITEM_MODEL_SETUP_USBJOYSTICK_APPLY,
#endif
ITEM_MODEL_SETUP_LINES_COUNT
};
@@ -443,6 +456,25 @@ void editTimerCountdown(int timerIdx, coord_t y, LcdFlags attr, event_t event)
NUM_SWITCHES - 1, /* Switch warning */
#endif
#if defined(USBJ_EX)
inline uint8_t USB_JOYSTICK_EXTROW()
{
return (usbJoystickExtMode() ? (uint8_t)0 : HIDDEN_ROW);
}
inline uint8_t USB_JOYSTICK_APPLYROW()
{
if(!usbJoystickExtMode()) return HIDDEN_ROW;
if(usbJoystickSettingsChanged()) return (uint8_t)0;
return READONLY_ROW;
}
#define USB_JOYSTICK_ROWS LABEL(USBJoystick), (uint8_t)0, USB_JOYSTICK_EXTROW(), \
USB_JOYSTICK_EXTROW(), USB_JOYSTICK_EXTROW(), USB_JOYSTICK_APPLYROW()
#else
#define USB_JOYSTICK_ROWS
#endif
#if defined(FUNCTION_SWITCHES)
static const char* _fct_sw_start[] = { STR_CHAR_UP, STR_CHAR_DOWN, "=" };
#endif
@@ -491,7 +523,9 @@ void menuModelSetup(event_t event)
EXTRA_MODULE_ROWS
TRAINER_ROWS
TRAINER_ROWS,
USB_JOYSTICK_ROWS
});
MENU_CHECK(menuTabModel, MENU_MODEL_SETUP, HEADER_LINE + ITEM_MODEL_SETUP_LINES_COUNT);
@@ -2053,6 +2087,39 @@ void menuModelSetup(event_t event)
}
break;
#endif
#if defined(USBJ_EX)
case ITEM_MODEL_SETUP_USBJOYSTICK_LABEL:
lcdDrawTextAlignedLeft(y, STR_USBJOYSTICK_LABEL);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_MODE:
g_model.usbJoystickExtMode = editChoice(MODEL_SETUP_2ND_COLUMN, y, INDENT TR_USBJOYSTICK_EXTMODE, STR_VUSBJOYSTICK_EXTMODE, g_model.usbJoystickExtMode, 0, 1, attr, event);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_IF_MODE:
g_model.usbJoystickIfMode = editChoice(MODEL_SETUP_2ND_COLUMN, y, INDENT TR_USBJOYSTICK_IF_MODE, STR_VUSBJOYSTICK_IF_MODE, g_model.usbJoystickIfMode, 0, USBJOYS_LAST, attr, event);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_CIRC_CUTOUT:
g_model.usbJoystickCircularCut = editChoice(MODEL_SETUP_2ND_COLUMN, y, INDENT TR_USBJOYSTICK_CIRC_COUTOUT, STR_VUSBJOYSTICK_CIRC_COUTOUT, g_model.usbJoystickCircularCut, 0, 2, attr, event);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_CH_BUTTON:
lcdDrawText(INDENT_WIDTH, y, BUTTON(TR_USBJOYSTICK_SETTINGS), attr);
if (attr && event == EVT_KEY_FIRST(KEY_ENTER)) {
pushMenu(menuModelUSBJoystick);
}
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_APPLY:
lcdDrawText(INDENT_WIDTH, y, BUTTON(TR_USBJOYSTICK_APPLY_CHANGES), attr);
if (attr && !READ_ONLY() && event == EVT_KEY_FIRST(KEY_ENTER)) {
killEvents(event);
onUSBJoystickModelChanged();
}
break;
#endif
}
}
+3
View File
@@ -122,6 +122,9 @@ void menuModelCustomScripts(event_t event);
void menuModelTelemetry(event_t event);
void menuModelSensor(event_t event);
void menuModelDisplay(event_t event);
#if defined(USBJ_EX)
void menuModelUSBJoystick(event_t event);
#endif
extern const MenuHandlerFunc menuTabModel[MENU_MODEL_PAGES_COUNT];
+68 -1
View File
@@ -22,6 +22,10 @@
#include "opentx.h"
#include "mixer_scheduler.h"
#if defined(USBJ_EX)
#include "usb_joystick.h"
#endif
#if defined(CROSSFIRE)
#include "telemetry/crossfire.h"
#endif
@@ -153,6 +157,15 @@ enum MenuModelSetupItems {
#endif
ITEM_MODEL_SETUP_TRAINER_CHANNELS,
ITEM_MODEL_SETUP_TRAINER_PPM_PARAMS,
#if defined(USBJ_EX)
ITEM_MODEL_SETUP_USBJOYSTICK_LABEL,
ITEM_MODEL_SETUP_USBJOYSTICK_MODE,
ITEM_MODEL_SETUP_USBJOYSTICK_IF_MODE,
ITEM_MODEL_SETUP_USBJOYSTICK_CIRC_CUTOUT,
ITEM_MODEL_SETUP_USBJOYSTICK_CH_BUTTON,
ITEM_MODEL_SETUP_USBJOYSTICK_APPLY,
#endif
ITEM_MODEL_SETUP_LINES_COUNT
};
@@ -392,6 +405,25 @@ void onBluetoothConnectMenu(const char * result)
#include "common/stdlcd/model_setup_afhds3.cpp"
#endif
#if defined(USBJ_EX)
inline uint8_t USB_JOYSTICK_EXTROW()
{
return (usbJoystickExtMode() ? (uint8_t)0 : HIDDEN_ROW);
}
inline uint8_t USB_JOYSTICK_APPLYROW()
{
if(!usbJoystickExtMode()) return HIDDEN_ROW;
if(usbJoystickSettingsChanged()) return (uint8_t)0;
return READONLY_ROW;
}
#define USB_JOYSTICK_ROWS LABEL(USBJoystick), (uint8_t)0, USB_JOYSTICK_EXTROW(), \
USB_JOYSTICK_EXTROW(), USB_JOYSTICK_EXTROW(), USB_JOYSTICK_APPLYROW()
#else
#define USB_JOYSTICK_ROWS
#endif
void menuModelSetup(event_t event)
{
horzpos_t l_posHorz = menuHorizontalPosition;
@@ -470,7 +502,9 @@ void menuModelSetup(event_t event)
IF_ACCESS_MODULE_RF(EXTERNAL_MODULE, 0), // Receiver 2
IF_ACCESS_MODULE_RF(EXTERNAL_MODULE, 0), // Receiver 3
TRAINER_ROWS
TRAINER_ROWS,
USB_JOYSTICK_ROWS
});
MENU_CHECK(menuTabModel, MENU_MODEL_SETUP, ITEM_MODEL_SETUP_LINES_COUNT);
@@ -1768,6 +1802,39 @@ void menuModelSetup(event_t event)
modelSetupModulePxx2ReceiverLine(CURRENT_MODULE_EDITED(k), CURRENT_RECEIVER_EDITED(k), y, event, attr);
break;
#endif
#if defined(USBJ_EX)
case ITEM_MODEL_SETUP_USBJOYSTICK_LABEL:
lcdDrawTextAlignedLeft(y, STR_USBJOYSTICK_LABEL);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_MODE:
g_model.usbJoystickExtMode = editChoice(MODEL_SETUP_2ND_COLUMN, y, INDENT TR_USBJOYSTICK_EXTMODE, STR_VUSBJOYSTICK_EXTMODE, g_model.usbJoystickExtMode, 0, 1, attr, event);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_IF_MODE:
g_model.usbJoystickIfMode = editChoice(MODEL_SETUP_2ND_COLUMN, y, INDENT TR_USBJOYSTICK_IF_MODE, STR_VUSBJOYSTICK_IF_MODE, g_model.usbJoystickIfMode, 0, USBJOYS_LAST, attr, event);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_CIRC_CUTOUT:
g_model.usbJoystickCircularCut = editChoice(MODEL_SETUP_2ND_COLUMN, y, INDENT TR_USBJOYSTICK_CIRC_COUTOUT, STR_VUSBJOYSTICK_CIRC_COUTOUT, g_model.usbJoystickCircularCut, 0, 2, attr, event);
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_CH_BUTTON:
lcdDrawText(INDENT_WIDTH, y, BUTTON(TR_USBJOYSTICK_SETTINGS), attr);
if (attr && event == EVT_KEY_FIRST(KEY_ENTER)) {
pushMenu(menuModelUSBJoystick);
}
break;
case ITEM_MODEL_SETUP_USBJOYSTICK_APPLY:
lcdDrawText(INDENT_WIDTH, y, BUTTON(TR_USBJOYSTICK_APPLY_CHANGES), attr);
if (attr && !READ_ONLY() && event == EVT_KEY_FIRST(KEY_ENTER)) {
killEvents(event);
onUSBJoystickModelChanged();
}
break;
#endif
}
}
+5
View File
@@ -222,3 +222,8 @@ add_gui_src(lvgl_widgets/input_mix_group.c)
if(HARDWARE_TOUCH)
add_gui_src(keyboard_curve.cpp)
endif()
if(USBJ_EX)
add_gui_src(model_usbjoystick.cpp)
endif()
+4
View File
@@ -83,6 +83,9 @@ static const uint8_t mask_model_special_functions[] = {
static const uint8_t mask_model_telemetry[] = {
#include "mask_model_telemetry.lbm"
};
static const uint8_t mask_model_usb[] = {
#include "mask_model_usb.lbm"
};
static const uint8_t mask_menu_model_select[] = {
#include "mask_menu_model_select.lbm" //TODO: someone may want to make proper icon
};
@@ -343,6 +346,7 @@ static const _BuiltinIcon _builtinIcons[] = {
{ICON_MODEL_SPECIAL_FUNCTIONS, mask_model_special_functions},
{ICON_MODEL_LUA_SCRIPTS, mask_model_lua_scripts},
{ICON_MODEL_TELEMETRY, mask_model_telemetry},
{ICON_MODEL_USB, mask_model_usb},
{ICON_MODEL_SELECT, mask_menu_model_select},
{ICON_MODEL_SELECT_CATEGORY, mask_model_select_category},
{ICON_THEME, mask_menu_theme},
+1
View File
@@ -56,6 +56,7 @@ enum MenuIcons {
ICON_MODEL_SPECIAL_FUNCTIONS,
ICON_MODEL_LUA_SCRIPTS,
ICON_MODEL_TELEMETRY,
ICON_MODEL_USB,
ICON_MODEL_SELECT,
ICON_MODEL_SELECT_CATEGORY,
ICON_THEME,
+13
View File
@@ -33,6 +33,10 @@
#include "throttle_params.h"
#include "preflight_checks.h"
#if defined(USBJ_EX)
#include "model_usbjoystick.h"
#endif
#include <algorithm>
#define SET_DIRTY() storageDirty(EE_MODEL)
@@ -329,6 +333,15 @@ void ModelSetupPage::build(FormWindow * window)
btn = new SubScreenButton(form, STR_THROTTLE_LABEL, []() { new ThrottleParams(); });
lv_obj_set_grid_cell(btn->getLvObj(), LV_GRID_ALIGN_STRETCH, 2, 1, LV_GRID_ALIGN_CENTER, 0, 1);
#if defined(USBJ_EX)
form = new FormGroup(oform, rect_t{});
form->setFlexLayout(LV_FLEX_FLOW_ROW, lv_dpx(PAGE_PADDING));
lv_obj_set_grid_dsc_array(form->getLvObj(), col_dsc, row_dsc);
btn = new SubScreenButton(form, STR_USBJOYSTICK_LABEL, []() { new ModelUSBJoystickPage(); });
lv_obj_set_grid_cell(btn->getLvObj(), LV_GRID_ALIGN_STRETCH, 0, 1, LV_GRID_ALIGN_CENTER, 0, 1);
#endif
}
#define MAX_SUBSCREEN_BTNS 9
@@ -0,0 +1,601 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "model_usbjoystick.h"
#include "usb_joystick.h"
#include "channel_bar.h"
#include "button_matrix.h"
#include "lvgl_widgets/input_mix_line.h"
#include "opentx.h"
#define SET_DIRTY() storageDirty(EE_MODEL)
#if LCD_W > LCD_H // Landscape
static const lv_coord_t line_col_dsc[] = {LV_GRID_FR(1), LV_GRID_FR(1),
LV_GRID_FR(1), LV_GRID_FR(1),
LV_GRID_TEMPLATE_LAST};
#define USBCH_EDIT_STATUS_BAR_WIDTH 250
#define USBCH_EDIT_STATUS_BAR_MARGIN 3
#define USBCH_EDIT_RIGHT_MARGIN 0
#define USBCH_COLS 4
static const lv_coord_t ch_col_dsc[] = {LV_GRID_FR(1), LV_GRID_FR(2),
LV_GRID_FR(1), LV_GRID_FR(2),
LV_GRID_TEMPLATE_LAST};
#define USBCH_CHN_ROWS 1
#define USBCH_BTN_MODE_COL 4
#define USBCH_BTN_MODE_ROW 0
#define USBCH_LINE_HEIGHT PAGE_LINE_HEIGHT + 14
static const lv_coord_t b_col_dsc[] = {LV_GRID_FR(10), 20, LV_GRID_FR(10), LV_GRID_FR(12),
LV_GRID_FR(9), LV_GRID_FR(9), LV_GRID_TEMPLATE_LAST};
static const lv_coord_t b_row_dsc[] = {LV_GRID_CONTENT, LV_GRID_TEMPLATE_LAST};
#else // Portrait
static const lv_coord_t line_col_dsc[] = {LV_GRID_FR(1), LV_GRID_FR(1),
LV_GRID_TEMPLATE_LAST};
#define USBCH_EDIT_STATUS_BAR_WIDTH 160
#define USBCH_EDIT_STATUS_BAR_MARGIN 0
#define USBCH_EDIT_RIGHT_MARGIN 3
#define USBCH_COLS 2
static const lv_coord_t ch_col_dsc[] = {LV_GRID_FR(2), LV_GRID_FR(3),
LV_GRID_TEMPLATE_LAST};
#define USBCH_CHN_ROWS 2
#define USBCH_BTN_MODE_COL 2
#define USBCH_BTN_MODE_ROW 1
#define USBCH_LINE_HEIGHT 2 * PAGE_LINE_HEIGHT + 10
static const lv_coord_t b_col_dsc[] = {LV_GRID_FR(1), 20, LV_GRID_FR(1), LV_GRID_FR(1),
LV_GRID_TEMPLATE_LAST};
static const lv_coord_t b_row_dsc[] = {LV_GRID_CONTENT, LV_GRID_CONTENT, LV_GRID_TEMPLATE_LAST};
#endif
#define USBCH_BTNMX_COL 8
static const lv_coord_t row_dsc[] = {LV_GRID_CONTENT, LV_GRID_TEMPLATE_LAST};
class USBChannelEditStatusBar : public Window
{
public:
USBChannelEditStatusBar(Window *parent, const rect_t &rect, int8_t channel) :
Window(parent, rect), _channel(channel)
{
channelBar = new ComboChannelBar(this, {USBCH_EDIT_STATUS_BAR_MARGIN, 0, rect.w - (USBCH_EDIT_STATUS_BAR_MARGIN * 2), rect.h}, channel);
channelBar->setLeftMargin(0);
channelBar->setTextColor(COLOR_THEME_PRIMARY2);
channelBar->setOutputChannelBarLimitColor(COLOR_THEME_EDIT);
}
protected:
ComboChannelBar *channelBar;
int8_t _channel;
};
static void btnsel_event_cb(lv_event_t* e);
class USBChannelButtonSel : public ButtonMatrix
{
public:
USBChannelButtonSel(Window* parent, const rect_t& rect, uint8_t channel,
std::function<void(int)> _setValue) :
ButtonMatrix(parent, rect),
m_channel(channel),
m_setValue(std::move(_setValue))
{
initBtnMap(USBCH_BTNMX_COL, USBJ_BUTTON_SIZE);
char snum[5];
for (uint8_t btn = 0; btn < USBJ_BUTTON_SIZE; btn++) {
snprintf(snum, 5, "%u", btn);
setText(btn, snum);
}
update();
lv_obj_add_event_cb(lvobj, btnsel_event_cb, LV_EVENT_DRAW_PART_BEGIN, this);
memset(m_btns, 0, USBJ_BUTTON_SIZE);
for (uint8_t ch = 0; ch < USBJ_MAX_JOYSTICK_CHANNELS; ch++) {
if (ch != m_channel) {
USBJoystickChData * cch = usbJChAddress(ch);
if (cch->mode == USBJOYS_CH_BUTTON) {
uint8_t last = cch->lastBtnNum();
for(uint8_t b = cch->btn_num; b <= last; b++) {
m_btns[b] = 1;
}
}
}
}
updateState();
}
void setValue(int val)
{
if (m_setValue) {
m_setValue(val);
}
}
void onPress(uint8_t btn_id) override
{
setValue(btn_id);
updateState();
}
bool isActive(uint8_t btn_id) override { return false; }
uint8_t getBtnState(uint8_t id)
{
if (id < USBJ_BUTTON_SIZE) return m_btns[id];
return 0;
}
void updateState()
{
USBJoystickChData * cch = usbJChAddress(m_channel);
for(uint8_t i = 0; i < USBJ_BUTTON_SIZE; i++) m_btns[i] &= 1;
uint8_t last = cch->lastBtnNum();
for(uint8_t b = cch->btn_num; b <= last; b++) m_btns[b] |= 2;
}
protected:
uint8_t m_channel = 0;
std::function<void(int)> m_setValue;
uint8_t m_btns[USBJ_BUTTON_SIZE];
};
static void btnsel_event_cb(lv_event_t* e)
{
lv_event_code_t code = lv_event_get_code(e);
if (code == LV_EVENT_DRAW_PART_BEGIN) {
lv_obj_draw_part_dsc_t* dsc = lv_event_get_draw_part_dsc(e);
if(dsc->class_p == &lv_btnmatrix_class && dsc->type == LV_BTNMATRIX_DRAW_PART_BTN) {
dsc->rect_dsc->radius = LV_RADIUS_CIRCLE;
auto btsel = (USBChannelButtonSel*)lv_event_get_user_data(e);
uint8_t state = btsel->getBtnState((uint8_t)dsc->id);
if (state == 1) {
dsc->rect_dsc->bg_color = makeLvColor(COLOR_THEME_DISABLED);
dsc->label_dsc->color = makeLvColor(COLOR_THEME_PRIMARY1);
}
else if (state == 2) {
dsc->rect_dsc->bg_color = makeLvColor(COLOR_THEME_EDIT);
dsc->label_dsc->color = makeLvColor(COLOR_THEME_PRIMARY2);
}
else if (state == 3) {
dsc->rect_dsc->bg_color = makeLvColor(COLOR_THEME_WARNING);
dsc->label_dsc->color = makeLvColor(COLOR_THEME_PRIMARY2);
}
else {
dsc->rect_dsc->bg_color = makeLvColor(COLOR_THEME_PRIMARY2);
dsc->label_dsc->color = makeLvColor(COLOR_THEME_SECONDARY1);
}
}
}
}
#define USBCH_LINES 3
#define SET_VALUE_WUPDATE(value) [=](int32_t newValue) { value = newValue; SET_DIRTY(); this->update(); }
class USBChannelEditWindow : public Page
{
public:
USBChannelEditWindow(uint8_t channel) :
Page(ICON_MODEL_USB), channel(channel)
{
auto form = new FormWindow(&body, rect_t{});
form->padAll(4);
form->padLeft(8);
form->padRight(8);
buildHeader(&header);
buildBody(form);
}
protected:
uint8_t channel;
USBChannelEditStatusBar* statusBar = nullptr;
FormWindow* m_btnModeFrame = nullptr;
Window* m_axisModeLine = nullptr;
Window* m_simModeLine = nullptr;
USBChannelButtonSel* _BtnNumSel = nullptr;
StaticText* collisionText = nullptr;
Choice* m_btnPosChoice = nullptr;
protected:
void update()
{
USBJoystickChData * cch = usbJChAddress(channel);
lv_obj_add_flag(m_btnModeFrame->getLvObj(), LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(m_axisModeLine->getLvObj(), LV_OBJ_FLAG_HIDDEN);
lv_obj_add_flag(m_simModeLine->getLvObj(), LV_OBJ_FLAG_HIDDEN);
if (cch->mode == USBJOYS_CH_BUTTON)
lv_obj_clear_flag(m_btnModeFrame->getLvObj(), LV_OBJ_FLAG_HIDDEN);
else if (cch->mode == USBJOYS_CH_AXIS)
lv_obj_clear_flag(m_axisModeLine->getLvObj(), LV_OBJ_FLAG_HIDDEN);
else if (cch->mode == USBJOYS_CH_SIM)
lv_obj_clear_flag(m_simModeLine->getLvObj(), LV_OBJ_FLAG_HIDDEN);
if(m_btnPosChoice)
m_btnPosChoice->enable((cch->param != USBJOYS_BTN_MODE_SW_EMU) && (cch->param != USBJOYS_BTN_MODE_DELTA));
if(collisionText) {
collisionText->setText("");
lv_obj_add_flag(collisionText->getLvObj(), LV_OBJ_FLAG_HIDDEN);
if (cch->mode == USBJOYS_CH_BUTTON) {
if (isUSBBtnNumCollision(channel)) {
collisionText->setText(STR_USBJOYSTICK_BTN_COLLISION);
lv_obj_clear_flag(collisionText->getLvObj(), LV_OBJ_FLAG_HIDDEN);
}
}
else if (cch->mode == USBJOYS_CH_AXIS) {
if (isUSBAxisCollision(channel)) {
collisionText->setText(STR_USBJOYSTICK_AXIS_COLLISION);
lv_obj_clear_flag(collisionText->getLvObj(), LV_OBJ_FLAG_HIDDEN);
}
}
else if (cch->mode == USBJOYS_CH_SIM) {
if (isUSBSimCollision(channel)) {
collisionText->setText(STR_USBJOYSTICK_AXIS_COLLISION);
lv_obj_clear_flag(collisionText->getLvObj(), LV_OBJ_FLAG_HIDDEN);
}
}
}
_BtnNumSel->updateState();
}
void buildHeader(Window *window)
{
header.setTitle(STR_USBJOYSTICK_LABEL);
header.setTitle2(getSourceString(MIXSRC_CH1 + channel));
statusBar = new USBChannelEditStatusBar(
window,
{window->getRect().w - USBCH_EDIT_STATUS_BAR_WIDTH - USBCH_EDIT_RIGHT_MARGIN,
0, USBCH_EDIT_STATUS_BAR_WIDTH, MENU_HEADER_HEIGHT + 3},
channel);
}
void buildBody(FormWindow* form)
{
FlexGridLayout grid(ch_col_dsc, row_dsc, 2);
form->setFlexLayout();
USBJoystickChData * cch = usbJChAddress(channel);
auto line = form->newLine(&grid);
line->padTop(0);
line->padBottom(0);
collisionText = new StaticText(line, rect_t{}, "", OPAQUE, FONT(BOLD) | COLOR_THEME_PRIMARY2 | CENTERED);
collisionText->setBackgroundColor(COLOR_THEME_WARNING);
lv_obj_set_grid_cell(collisionText->getLvObj(), LV_GRID_ALIGN_STRETCH, 0, USBCH_COLS, LV_GRID_ALIGN_CENTER, 0, 1);
line = form->newLine(&grid);
new StaticText(line, rect_t{}, STR_USBJOYSTICK_CH_MODE, 0, COLOR_THEME_PRIMARY1);
new Choice(line, rect_t{}, STR_VUSBJOYSTICK_CH_MODE, 0, USBJOYS_CH_LAST,
GET_DEFAULT(cch->mode), SET_VALUE_WUPDATE(cch->mode));
#if LCD_H > LCD_W
line = form->newLine(&grid);
#endif
new StaticText(line, rect_t{}, STR_USBJOYSTICK_CH_INVERSION, 0, COLOR_THEME_PRIMARY1);
new CheckBox(line, rect_t{}, GET_SET_DEFAULT(cch->inversion));
line = form->newLine(&grid);
m_btnModeFrame = new FormWindow(line, rect_t{});
m_btnModeFrame->setFlexLayout();
line = m_btnModeFrame->newLine(&grid);
new StaticText(line, rect_t{}, STR_USBJOYSTICK_CH_BTNMODE, 0, COLOR_THEME_PRIMARY1);
new Choice(line, rect_t{}, STR_VUSBJOYSTICK_CH_BTNMODE, 0, USBJOYS_BTN_MODE_LAST,
GET_DEFAULT(cch->param),
[=](int32_t newValue)
{
cch->param = newValue;
if(cch->param == USBJOYS_BTN_MODE_SW_EMU) m_btnPosChoice->setValue(0);
else if(cch->param == USBJOYS_BTN_MODE_DELTA) m_btnPosChoice->setValue(1);
SET_DIRTY();
this->update();
});
#if LCD_H > LCD_W
line = m_btnModeFrame->newLine(&grid);
#endif
new StaticText(line, rect_t{}, STR_USBJOYSTICK_CH_SWPOS, 0, COLOR_THEME_PRIMARY1);
m_btnPosChoice = new Choice(line, rect_t{}, STR_VUSBJOYSTICK_CH_SWPOS, 0, 7,
GET_DEFAULT(cch->switch_npos), SET_VALUE_WUPDATE(cch->switch_npos));
line = m_btnModeFrame->newLine(&grid);
new StaticText(line, rect_t{}, STR_USBJOYSTICK_CH_BTNNUM, 0, COLOR_THEME_PRIMARY1);
#if LCD_H > LCD_W
line = m_btnModeFrame->newLine(&grid);
#endif
_BtnNumSel = new USBChannelButtonSel(line, rect_t{},
channel, SET_VALUE_WUPDATE(cch->btn_num));
m_axisModeLine = form->newLine(&grid);
new StaticText(m_axisModeLine, rect_t{}, STR_USBJOYSTICK_CH_AXIS, 0, COLOR_THEME_PRIMARY1);
new Choice(m_axisModeLine, rect_t{}, STR_VUSBJOYSTICK_CH_AXIS, 0, USBJOYS_AXIS_LAST,
GET_DEFAULT(cch->param), SET_VALUE_WUPDATE(cch->param));
m_simModeLine = form->newLine(&grid);
new StaticText(m_simModeLine, rect_t{}, STR_USBJOYSTICK_CH_SIM, 0, COLOR_THEME_PRIMARY1);
new Choice(m_simModeLine, rect_t{}, STR_VUSBJOYSTICK_CH_SIM, 0, USBJOYS_SIM_LAST,
GET_DEFAULT(cch->param), SET_VALUE_WUPDATE(cch->param));
update();
}
};
class USBChannelLineButton : public Button
{
public:
USBChannelLineButton(Window* parent, uint8_t index) :
Button(parent, rect_t{}, nullptr, 0, 0, input_mix_line_create), index(index)
{
setHeight(USBCH_LINE_HEIGHT);
lv_obj_set_layout(lvobj, LV_LAYOUT_GRID);
lv_obj_set_grid_dsc_array(lvobj, b_col_dsc, b_row_dsc);
lv_obj_set_style_pad_row(lvobj, 0, 0);
lv_obj_set_style_pad_column(lvobj, 4, 0);
lv_obj_add_event_cb(lvobj, USBChannelLineButton::on_draw,
LV_EVENT_DRAW_MAIN_BEGIN, nullptr);
}
static void on_draw(lv_event_t* e)
{
lv_obj_t* target = lv_event_get_target(e);
auto line = (USBChannelLineButton*)lv_obj_get_user_data(target);
if (line) {
if (!line->init)
line->delayed_init(e);
else
line->refresh();
}
}
void delayed_init(lv_event_t* e)
{
m_chn = lv_label_create(lvobj);
lv_obj_set_grid_cell(m_chn, LV_GRID_ALIGN_START, 0, 1,
LV_GRID_ALIGN_CENTER, 0, USBCH_CHN_ROWS);
m_inverse = new StaticBitmap(this, rect_t{0, 0, 11, 16}, chanMonInvertedBitmap, COLOR_THEME_SECONDARY1, false);
lv_obj_set_grid_cell(m_inverse->getLvObj(), LV_GRID_ALIGN_START, 1, 1,
LV_GRID_ALIGN_CENTER, 0, 1);
m_mode = lv_label_create(lvobj);
lv_obj_set_grid_cell(m_mode, LV_GRID_ALIGN_START, 2, 1,
LV_GRID_ALIGN_CENTER, 0, 1);
m_param = lv_label_create(lvobj);
lv_obj_set_grid_cell(m_param, LV_GRID_ALIGN_START, 3, 1,
LV_GRID_ALIGN_CENTER, 0, 1);
m_btn_mode = lv_label_create(lvobj);
lv_obj_set_grid_cell(m_btn_mode, LV_GRID_ALIGN_START, USBCH_BTN_MODE_COL, 1,
LV_GRID_ALIGN_CENTER, USBCH_BTN_MODE_ROW, 1);
m_btns = lv_label_create(lvobj);
lv_obj_set_grid_cell(m_btns, LV_GRID_ALIGN_START, USBCH_BTN_MODE_COL+1, 1,
LV_GRID_ALIGN_CENTER, USBCH_BTN_MODE_ROW, 1);
lv_label_set_text(m_chn, getSourceString(MIXSRC_CH1 + index));
lv_label_set_text(m_mode, "");
lv_label_set_text(m_param, "");
lv_label_set_text(m_btn_mode, "");
lv_label_set_text(m_btns, "");
init = true;
refresh();
lv_obj_update_layout(lvobj);
if (e) {
auto param = lv_event_get_param(e);
lv_event_send(lvobj, LV_EVENT_DRAW_MAIN, param);
}
}
void refresh()
{
if (!init) return;
USBJoystickChData * cch = usbJChAddress(index);
lv_label_set_text(m_mode, STR_VUSBJOYSTICK_CH_MODE[cch->mode]);
if (cch->inversion)
lv_obj_clear_flag(m_inverse->getLvObj(), LV_OBJ_FLAG_HIDDEN);
else
lv_obj_add_flag(m_inverse->getLvObj(), LV_OBJ_FLAG_HIDDEN);
LcdFlags warn = COLOR_THEME_SECONDARY1;
LcdFlags font = FONT(STD);
const char* param = "";
if (cch->mode == USBJOYS_CH_BUTTON) {
param = STR_VUSBJOYSTICK_CH_BTNMODE[cch->param];
}
else if (cch->mode == USBJOYS_CH_AXIS) {
param = STR_VUSBJOYSTICK_CH_AXIS[cch->param];
if (isUSBAxisCollision(index)) {
warn = COLOR_THEME_WARNING;
font = FONT(BOLD);
}
}
else if (cch->mode == USBJOYS_CH_SIM) {
param = STR_VUSBJOYSTICK_CH_SIM[cch->param];
if (isUSBSimCollision(index)) {
warn = COLOR_THEME_WARNING;
font = FONT(BOLD);
}
}
lv_label_set_text(m_param, param);
lv_obj_set_style_text_color(m_param, makeLvColor(warn), 0);
lv_obj_set_style_text_font(m_param, getFont(font), 0);
if (cch->mode == USBJOYS_CH_BUTTON) {
lv_label_set_text(m_btn_mode, STR_VUSBJOYSTICK_CH_SWPOS[cch->switch_npos]);
char str[20];
uint8_t last = cch->lastBtnNum();
if (last > cch->btn_num)
snprintf(str, 20, "%u..%u", cch->btn_num, last);
else
snprintf(str, 20, "%u", cch->btn_num);
lv_label_set_text(m_btns, str);
if (isUSBBtnNumCollision(index)) {
warn = COLOR_THEME_WARNING;
font = FONT(BOLD);
}
lv_obj_set_style_text_color(m_btns, makeLvColor(warn), 0);
lv_obj_set_style_text_font(m_btns, getFont(font), 0);
} else {
lv_label_set_text(m_btn_mode, "");
lv_label_set_text(m_btns, "");
}
}
protected:
bool init = false;
uint8_t index;
lv_obj_t* m_chn;
lv_obj_t* m_mode;
lv_obj_t* m_param;
lv_obj_t* m_btn_mode;
lv_obj_t* m_btns;
StaticBitmap* m_inverse;
};
ModelUSBJoystickPage::ModelUSBJoystickPage() :
Page(ICON_MODEL_USB)
{
header.setTitle(STR_USBJOYSTICK_LABEL);
auto form = new FormWindow(&body, rect_t{});
form->padAll(lv_dpx(8));
form->setFlexLayout();
FlexGridLayout grid(line_col_dsc, row_dsc, 2);
// Extended mode
auto line = form->newLine(&grid);
new StaticText(line, rect_t{}, STR_USBJOYSTICK_EXTMODE, 0, COLOR_THEME_PRIMARY1);
new Choice(line, rect_t{}, STR_VUSBJOYSTICK_EXTMODE, 0, 1,
GET_DEFAULT(g_model.usbJoystickExtMode), SET_VALUE_WUPDATE(g_model.usbJoystickExtMode));
#if LCD_H > LCD_W
line = form->newLine(&grid);
#endif
_IfModeLabel = new StaticText(line, rect_t{}, STR_USBJOYSTICK_IF_MODE, 0, COLOR_THEME_PRIMARY1);
_IfMode = new Choice(line, rect_t{}, STR_VUSBJOYSTICK_IF_MODE, 0, USBJOYS_LAST,
GET_DEFAULT(g_model.usbJoystickIfMode), SET_VALUE_WUPDATE(g_model.usbJoystickIfMode));
line = form->newLine(&grid);
_CircCoutoutLabel = new StaticText(line, rect_t{}, STR_USBJOYSTICK_CIRC_COUTOUT, 0, COLOR_THEME_PRIMARY1);
_CircCoutout = new Choice(line, rect_t{}, STR_VUSBJOYSTICK_CIRC_COUTOUT, 0, USBJOYS_LAST,
GET_DEFAULT(g_model.usbJoystickCircularCut), SET_VALUE_WUPDATE(g_model.usbJoystickCircularCut));
#if LCD_H > LCD_W
line = form->newLine(&grid);
#endif
_ApplyBtn = new TextButton(line, rect_t{}, STR_USBJOYSTICK_APPLY_CHANGES,
[=]() { onUSBJoystickModelChanged(); this->update(); return 0; });
auto btngrp = new FormGroup(form, rect_t{});
_ChannelsGroup = btngrp;
btngrp->setFlexLayout();
btngrp->padRow(lv_dpx(4));
for (uint8_t ch = 0; ch < USBJ_MAX_JOYSTICK_CHANNELS; ch++) {
// Channel settings
auto btn = new USBChannelLineButton(btngrp, ch);
USBJoystickChData * cch = usbJChAddress(ch);
btn->setPressHandler([=]() -> uint8_t {
if (cch->mode == USBJOYS_CH_NONE) {
editChannel(ch, btn);
}
else {
Menu *menu = new Menu(parent);
menu->addLine(STR_EDIT, [=]() {
editChannel(ch, btn);
});
menu->addLine(STR_CLEAR, [=]() {
memset(cch, 0, sizeof(USBJoystickChData));
SET_DIRTY();
btn->invalidate();
});
}
return 0;
});
}
update();
}
void ModelUSBJoystickPage::update()
{
const uint8_t usbj_ctrls = 6;
Window* ctrls[usbj_ctrls] = { _IfModeLabel, _IfMode, _CircCoutoutLabel, _CircCoutout, _ApplyBtn, _ChannelsGroup };
for(uint8_t i = 0; i < usbj_ctrls; i++) {
if(usbJoystickExtMode()) {
lv_obj_clear_flag(ctrls[i]->getLvObj(), LV_OBJ_FLAG_HIDDEN);
_ApplyBtn->enable(usbJoystickSettingsChanged());
}
else {
lv_obj_add_flag(ctrls[i]->getLvObj(), LV_OBJ_FLAG_HIDDEN);
}
}
}
void ModelUSBJoystickPage::editChannel(uint8_t channel, USBChannelLineButton* btn)
{
auto chedit = new USBChannelEditWindow(channel);
chedit->setCloseHandler(
[=]() { this->update(); });
}
@@ -0,0 +1,45 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#pragma once
#include "page.h"
class FormGroup;
class USBChannelLineButton;
class ModelUSBJoystickPage : public Page
{
public:
ModelUSBJoystickPage();
protected:
void update();
void editChannel(uint8_t channel, USBChannelLineButton* btn);
protected:
Window* _IfModeLabel;
Window* _IfMode;
Window* _CircCoutoutLabel;
Window* _CircCoutout;
TextButton* _ApplyBtn;
Window* _ChannelsGroup;
};
@@ -62,3 +62,11 @@ if(PXX2)
../common/stdlcd/model_receiver_options.cpp
)
endif()
if(USBJ_EX)
set(GUI_SRC
${GUI_SRC}
../common/stdlcd/model_usbjoystick.cpp
)
endif()
@@ -0,0 +1,255 @@
/*
* Copyright (C) EdgeTX
*
* Based on code named
* opentx - https://github.com/opentx/opentx
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "opentx.h"
#include "usb_joystick.h"
#define _STR_MAX(x) "/" #x
#define STR_MAX(x) _STR_MAX(x)
#if LCD_W >= 212
#define MODE_POS 5*FW
#define SUBMODE_POS MODE_POS+2*FW
#define USBJ_ONE_2ND_COLUMN (12*FW)
#define BTNMODE_POS SUBMODE_POS+5*FW
#define BTNNUM_POS BTNMODE_POS+12*FW
#else
#define MODE_POS 5*FW
#define SUBMODE_POS MODE_POS+2*FW
#define USBJ_ONE_2ND_COLUMN (12*FW)
#define BTNMODE_POS SUBMODE_POS+5*FW
#define BTNNUM_POS LCD_W
#endif
enum USBJFields {
USBJ_FIELD_MODE,
USBJ_FIELD_INVERSION,
USBJ_FIELD_SUBMODE,
USBJ_FIELD_BTNPOS,
USBJ_FIELD_BTNNUM,
USBJ_FIELD_MAX
};
void menuModelUSBJoystickOne(event_t event)
{
#if defined(KEYS_GPIO_REG_MDL)
if (event == EVT_KEY_FIRST(KEY_MODEL)) {
pushMenu(menuChannelsView);
killEvents(event);
}
#elif defined(NAVIGATION_X7)
if (event == EVT_KEY_FIRST(KEY_MENU)) {
pushMenu(menuChannelsView);
killEvents(event);
}
#elif defined(NAVIGATION_XLITE)
if (event == EVT_KEY_FIRST(KEY_ENTER) && IS_SHIFT_PRESSED()) {
pushMenu(menuChannelsView);
killEvents(event);
}
#endif
USBJoystickChData * cch = usbJChAddress(s_currIdx);
putsChn(12*FW, 0, s_currIdx+1, 0);
lcdDrawNumber(20*FW, 0, channelOutputs[s_currIdx], RIGHT);
SUBMENU(STR_USBJOYSTICK_LABEL, USBJ_FIELD_MAX, {
0,
(cch->mode != USBJOYS_CH_NONE) ? (uint8_t)0 : (uint8_t)HIDDEN_ROW,
(cch->mode != USBJOYS_CH_NONE) ? (uint8_t)0 : (uint8_t)HIDDEN_ROW,
(cch->mode == USBJOYS_CH_BUTTON) ?
(((cch->param == USBJOYS_BTN_MODE_SW_EMU) || (cch->param == USBJOYS_BTN_MODE_DELTA)) ? (uint8_t)READONLY_ROW : (uint8_t)0)
: (uint8_t)HIDDEN_ROW,
(cch->mode == USBJOYS_CH_BUTTON) ? (uint8_t)0 : (uint8_t)HIDDEN_ROW });
int8_t sub = menuVerticalPosition;
char str[20];
for (uint8_t i=0; i<(NUM_BODY_LINES-1); i++) {
coord_t y = MENU_HEADER_HEIGHT + 1 + i*FH;
uint8_t k = i + menuVerticalOffset;
for (int j=0; j<=k; ++j) {
if (j<(int)DIM(mstate_tab) && mstate_tab[j] == HIDDEN_ROW) {
++k;
}
}
LcdFlags attr = (sub==k ? (s_editMode>0 ? BLINK|INVERS : INVERS) : 0);
switch (k) {
case USBJ_FIELD_MODE:
cch->mode = editChoice(USBJ_ONE_2ND_COLUMN, y, STR_USBJOYSTICK_CH_MODE, STR_VUSBJOYSTICK_CH_MODE, cch->mode, 0, USBJOYS_CH_LAST, attr, event);
break;
case USBJ_FIELD_INVERSION:
lcdDrawTextAlignedLeft(y, TR_USBJOYSTICK_CH_INVERSION);
drawCheckBox(USBJ_ONE_2ND_COLUMN, y, cch->inversion, attr);
if (attr) cch->inversion = checkIncDecModel(event, cch->inversion, 0, 1);
break;
case USBJ_FIELD_SUBMODE:
if(cch->mode == USBJOYS_CH_BUTTON) {
cch->param = editChoice(USBJ_ONE_2ND_COLUMN, y, STR_USBJOYSTICK_CH_BTNMODE, STR_VUSBJOYSTICK_CH_BTNMODE, cch->param, 0, USBJOYS_BTN_MODE_LAST, attr, event);
if(cch->param == USBJOYS_BTN_MODE_SW_EMU) cch->switch_npos = 0;
else if(cch->param == USBJOYS_BTN_MODE_DELTA) cch->switch_npos = 1;
}
else if(cch->mode == USBJOYS_CH_AXIS) {
cch->param = editChoice(USBJ_ONE_2ND_COLUMN, y, STR_USBJOYSTICK_CH_AXIS, STR_VUSBJOYSTICK_CH_AXIS, cch->param, 0, USBJOYS_AXIS_LAST, attr, event);
}
else if(cch->mode == USBJOYS_CH_SIM) {
cch->param = editChoice(USBJ_ONE_2ND_COLUMN, y, STR_USBJOYSTICK_CH_SIM, STR_VUSBJOYSTICK_CH_SIM, cch->param, 0, USBJOYS_SIM_LAST, attr, event);
}
break;
case USBJ_FIELD_BTNPOS:
if(cch->param == USBJOYS_BTN_MODE_SW_EMU) {
lcdDrawTextAlignedLeft(y, STR_USBJOYSTICK_CH_SWPOS);
lcdDrawText(USBJ_ONE_2ND_COLUMN, y, STR_VUSBJOYSTICK_CH_SWPOS[0], attr);
}
else if(cch->param == USBJOYS_BTN_MODE_DELTA) {
lcdDrawTextAlignedLeft(y, STR_USBJOYSTICK_CH_SWPOS);
lcdDrawText(USBJ_ONE_2ND_COLUMN, y, STR_VUSBJOYSTICK_CH_SWPOS[1], attr);
}
else {
cch->switch_npos = editChoice(USBJ_ONE_2ND_COLUMN, y, STR_USBJOYSTICK_CH_SWPOS, STR_VUSBJOYSTICK_CH_SWPOS, cch->switch_npos, 0, 7, attr, event);
}
break;
case USBJ_FIELD_BTNNUM:
lcdDrawTextAlignedLeft(y, TR_USBJOYSTICK_CH_BTNNUM);
uint8_t last = cch->lastBtnNumNoCLip();
uint8_t limited = 0;
if(last >= USBJ_BUTTON_SIZE) {
limited = 1;
last = USBJ_BUTTON_SIZE-1;
}
if (last > cch->btn_num)
snprintf(str, 20, "%u..%u%c", cch->btn_num, last, limited ? '!' : ' ');
else
snprintf(str, 20, "%u%c", cch->btn_num, limited ? '!' : ' ');
lcdDrawText(USBJ_ONE_2ND_COLUMN, y, str, attr);
if (attr) {
CHECK_INCDEC_MODELVAR(event, cch->btn_num, 0, USBJ_BUTTON_SIZE);
}
break;
}
}
if (cch->mode == USBJOYS_CH_BUTTON) {
if (isUSBBtnNumCollision(s_currIdx)) {
lcdDrawText(LCD_W/2, LCD_H-FH, STR_USBJOYSTICK_BTN_COLLISION, INVERS | CENTERED);
}
}
else if (cch->mode == USBJOYS_CH_AXIS) {
if (isUSBAxisCollision(s_currIdx)) {
lcdDrawText(LCD_W/2, LCD_H-FH, STR_USBJOYSTICK_AXIS_COLLISION, INVERS | CENTERED);
}
}
else if (cch->mode == USBJOYS_CH_SIM) {
if (isUSBSimCollision(s_currIdx)) {
lcdDrawText(LCD_W/2, LCD_H-FH, STR_USBJOYSTICK_AXIS_COLLISION, INVERS | CENTERED);
}
}
}
void onUSBJoystickMenu(const char *result)
{
int8_t sub = menuVerticalPosition - HEADER_LINE;
USBJoystickChData * cs = usbJChAddress(sub);
if (result == STR_EDIT) {
s_currIdx = sub;
pushMenu(menuModelUSBJoystickOne);
}
else if (result == STR_CLEAR) {
memset(cs, 0, sizeof(USBJoystickChData));
storageDirty(EE_MODEL);
}
}
void menuModelUSBJoystick(event_t event)
{
check_submenu_simple(event, USBJ_MAX_JOYSTICK_CHANNELS - HEADER_LINE);
title(STR_USBJOYSTICK_LABEL);
if (s_editMode > 0) s_editMode = 0;
int8_t sub = menuVerticalPosition - HEADER_LINE;
coord_t y = 0;
uint8_t k = 0;
if (event == EVT_KEY_FIRST(KEY_ENTER)) {
killEvents(event);
USBJoystickChData * cch = usbJChAddress(sub);
s_currIdx = sub;
if (sub >= 0)
POPUP_MENU_ADD_ITEM(STR_EDIT);
if (cch->mode != USBJOYS_CH_NONE)
POPUP_MENU_ADD_ITEM(STR_CLEAR);
if (popupMenuItemsCount == 1) {
popupMenuItemsCount = 0;
s_currIdx = sub;
pushMenu(menuModelUSBJoystickOne);
}
else {
POPUP_MENU_START(onUSBJoystickMenu);
}
}
char str[20];
for (uint8_t i=0; i<NUM_BODY_LINES; i++) {
y = MENU_HEADER_HEIGHT + 1 + i*FH;
k = i + menuVerticalOffset;
LcdFlags attr = (sub==k) ? INVERS : 0;
USBJoystickChData * cch = usbJChAddress(k);
putsChn(0, y, k+1, attr);
lcdDrawChar(4*FW, y, cch->inversion ? '{' : ' ', 0);
lcdDrawTextAtIndex(MODE_POS, y, STR_VUSBJOYSTICK_CH_MODE_S, cch->mode, 0);
if (cch->mode == USBJOYS_CH_BUTTON) {
lcdDrawTextAtIndex(SUBMODE_POS, y, STR_VUSBJOYSTICK_CH_SWPOS, cch->switch_npos, 0);
lcdDrawTextAtIndex(BTNMODE_POS, y, STR_VUSBJOYSTICK_CH_BTNMODE_S, cch->param, 0);
uint8_t last = cch->lastBtnNum();
if (last > cch->btn_num)
sprintf(str, "%u..%u", cch->btn_num, last);
else
sprintf(str, "%u", cch->btn_num);
LcdFlags warn = 0;
if (isUSBBtnNumCollision(k)) warn = INVERS;
lcdDrawText(BTNNUM_POS, y, str, RIGHT|warn);
}
else if (cch->mode == USBJOYS_CH_AXIS) {
LcdFlags warn = 0;
if (isUSBAxisCollision(k)) warn = INVERS;
lcdDrawTextAtIndex(SUBMODE_POS, y, STR_VUSBJOYSTICK_CH_AXIS, cch->param, warn);
}
else if (cch->mode == USBJOYS_CH_SIM) {
LcdFlags warn = 0;
if (isUSBSimCollision(k)) warn = INVERS;
lcdDrawTextAtIndex(SUBMODE_POS, y, STR_VUSBJOYSTICK_CH_SIM, cch->param, warn);
}
}
}