Mirror/opentx
1
0
Fork 0
mirror of https://github.com/opentx/opentx.git synced 2025-07-15 12:25:12 +03:00
Code Issues Wiki Activity

[Horus] UI continued

Browse source
This commit is contained in:
Bertrand Songis 2015-11-14 17:19:20 +01:00
parent f32231cab2
commit ed2f66aedd
28 changed files with 449 additions and 327 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
radio/src/bitmaps/Horus/mask_cvpoint.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 369 B

BIN
radio/src/bitmaps/Horus/mask_cvpoint_center.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 222 B

BIN
radio/src/bitmaps/Horus/mask_point.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 212 B

0
radio/src/fonts/extra_17px.png → radio/src/fonts/extra_16px.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 4.8 KiB

After

Width:  |  Height:  |  Size: 4.8 KiB

Before After
Before After

12
radio/src/gui/Horus/bitmaps.cpp
View file

@ -251,3 +251,15 @@ const uint8_t LBM_STAR1[] = {
const uint8_t LBM_ASTERISK[] = {
#include "../../bitmaps/Horus/asterisk.lbm"
};
const uint8_t LBM_POINT[] = {
#include "../../bitmaps/Horus/mask_point.lbm"
};
const uint8_t LBM_CURVE_POINT[] = {
#include "../../bitmaps/Horus/mask_cvpoint.lbm"
};
const uint8_t LBM_CURVE_POINT_CENTER[] = {
#include "../../bitmaps/Horus/mask_cvpoint_center.lbm"
};

10
radio/src/gui/Horus/gui.h
View file

@ -59,9 +59,9 @@
#define INVERT_VERT_MARGIN 1
#define INVERT_LINE_HEIGHT 18
#define CURVE_SIDE_WIDTH 88
#define CURVE_CENTER_X (LCD_W-CURVE_SIDE_WIDTH-10)
#define CURVE_CENTER_Y 159
#define CURVE_SIDE_WIDTH 100
#define CURVE_CENTER_X (LCD_W-CURVE_SIDE_WIDTH-7)
#define CURVE_CENTER_Y 151
#define MENU_TITLE_NEXT_POS (lcdNextPos + 10)
#define MENU_INIT_VPOS -1
@ -111,4 +111,6 @@ extern const uint8_t LBM_STAR1[];
// Other icons
extern const uint8_t LBM_ASTERISK[];
extern const uint8_t LBM_POINT[];
extern const uint8_t LBM_CURVE_POINT[];
extern const uint8_t LBM_CURVE_POINT_CENTER[];

53
radio/src/gui/Horus/lcd.cpp
View file

@ -42,8 +42,6 @@ display_t displayBuf[DISPLAY_BUFFER_SIZE];
uint16_t lcdColorTable[LCD_COLOR_COUNT];
#define PIXEL_PTR(x, y) &displayBuf[(y)*LCD_W + (x)]
void lcdColorsInit()
{
lcdColorTable[TEXT_COLOR_INDEX] = BLACK;
@ -59,8 +57,8 @@ void lcdColorsInit()
lcdColorTable[ALARM_COLOR_INDEX] = RED;
lcdColorTable[WARNING_COLOR_INDEX] = YELLOW;
lcdColorTable[TEXT_DISABLE_COLOR_INDEX] = RGB(0x60, 0x60, 0x60);
lcdColorTable[CURVE_AXIS_COLOR_INDEX] = BLUE;
lcdColorTable[CURVE_COLOR_INDEX] = BLACK;
lcdColorTable[CURVE_AXIS_COLOR_INDEX] = RGB(180, 180, 180);
lcdColorTable[CURVE_COLOR_INDEX] = RED;
lcdColorTable[CURVE_CURSOR_COLOR_INDEX] = RED;
lcdColorTable[TITLE_BGCOLOR_INDEX] = RED;
lcdColorTable[HEADER_BGCOLOR_INDEX] = DARKRED;
@ -80,12 +78,12 @@ char getMappedChar(unsigned char c)
return c - 0xC0 + 96;
}
int getFontPatternWidth(const uint16_t *spec, int index)
int getFontPatternWidth(const uint16_t * spec, int index)
{
return spec[index+1] - spec[index];
}
int getCharWidth(char c, const uint16_t *spec)
int getCharWidth(char c, const uint16_t * spec)
{
return getFontPatternWidth(spec, getMappedChar(c));
}
@ -203,7 +201,7 @@ void lcdDrawTextWithLen(coord_t x, coord_t y, const pm_char * s, uint8_t len, Lc
else if (FONTSIZE(flags) == SMLSIZE)
lcdDrawSolidFilledRect(x-INVERT_HORZ_MARGIN+1, y-INVERT_VERT_MARGIN, width+2*INVERT_HORZ_MARGIN-2, INVERT_LINE_HEIGHT, TEXT_INVERTED_BGCOLOR);
else
lcdDrawSolidFilledRect(x-INVERT_HORZ_MARGIN, y-INVERT_VERT_MARGIN, width+2*INVERT_HORZ_MARGIN, INVERT_LINE_HEIGHT, TEXT_INVERTED_BGCOLOR);
lcdDrawSolidFilledRect(x-INVERT_HORZ_MARGIN, y/*-INVERT_VERT_MARGIN*/, width+2*INVERT_HORZ_MARGIN, INVERT_LINE_HEIGHT, TEXT_INVERTED_BGCOLOR);
}
char str[256];
@ -254,11 +252,6 @@ void lcdDrawText(coord_t x, coord_t y, const pm_char * s, LcdFlags flags)
lcdDrawTextWithLen(x, y, s, 255, flags);
}
void lcd_putsLeft(coord_t y, const pm_char * s)
{
lcdDrawText(MENUS_MARGIN_LEFT, y, s);
}
void lcd_putsCenter(coord_t y, const pm_char * s, LcdFlags attr)
{
int x = (LCD_W - getTextWidth(s)) / 2;
@ -473,7 +466,7 @@ void putsStrIdx(coord_t x, coord_t y, const pm_char *str, int idx, LcdFlags att,
void putsMixerSource(coord_t x, coord_t y, uint8_t idx, LcdFlags att)
{
if (idx == 0) {
if (idx == MIXSRC_NONE) {
lcdDrawTextAtIndex(x, y, STR_VSRCRAW, 0, att); // TODO macro
}
else if (idx <= MIXSRC_LAST_INPUT) {
@ -503,8 +496,7 @@ void putsMixerSource(coord_t x, coord_t y, uint8_t idx, LcdFlags att)
lcdDrawChar(x+20, y, 'a'+qr.rem, att);
}
}
else if (idx < MIXSRC_LAST_POT) {
else if (idx <= MIXSRC_LAST_POT) {
idx = idx-MIXSRC_Rud;
if (ZEXIST(g_eeGeneral.anaNames[idx]))
lcdDrawTextWithLen(x, y, g_eeGeneral.anaNames[idx], LEN_ANA_NAME, ZCHAR|att);
@ -793,23 +785,6 @@ void lcdSetContrast()
lcdSetRefVolt(g_eeGeneral.contrast);
}
inline void lcdDrawPixel(display_t * p, display_t value)
{
*p = value;
}
inline void lcdDrawPixel(coord_t x, coord_t y, display_t value)
{
display_t * p = PIXEL_PTR(x, y);
lcdDrawPixel(p, value);
}
inline void lcdDrawTransparentPixel(coord_t x, coord_t y, uint8_t opacity, uint16_t color)
{
display_t * p = PIXEL_PTR(x, y);
lcdDrawTransparentPixel(p, opacity, color);
}
void lcdDrawTransparentPixel(display_t * p, uint8_t opacity, uint16_t color)
{
ASSERT_IN_DISPLAY(p);
@ -874,13 +849,22 @@ void lcdDrawVerticalLine(coord_t x, coord_t y, coord_t h, uint8_t pat, LcdFlags
if (y<0) { h+=y; y=0; if (h<=0) return; }
if (y+h > LCD_H) { h = LCD_H - y; }
display_t color = lcdColorTable[COLOR_IDX(att)];
uint8_t opacity = 0x0F - (att >> 24);
if (pat == SOLID) {
while (h--) {
lcdDrawTransparentPixel(x, y, opacity, color);
y++;
}
}
else {
if (pat==DOTTED && !(y%2)) {
pat = ~pat;
}
while (h--) {
if (pat & 1) {
lcdDrawPoint(x, y, att);
lcdDrawTransparentPixel(x, y, opacity, color);
pat = (pat >> 1) | 0x80;
}
else {
@ -888,6 +872,7 @@ void lcdDrawVerticalLine(coord_t x, coord_t y, coord_t h, uint8_t pat, LcdFlags
}
y++;
}
}
}
#if defined(SIMU)

23
radio/src/gui/Horus/lcd.h
View file

@ -191,7 +191,6 @@ void lcdDrawText(coord_t x, coord_t y, const pm_char * s, LcdFlags attr=TEXT_COL
void lcdDrawTextAtIndex(coord_t x, coord_t y, const pm_char * s, uint8_t idx, LcdFlags attr=TEXT_COLOR);
void lcdDrawTextWithLen(coord_t x, coord_t y, const pm_char * s, uint8_t len, LcdFlags attr=TEXT_COLOR);
void lcdDrawTextWithLen(coord_t x, coord_t y, const pm_char * s, unsigned char len);
void lcd_putsLeft(coord_t y, const pm_char * s);
void lcd_putsCenter(coord_t y, const pm_char * s, LcdFlags attr=0);
void lcd_outhex4(coord_t x, coord_t y, uint32_t val, LcdFlags mode=0);
void lcdDrawNumber(coord_t x, coord_t y, int32_t val, LcdFlags flags=0, uint8_t len=0, const char * prefix=NULL, const char * suffix=NULL);
@ -224,14 +223,34 @@ void putsTimer(coord_t x, coord_t y, putstime_t tme, LcdFlags att=0);
#define SOLID 0xff
#define DOTTED 0x55
#define STASHED 0x70
#define PIXEL_PTR(x, y) &displayBuf[(y)*LCD_W + (x)]
inline void lcdDrawPixel(display_t * p, display_t value)
{
*p = value;
}
inline void lcdDrawPixel(coord_t x, coord_t y, display_t value)
{
display_t * p = PIXEL_PTR(x, y);
lcdDrawPixel(p, value);
}
void lcdDrawTransparentPixel(coord_t x, coord_t y, uint8_t opacity, uint16_t color);
void lcdDrawTransparentPixel(display_t * p, uint8_t opacity, uint16_t color);
void lcdDrawPoint(coord_t x, coord_t y, LcdFlags att=0);
void lcdDrawHorizontalLine(coord_t x, coord_t y, coord_t w, uint8_t pat, LcdFlags att=0);
void lcdDrawVerticalLine(coord_t x, scoord_t y, scoord_t h, uint8_t pat, LcdFlags att=0);
void lcdDrawLine(coord_t x1, coord_t y1, coord_t x2, coord_t y2, uint8_t pat=SOLID, LcdFlags att=0);
inline void lcdDrawTransparentPixel(coord_t x, coord_t y, uint8_t opacity, uint16_t color)
{
display_t * p = PIXEL_PTR(x, y);
lcdDrawTransparentPixel(p, opacity, color);
}
#if !defined(SIMU)
inline void lcdDrawSolidFilledRect(coord_t x, scoord_t y, coord_t w, coord_t h, LcdFlags att)
{

8
radio/src/gui/Horus/menu_general_sdmanager.cpp
View file

@ -47,13 +47,13 @@ bool menuGeneralSdManagerInfo(evt_t event)
{
SIMPLE_SUBMENU(STR_SD_INFO_TITLE, 1, DEFAULT_SCROLLBAR_X);
lcd_putsLeft(2*FH, STR_SD_TYPE);
lcdDrawText(MENUS_MARGIN_LEFT, 2*FH, STR_SD_TYPE);
lcdDrawText(100, 2*FH, SD_IS_HC() ? STR_SDHC_CARD : STR_SD_CARD);
lcd_putsLeft(3*FH, STR_SD_SIZE);
lcdDrawText(MENUS_MARGIN_LEFT, 3*FH, STR_SD_SIZE);
lcdDrawNumber(100, 3*FH, sdGetSize(), LEFT, 0, NULL, "M");
lcd_putsLeft(4*FH, STR_SD_SECTORS);
lcdDrawText(MENUS_MARGIN_LEFT, 4*FH, STR_SD_SECTORS);
#if defined(SD_GET_FREE_BLOCKNR)
lcdDrawNumber(100, 4*FH, SD_GET_FREE_BLOCKNR()/1000, LEFT, 0, NULL, "/");
lcdDrawNumber(150, 4*FH, sdGetNoSectors()/1000, LEFT);
@ -61,7 +61,7 @@ bool menuGeneralSdManagerInfo(evt_t event)
lcdDrawNumber(100, 4*FH, sdGetNoSectors()/1000, LEFT, 0, NULL, "k");
#endif
lcd_putsLeft(5*FH, STR_SD_SPEED);
lcdDrawText(MENUS_MARGIN_LEFT, 5*FH, STR_SD_SPEED);
lcdDrawNumber(100, 5*FH, SD_GET_SPEED()/1000, LEFT, 0, NULL, "kb/s");
return true;

116
radio/src/gui/Horus/menu_general_setup.cpp
View file

@ -46,10 +46,10 @@
#define MINUTE_SEPARATOR_OFFSET 63
#define SECOND_OFFSET 75
#define SLIDER_5POS(y, value, label, event, attr) { \
#define SLIDER_5POS(y, value, event, attr) { \
int8_t tmp = value; \
drawSlider(RADIO_SETUP_2ND_COLUMN, y, 2+tmp, 4, attr); \
value = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, label, NULL, tmp, -2, +2, attr, event); \
value = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, NULL, tmp, -2, +2, attr, event); \
}
#if defined(SPLASH) && !defined(FSPLASH)
@ -139,7 +139,7 @@ bool menuGeneralSetup(evt_t event)
switch(k) {
case ITEM_SETUP_DATE:
{
lcd_putsLeft(y, STR_DATE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_DATE);
LcdFlags flags = 0;
if (attr && m_posHorz < 0) {
flags |= INVERS;
@ -178,7 +178,7 @@ bool menuGeneralSetup(evt_t event)
case ITEM_SETUP_TIME:
{
lcd_putsLeft(y, STR_TIME);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TIME);
LcdFlags flags = 0;
if (attr && m_posHorz < 0) {
flags |= INVERS;
@ -211,7 +211,7 @@ bool menuGeneralSetup(evt_t event)
#if 0
case ITEM_SETUP_BATT_RANGE:
{
lcd_putsLeft(y, STR_BATTERY_RANGE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BATTERY_RANGE);
LcdFlags color = WHITE;
if (attr && m_posHorz < 0) {
color = BLACK;
@ -231,11 +231,12 @@ bool menuGeneralSetup(evt_t event)
#endif
case ITEM_SETUP_SOUND_LABEL:
lcd_putsLeft(y, STR_SOUND_LABEL);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SOUND_LABEL);
break;
case ITEM_SETUP_BEEP_MODE:
g_eeGeneral.beepMode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_SPEAKER, STR_VBEEPMODE, g_eeGeneral.beepMode, -2, 1, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SPEAKER);
g_eeGeneral.beepMode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_VBEEPMODE, g_eeGeneral.beepMode, -2, 1, attr, event);
#if defined(FRSKY)
if (attr && checkIncDec_Ret) frskySendAlarms();
#endif
@ -243,7 +244,7 @@ bool menuGeneralSetup(evt_t event)
case ITEM_SETUP_SPEAKER_VOLUME:
{
lcd_putsLeft(y, STR_SPEAKER_VOLUME);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SPEAKER_VOLUME);
uint8_t b = g_eeGeneral.speakerVolume+VOLUME_LEVEL_DEF;
drawSlider(RADIO_SETUP_2ND_COLUMN, y, b, VOLUME_LEVEL_MAX, attr);
if (attr) {
@ -256,21 +257,25 @@ bool menuGeneralSetup(evt_t event)
}
case ITEM_SETUP_BEEP_VOLUME:
SLIDER_5POS(y, g_eeGeneral.beepVolume, STR_BEEP_VOLUME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BEEP_VOLUME);
SLIDER_5POS(y, g_eeGeneral.beepVolume, event, attr);
break;
case ITEM_SETUP_WAV_VOLUME:
SLIDER_5POS(y, g_eeGeneral.wavVolume, STR_WAV_VOLUME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_WAV_VOLUME);
SLIDER_5POS(y, g_eeGeneral.wavVolume, event, attr);
break;
case ITEM_SETUP_BACKGROUND_VOLUME:
SLIDER_5POS(y, g_eeGeneral.backgroundVolume, STR_BG_VOLUME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BG_VOLUME);
SLIDER_5POS(y, g_eeGeneral.backgroundVolume, event, attr);
break;
case ITEM_SETUP_BEEP_LENGTH:
SLIDER_5POS(y, g_eeGeneral.beepLength, STR_BEEP_LENGTH, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BEEP_LENGTH);
SLIDER_5POS(y, g_eeGeneral.beepLength, event, attr);
break;
case ITEM_SETUP_SPEAKER_PITCH:
lcd_putsLeft( y, STR_SPKRPITCH);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SPKRPITCH);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.speakerPitch*15, attr|LEFT, 0, "+", "Hz");
if (attr) {
CHECK_INCDEC_GENVAR(event, g_eeGeneral.speakerPitch, 0, 20);
@ -279,23 +284,24 @@ bool menuGeneralSetup(evt_t event)
#if defined(VARIO)
case ITEM_SETUP_VARIO_LABEL:
lcd_putsLeft(y, STR_VARIO);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_VARIO);
break;
case ITEM_SETUP_VARIO_VOLUME:
SLIDER_5POS(y, g_eeGeneral.varioVolume, TR_SPEAKER_VOLUME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, TR_SPEAKER_VOLUME);
SLIDER_5POS(y, g_eeGeneral.varioVolume, event, attr);
break;
case ITEM_SETUP_VARIO_PITCH:
lcd_putsLeft(y, STR_PITCH_AT_ZERO);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PITCH_AT_ZERO);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, VARIO_FREQUENCY_ZERO+(g_eeGeneral.varioPitch*10), attr|LEFT, 0, NULL, "Hz");
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.varioPitch, -40, 40);
break;
case ITEM_SETUP_VARIO_RANGE:
lcd_putsLeft(y, STR_PITCH_AT_MAX);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PITCH_AT_MAX);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, VARIO_FREQUENCY_ZERO+(g_eeGeneral.varioPitch*10)+VARIO_FREQUENCY_RANGE+(g_eeGeneral.varioRange*10), attr|LEFT, 0, NULL, "Hz");
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.varioRange, -80, 80);
break;
case ITEM_SETUP_VARIO_REPEAT:
lcd_putsLeft(y, STR_REPEAT_AT_ZERO);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_REPEAT_AT_ZERO);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, VARIO_REPEAT_ZERO+(g_eeGeneral.varioRepeat*10), attr|LEFT, 0, NULL, STR_MS);
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.varioRepeat, -30, 50);
break;
@ -303,25 +309,28 @@ bool menuGeneralSetup(evt_t event)
#if defined(HAPTIC)
case ITEM_SETUP_HAPTIC_LABEL:
lcd_putsLeft(y, STR_HAPTIC_LABEL);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_HAPTIC_LABEL);
break;
case ITEM_SETUP_HAPTIC_MODE:
g_eeGeneral.hapticMode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_MODE, STR_VBEEPMODE, g_eeGeneral.hapticMode, -2, 1, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODE);
g_eeGeneral.hapticMode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_VBEEPMODE, g_eeGeneral.hapticMode, -2, 1, attr, event);
break;
case ITEM_SETUP_HAPTIC_LENGTH:
SLIDER_5POS(y, g_eeGeneral.hapticLength, STR_LENGTH, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_LENGTH);
SLIDER_5POS(y, g_eeGeneral.hapticLength, event, attr);
break;
case ITEM_SETUP_HAPTIC_STRENGTH:
SLIDER_5POS(y, g_eeGeneral.hapticStrength, STR_HAPTICSTRENGTH, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_HAPTICSTRENGTH);
SLIDER_5POS(y, g_eeGeneral.hapticStrength, event, attr);
break;
#endif
#if 0
case ITEM_SETUP_CONTRAST:
lcd_putsLeft(y, STR_CONTRAST);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CONTRAST);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.contrast, attr|LEFT);
if (attr) {
CHECK_INCDEC_GENVAR(event, g_eeGeneral.contrast, CONTRAST_MIN, CONTRAST_MAX);
@ -331,11 +340,11 @@ bool menuGeneralSetup(evt_t event)
#endif
case ITEM_SETUP_ALARMS_LABEL:
lcd_putsLeft(y, STR_ALARMS_LABEL);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ALARMS_LABEL);
break;
case ITEM_SETUP_BATTERY_WARNING:
lcd_putsLeft(y, STR_BATTERYWARNING);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BATTERYWARNING);
putsVolts(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.vBatWarn, attr|LEFT);
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.vBatWarn, 27, 42); // 2.7-4.2V
break;
@ -343,62 +352,66 @@ bool menuGeneralSetup(evt_t event)
#if 0
case ITEM_SETUP_MEMORY_WARNING:
{
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MEMORYWARNING);
uint8_t b = 1-g_eeGeneral.disableMemoryWarning;
g_eeGeneral.disableMemoryWarning = 1 - onoffMenuItem(b, RADIO_SETUP_2ND_COLUMN, y, STR_MEMORYWARNING, attr, event);
g_eeGeneral.disableMemoryWarning = 1 - onoffMenuItem(b, RADIO_SETUP_2ND_COLUMN, y, attr, event);
break;
}
#endif
case ITEM_SETUP_ALARM_WARNING:
{
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ALARMWARNING);
uint8_t b = 1-g_eeGeneral.disableAlarmWarning;
g_eeGeneral.disableAlarmWarning = 1 - onoffMenuItem(b, RADIO_SETUP_2ND_COLUMN, y, STR_ALARMWARNING, attr, event);
g_eeGeneral.disableAlarmWarning = 1 - onoffMenuItem(b, RADIO_SETUP_2ND_COLUMN, y, attr, event);
break;
}
#if defined(PCBSKY9X)
case ITEM_SETUP_CAPACITY_WARNING:
lcd_putsLeft(y, STR_CAPAWARNING);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CAPAWARNING);
putsValueWithUnit(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.mAhWarn*50, UNIT_MAH, attr|LEFT) ;
if(attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.mAhWarn, 0, 100);
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.mAhWarn, 0, 100);
break;
#endif
#if defined(PCBSKY9X)
case ITEM_SETUP_TEMPERATURE_WARNING:
lcd_putsLeft(y, STR_TEMPWARNING);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TEMPWARNING);
putsValueWithUnit(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.temperatureWarn, UNIT_TEMPERATURE, attr|LEFT) ;
if(attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.temperatureWarn, 0, 120); // 0 means no alarm
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.temperatureWarn, 0, 120); // 0 means no alarm
break;
#endif
case ITEM_SETUP_INACTIVITY_ALARM:
lcd_putsLeft( y,STR_INACTIVITYALARM);
lcdDrawText(MENUS_MARGIN_LEFT, y,STR_INACTIVITYALARM);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.inactivityTimer, attr|LEFT, 0, NULL, "m");
if (attr) g_eeGeneral.inactivityTimer = checkIncDec(event, g_eeGeneral.inactivityTimer, 0, 250, EE_GENERAL); //0..250minutes
break;
#if 0
case ITEM_SETUP_BACKLIGHT_LABEL:
lcd_putsLeft(y, STR_BACKLIGHT_LABEL);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BACKLIGHT_LABEL);
break;
case ITEM_SETUP_BACKLIGHT_MODE:
g_eeGeneral.backlightMode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_MODE, STR_VBLMODE, g_eeGeneral.backlightMode, e_backlight_mode_off, e_backlight_mode_on, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODE);
g_eeGeneral.backlightMode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_VBLMODE, g_eeGeneral.backlightMode, e_backlight_mode_off, e_backlight_mode_on, attr, event);
break;
case ITEM_SETUP_FLASH_BEEP:
g_eeGeneral.alarmsFlash = onoffMenuItem(g_eeGeneral.alarmsFlash, RADIO_SETUP_2ND_COLUMN, y, STR_ALARM, attr, event ) ;
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ALARM);
g_eeGeneral.alarmsFlash = onoffMenuItem(g_eeGeneral.alarmsFlash, RADIO_SETUP_2ND_COLUMN, y, attr, event ) ;
break;
case ITEM_SETUP_BACKLIGHT_DELAY:
lcd_putsLeft(y, STR_BLDELAY);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BLDELAY);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.lightAutoOff*5, attr|LEFT, 0, NULL, "s");
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.lightAutoOff, 0, 600/5);
break;
case ITEM_SETUP_BRIGHTNESS:
lcd_putsLeft(y, STR_BRIGHTNESS);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BRIGHTNESS);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, 100-g_eeGeneral.backlightBright, attr|LEFT) ;
if (attr) {
uint8_t b = 100 - g_eeGeneral.backlightBright;
@ -408,7 +421,7 @@ bool menuGeneralSetup(evt_t event)
break;
case ITEM_SETUP_BACKLIGHT_COLOR:
lcd_putsLeft(y, STR_BLCOLOR);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BLCOLOR);
drawSlider(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.backlightColor, 20, attr);
if (attr) g_eeGeneral.backlightColor = checkIncDec(event, g_eeGeneral.backlightColor, 0, 20, EE_GENERAL | NO_INCDEC_MARKS);
break;
@ -417,7 +430,7 @@ bool menuGeneralSetup(evt_t event)
#if 0
case ITEM_SETUP_DISABLE_SPLASH:
{
lcd_putsLeft(y, STR_SPLASHSCREEN);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SPLASHSCREEN);
if (SPLASH_NEEDED()) {
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, SPLASH_TIMEOUT/100, attr|LEFT, 0, NULL, "s");
}
@ -430,21 +443,23 @@ bool menuGeneralSetup(evt_t event)
#endif
case ITEM_SETUP_TIMEZONE:
lcd_putsLeft(y, STR_TIMEZONE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TIMEZONE);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, g_eeGeneral.timezone, attr|LEFT);
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.timezone, -12, 12);
break;
case ITEM_SETUP_GPSFORMAT:
g_eeGeneral.gpsFormat = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_GPSCOORD, STR_GPSFORMAT, g_eeGeneral.gpsFormat, 0, 1, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_GPSCOORD);
g_eeGeneral.gpsFormat = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_GPSFORMAT, g_eeGeneral.gpsFormat, 0, 1, attr, event);
break;
case ITEM_SETUP_COUNTRYCODE:
g_eeGeneral.countryCode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_COUNTRYCODE, STR_COUNTRYCODES, g_eeGeneral.countryCode, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_COUNTRYCODE);
g_eeGeneral.countryCode = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_COUNTRYCODES, g_eeGeneral.countryCode, 0, 2, attr, event);
break;
case ITEM_SETUP_LANGUAGE:
lcd_putsLeft(y, STR_VOICELANG);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_VOICELANG);
lcdDrawText(RADIO_SETUP_2ND_COLUMN, y, currentLanguagePack->name, attr);
if (attr) {
currentLanguagePackIdx = checkIncDec(event, currentLanguagePackIdx, 0, DIM(languagePacks)-2, EE_GENERAL);
@ -456,12 +471,14 @@ bool menuGeneralSetup(evt_t event)
break;
case ITEM_SETUP_IMPERIAL:
g_eeGeneral.imperial = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_UNITSSYSTEM, STR_VUNITSSYSTEM, g_eeGeneral.imperial, 0, 1, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_UNITSSYSTEM);
g_eeGeneral.imperial = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_VUNITSSYSTEM, g_eeGeneral.imperial, 0, 1, attr, event);
break;
#if 0
case ITEM_SETUP_FAI:
onoffMenuItem(g_eeGeneral.fai, RADIO_SETUP_2ND_COLUMN, y, PSTR("FAI Mode"), attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, PSTR("FAI Mode"));
onoffMenuItem(g_eeGeneral.fai, RADIO_SETUP_2ND_COLUMN, y, attr, event);
if (attr && checkIncDec_Ret) {
if (g_eeGeneral.fai)
POPUP_WARNING(PSTR("FAI\001mode blocked!"));
@ -473,19 +490,20 @@ bool menuGeneralSetup(evt_t event)
#if defined(MAVLINK)
case ITEM_MAVLINK_BAUD:
g_eeGeneral.mavbaud = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_MAVLINK_BAUD_LABEL, STR_MAVLINK_BAUDS, g_eeGeneral.mavbaud, 0, 7, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MAVLINK_BAUD_LABEL);
g_eeGeneral.mavbaud = selectMenuItem(RADIO_SETUP_2ND_COLUMN, y, STR_MAVLINK_BAUDS, g_eeGeneral.mavbaud, 0, 7, attr, event);
break;
#endif
case ITEM_SETUP_SWITCHES_DELAY:
lcd_putsLeft(y, STR_SWITCHES_DELAY);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SWITCHES_DELAY);
lcdDrawNumber(RADIO_SETUP_2ND_COLUMN, y, 10*SWITCHES_DELAY(), attr|LEFT, 0, NULL, STR_MS);
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.switchesDelay, -15, +15);
break;
case ITEM_SETUP_RX_CHANNEL_ORD:
{
lcd_putsLeft(y, STR_RXCHANNELORD); // RAET->AETR
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_RXCHANNELORD); // RAET->AETR
char s[5];
for (uint8_t i=0; i<4; i++) {
s[i] = STR_RETA123[channel_order(i+1)];
@ -498,7 +516,7 @@ bool menuGeneralSetup(evt_t event)
case ITEM_SETUP_STICK_MODE:
{
lcd_putsLeft(y, NO_INDENT(STR_MODE));
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_MODE));
char s[2] = " ";
s[0] = '1'+g_eeGeneral.stickMode;
lcdDrawText(RADIO_SETUP_2ND_COLUMN, y, s, attr);

2
radio/src/gui/Horus/menu_general_trainer.cpp
View file

@ -97,7 +97,7 @@ bool menuGeneralTrainer(evt_t event)
}
attr = (sub==5) ? blink : 0;
lcd_putsLeft(MENU_CONTENT_TOP + 5*FH, STR_MULTIPLIER);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 5*FH, STR_MULTIPLIER);
lcdDrawNumber(TRAINER_COLUMN_1, MENU_CONTENT_TOP + 5*FH, g_eeGeneral.PPM_Multiplier+10, LEFT|attr|PREC1);
if (attr) CHECK_INCDEC_GENVAR(event, g_eeGeneral.PPM_Multiplier, -10, 40);

8
radio/src/gui/Horus/menu_general_version.cpp
View file

@ -40,10 +40,10 @@ bool menuGeneralVersion(evt_t event)
{
SIMPLE_MENU(STR_MENUVERSION, menuTabGeneral, e_Vers, 1, DEFAULT_SCROLLBAR_X);
lcd_putsLeft(MENU_CONTENT_TOP + FH, vers_stamp);
lcd_putsLeft(MENU_CONTENT_TOP + 2*FH, date_stamp);
lcd_putsLeft(MENU_CONTENT_TOP + 3*FH, time_stamp);
lcd_putsLeft(MENU_CONTENT_TOP + 4*FH, eeprom_stamp);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + FH, vers_stamp);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 2*FH, date_stamp);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 3*FH, time_stamp);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 4*FH, eeprom_stamp);
// TODO EEPROM erase + backup
// lcd_putsCenter(MENU_HEADER_HEIGHT+6*FH, STR_EEBACKUP);

10
radio/src/gui/Horus/menu_model.cpp
View file

@ -77,14 +77,12 @@ void editCurveRef(coord_t x, coord_t y, CurveRef & curve, evt_t event, uint8_t a
#define MIXES_2ND_COLUMN 100
uint8_t editDelay(const coord_t x, const coord_t y, const evt_t event, const uint8_t attr, const pm_char *str, uint8_t delay)
uint8_t editDelay(const coord_t x, const coord_t y, const evt_t event, const uint8_t attr, uint8_t delay)
{
lcdDrawText(x+MENUS_MARGIN_LEFT, y, str, TEXT_COLOR);
lcdDrawNumber(x+MIXES_2ND_COLUMN, y, (10/DELAY_STEP)*delay, attr|PREC1|LEFT);
if (attr) CHECK_INCDEC_MODELVAR_ZERO(event, delay, DELAY_MAX);
return delay;
}
#define EDIT_DELAY(x, y, event, attr, str, delay) editDelay(x, y, event, attr, str, delay)
const MenuFuncP menuTabModel[] = {
// menuModelSelect,
@ -201,10 +199,4 @@ void editName(coord_t x, coord_t y, char * name, uint8_t size, evt_t event, uint
}
}
void editSingleName(coord_t x, coord_t y, const pm_char *label, char *name, uint8_t size, evt_t event, uint8_t active)
{
lcd_putsLeft(y, label);
editName(x, y, name, size, event, active);
}
static uint8_t s_currIdx;

8
radio/src/gui/Horus/menu_model_curves.cpp
View file

@ -145,11 +145,11 @@ bool menuModelCurveOne(evt_t event)
lcdDrawNumber(MENU_TITLE_NEXT_POS, MENU_TITLE_TOP+2, s_curveChan+1, LEFT|HEADER_COLOR);
lcd_putsLeft(MENU_CONTENT_TOP, STR_NAME);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP, STR_NAME);
editName(MENUS_MARGIN_LEFT+INDENT_WIDTH, MENU_CONTENT_TOP + FH, g_model.curveNames[s_curveChan], sizeof(g_model.curveNames[s_curveChan]), event, m_posVert==0);
LcdFlags attr = (m_posVert==1 ? (s_editMode>0 ? INVERS|BLINK : INVERS) : 0);
lcd_putsLeft(MENU_CONTENT_TOP + 2*FH, "Type");
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 2*FH, "Type");
lcdDrawTextAtIndex(MENUS_MARGIN_LEFT+INDENT_WIDTH, MENU_CONTENT_TOP + 3*FH, STR_CURVE_TYPES, crv.type, attr);
if (attr) {
uint8_t newType = checkIncDecModelZero(event, crv.type, CURVE_TYPE_LAST);
@ -166,7 +166,7 @@ bool menuModelCurveOne(evt_t event)
}
attr = (m_posVert==2 ? (s_editMode>0 ? INVERS|BLINK : INVERS) : 0);
lcd_putsLeft(MENU_CONTENT_TOP + 4*FH, STR_COUNT);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 4*FH, STR_COUNT);
lcdDrawNumber(MENUS_MARGIN_LEFT+INDENT_WIDTH, MENU_CONTENT_TOP + 5*FH, 5+crv.points, LEFT|attr, 0, NULL, STR_PTS);
if (attr) {
int count = checkIncDecModel(event, crv.points, -3, 12); // 2pts - 17pts
@ -186,7 +186,7 @@ bool menuModelCurveOne(evt_t event)
}
}
lcd_putsLeft(MENU_CONTENT_TOP + 6*FH, STR_SMOOTH);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_CONTENT_TOP + 6*FH, STR_SMOOTH);
drawCheckBox(lcdNextPos + 10, MENU_CONTENT_TOP + 6*FH, crv.smooth, m_posVert==3 ? INVERS : 0);
if (m_posVert==3) crv.smooth = checkIncDecModel(event, crv.smooth, 0, 1);

11
radio/src/gui/Horus/menu_model_heli.cpp
View file

@ -63,17 +63,18 @@ bool menuModelHeli(evt_t event)
switch(k) {
case ITEM_HELI_SWASHTYPE:
g_model.swashR.type = selectMenuItem(MODEL_HELI_2ND_COLUMN, y, STR_SWASHTYPE, STR_VSWASHTYPE, g_model.swashR.type, 0, SWASH_TYPE_MAX, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SWASHTYPE);
g_model.swashR.type = selectMenuItem(MODEL_HELI_2ND_COLUMN, y, STR_VSWASHTYPE, g_model.swashR.type, 0, SWASH_TYPE_MAX, attr, event);
break;
case ITEM_HELI_SWASHRING:
lcd_putsLeft(y, STR_SWASHRING);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SWASHRING);
lcdDrawNumber(MODEL_HELI_2ND_COLUMN, y, g_model.swashR.value, LEFT|attr);
if (attr) CHECK_INCDEC_MODELVAR_ZERO(event, g_model.swashR.value, 100);
break;
case ITEM_HELI_ELE:
lcd_putsLeft(y, STR_ELEVATOR);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ELEVATOR);
putsMixerSource(MODEL_HELI_2ND_COLUMN, y, g_model.swashR.elevatorSource, attr);
if (attr) CHECK_INCDEC_MODELSOURCE(event, g_model.swashR.elevatorSource, 0, MIXSRC_LAST_CH);
break;
@ -85,7 +86,7 @@ bool menuModelHeli(evt_t event)
break;
case ITEM_HELI_AIL:
lcd_putsLeft(y, STR_AILERON);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_AILERON);
putsMixerSource(MODEL_HELI_2ND_COLUMN, y, g_model.swashR.aileronSource, attr);
if (attr) CHECK_INCDEC_MODELSOURCE(event, g_model.swashR.aileronSource, 0, MIXSRC_LAST_CH);
break;
@ -97,7 +98,7 @@ bool menuModelHeli(evt_t event)
break;
case ITEM_HELI_COL:
lcd_putsLeft(y, STR_COLLECTIVE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_COLLECTIVE);
putsMixerSource(MODEL_HELI_2ND_COLUMN, y, g_model.swashR.collectiveSource, attr);
if (attr) CHECK_INCDEC_MODELSOURCE(event, g_model.swashR.collectiveSource, 0, MIXSRC_LAST_CH);
break;

199
radio/src/gui/Horus/menu_model_inputs_mixes.cpp
View file

@ -53,8 +53,6 @@ void displayFlightModes(coord_t x, coord_t y, FlightModesType value, uint8_t att
FlightModesType editFlightModes(coord_t x, coord_t y, evt_t event, FlightModesType value, uint8_t attr)
{
lcd_putsColumnLeft(x, y, STR_FLMODE);
int posHorz = m_posHorz;
displayFlightModes(x, y, value, attr);
@ -96,20 +94,46 @@ coord_t getYCoord(FnFuncP fn, coord_t x)
void DrawFunction(FnFuncP fn, int offset)
{
lcdDrawVerticalLine(CURVE_CENTER_X-offset, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2, 0xee, CURVE_AXIS_COLOR);
lcdDrawHorizontalLine(CURVE_CENTER_X-CURVE_SIDE_WIDTH-offset, CURVE_CENTER_Y, CURVE_SIDE_WIDTH*2, 0xee, CURVE_AXIS_COLOR);
int left = CURVE_CENTER_X-offset-CURVE_SIDE_WIDTH;
int right = CURVE_CENTER_X-offset+CURVE_SIDE_WIDTH;
int center = CURVE_CENTER_X-offset;
// Axis
lcdDrawSolidHorizontalLine(left, CURVE_CENTER_Y, CURVE_SIDE_WIDTH*2+1, CURVE_AXIS_COLOR);
lcdDrawSolidVerticalLine(center, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2, CURVE_AXIS_COLOR);
// Extra lines
lcdDrawVerticalLine(left+CURVE_SIDE_WIDTH/2, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2, STASHED, CURVE_AXIS_COLOR);
lcdDrawVerticalLine(right-CURVE_SIDE_WIDTH/2, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2, STASHED, CURVE_AXIS_COLOR);
lcdDrawHorizontalLine(left, CURVE_CENTER_Y-CURVE_SIDE_WIDTH/2, CURVE_SIDE_WIDTH*2+1, STASHED, CURVE_AXIS_COLOR);
lcdDrawHorizontalLine(left, CURVE_CENTER_Y+CURVE_SIDE_WIDTH/2, CURVE_SIDE_WIDTH*2+1, STASHED, CURVE_AXIS_COLOR);
// Outside border
lcdDrawSolidVerticalLine(left, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2, TEXT_COLOR);
lcdDrawSolidVerticalLine(right, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2, TEXT_COLOR);
lcdDrawSolidHorizontalLine(left, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2+1, TEXT_COLOR);
lcdDrawSolidHorizontalLine(left, CURVE_CENTER_Y+CURVE_SIDE_WIDTH, CURVE_SIDE_WIDTH*2+1, TEXT_COLOR);
// Horizontal / Vertical scale
for (int i=0; i<=20; i++) {
lcdDrawSolidHorizontalLine(left-15, CURVE_CENTER_Y-CURVE_SIDE_WIDTH+i*CURVE_SIDE_WIDTH/10, 10, TEXT_COLOR);
lcdDrawSolidVerticalLine(left+i*CURVE_SIDE_WIDTH/10, CURVE_CENTER_Y+CURVE_SIDE_WIDTH+5, 10, TEXT_COLOR);
}
coord_t prev_yv = (coord_t)-1;
for (int xv=-CURVE_SIDE_WIDTH; xv<=CURVE_SIDE_WIDTH; xv++) {
for (int xv=-CURVE_SIDE_WIDTH; xv<=CURVE_SIDE_WIDTH; xv+=1) {
coord_t yv = getYCoord(fn, xv);
if (prev_yv != (coord_t)-1) {
if (abs(yv-prev_yv) <= 1) {
lcdDrawPoint(CURVE_CENTER_X+xv-offset-1, prev_yv, CURVE_COLOR);
if (prev_yv < yv) {
for (int y=prev_yv; y<=yv; y+=1) {
lcdDrawBitmapPattern(CURVE_CENTER_X+xv-offset-2, y-2, LBM_POINT, TEXT_COLOR);
}
}
else {
uint8_t tmp = (prev_yv < yv ? 0 : 1);
lcdDrawSolidVerticalLine(CURVE_CENTER_X+xv-offset-1, yv+tmp, prev_yv-yv, CURVE_COLOR);
for (int y=yv; y<=prev_yv; y+=1) {
lcdDrawBitmapPattern(CURVE_CENTER_X+xv-offset-2, y-2, LBM_POINT, TEXT_COLOR);
}
}
}
prev_yv = yv;
@ -325,7 +349,6 @@ enum ExposFields {
EXPO_FIELD_INPUT_NAME,
EXPO_FIELD_NAME,
EXPO_FIELD_SOURCE,
EXPO_FIELD_SCALE,
EXPO_FIELD_WEIGHT,
EXPO_FIELD_OFFSET,
CASE_CURVES(EXPO_FIELD_CURVE)
@ -342,102 +365,111 @@ bool menuModelExpoOne(evt_t event)
{
ExpoData *ed = expoAddress(s_currIdx);
SUBMENU(STR_MENUINPUTS, EXPO_FIELD_MAX, EXPO_ONE_2ND_COLUMN+85, { 0, 0, 0, (ed->srcRaw >= MIXSRC_FIRST_TELEM ? (uint8_t)0 : (uint8_t)HIDDEN_ROW), 0, 0, CASE_CURVES(CURVE_ROWS) CASE_FLIGHT_MODES((MAX_FLIGHT_MODES-1) | NAVIGATION_LINE_BY_LINE) 0 /*, ...*/});
SUBMENU(STR_MENUINPUTS, EXPO_FIELD_MAX, 0, { 0, 0, (ed->srcRaw >= MIXSRC_FIRST_TELEM ? (uint8_t)1 : (uint8_t)0), 0, 0, CASE_CURVES(CURVE_ROWS) CASE_FLIGHT_MODES((MAX_FLIGHT_MODES-1) | NAVIGATION_LINE_BY_LINE) 0 /*, ...*/});
putsMixerSource(MENU_TITLE_NEXT_POS, MENU_TITLE_TOP+2, MIXSRC_FIRST_INPUT+ed->chn, HEADER_COLOR);
int8_t sub = m_posVert;
int sub = m_posVert;
coord_t y = MENU_CONTENT_TOP;
DrawFunction(expoFn);
{
char textx[5];
char texty[5];
int x = getValue(ed->srcRaw);
if (ed->srcRaw >= MIXSRC_FIRST_TELEM) {
putsTelemetryChannelValue(LCD_W-8, 6*FH, ed->srcRaw - MIXSRC_FIRST_TELEM, x);
sprintf(textx, "%d", calcRESXto100(x));
// TODO putsTelemetryChannelValue(LCD_W-8, 6*FH, ed->srcRaw - MIXSRC_FIRST_TELEM, x);
if (ed->scale > 0) x = (x * 1024) / convertTelemValue(ed->srcRaw - MIXSRC_FIRST_TELEM + 1, ed->scale);
}
else {
lcdDrawNumber(CURVE_CENTER_X+CURVE_SIDE_WIDTH, CURVE_CENTER_Y+CURVE_SIDE_WIDTH-FH+6, calcRESXto1000(x), PREC1);
sprintf(textx, "%d", calcRESXto100(x));
}
x = limit(-1024, x, 1024);
int y = limit<int>(-1024, expoFn(x), 1024);
lcdDrawNumber(CURVE_CENTER_X-CURVE_SIDE_WIDTH, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, calcRESXto1000(y), LEFT|PREC1);
sprintf(texty, "%d", calcRESXto100(y));
x = divRound(x*CURVE_SIDE_WIDTH, RESX);
y = getYCoord(expoFn, x);
lcdDrawVerticalLine(CURVE_CENTER_X+x, y-3, 7, SOLID, CURVE_CURSOR_COLOR);
lcdDrawHorizontalLine(CURVE_CENTER_X+x-3, y, 7, SOLID, CURVE_CURSOR_COLOR);
lcdDrawSolidFilledRect(CURVE_CENTER_X+x, CURVE_CENTER_Y-CURVE_SIDE_WIDTH, 2, 2*CURVE_SIDE_WIDTH+2, CURVE_CURSOR_COLOR);
lcdDrawSolidFilledRect(CURVE_CENTER_X-CURVE_SIDE_WIDTH-2, y-1, 2*CURVE_SIDE_WIDTH+2, 2, CURVE_CURSOR_COLOR);
lcdDrawBitmapPattern(CURVE_CENTER_X+x-4, y-4, LBM_CURVE_POINT, CURVE_CURSOR_COLOR);
lcdDrawBitmapPattern(CURVE_CENTER_X+x-4, y-4, LBM_CURVE_POINT_CENTER, TEXT_BGCOLOR);
int left = (x < -30 ? CURVE_CENTER_X+x : (x > 30 ? CURVE_CENTER_X+x-34 : CURVE_CENTER_X-17+x/2));
lcdDrawSolidFilledRect(left, CURVE_CENTER_Y+CURVE_SIDE_WIDTH+2, 36, 17, CURVE_CURSOR_COLOR);
lcdDrawText(left+3+(35-getTextWidth(textx, SMLSIZE))/2, CURVE_CENTER_Y+CURVE_SIDE_WIDTH+3, textx, LEFT|SMLSIZE|TEXT_BGCOLOR);
int top = (y < CURVE_CENTER_Y-8 ? y-1 : (y > CURVE_CENTER_Y+8 ? y-16 : CURVE_CENTER_Y-8+(y-CURVE_CENTER_Y)/2));
lcdDrawSolidFilledRect(CURVE_CENTER_X-CURVE_SIDE_WIDTH-37, top, 36, 17, CURVE_CURSOR_COLOR);
lcdDrawText(CURVE_CENTER_X-CURVE_SIDE_WIDTH-34+(35-getTextWidth(texty, SMLSIZE))/2, top+1, texty, LEFT|SMLSIZE|TEXT_BGCOLOR);
}
for (unsigned int k=0; k<NUM_BODY_LINES; k++) {
int i = k + s_pgOfs;
for (int j=0; j<=i; ++j) {
if (j<(int)DIM(mstate_tab) && mstate_tab[j] == HIDDEN_ROW) {
++i;
}
}
for (int i=0; i<NUM_BODY_LINES+1; i++) {
LcdFlags attr = (sub==i ? (s_editMode>0 ? BLINK|INVERS : INVERS) : 0);
switch(i)
{
switch (i) {
case EXPO_FIELD_INPUT_NAME:
editSingleName(EXPO_ONE_2ND_COLUMN, y, STR_INPUTNAME, g_model.inputNames[ed->chn], sizeof(g_model.inputNames[ed->chn]), event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_INPUTNAME);
editName(EXPO_ONE_2ND_COLUMN, y, g_model.inputNames[ed->chn], sizeof(g_model.inputNames[ed->chn]), event, attr);
break;
case EXPO_FIELD_NAME:
editSingleName(EXPO_ONE_2ND_COLUMN, y, STR_EXPONAME, ed->name, sizeof(ed->name), event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_EXPONAME);
editName(EXPO_ONE_2ND_COLUMN, y, ed->name, sizeof(ed->name), event, attr);
break;
case EXPO_FIELD_SOURCE:
lcd_putsLeft(y, NO_INDENT(STR_SOURCE));
putsMixerSource(EXPO_ONE_2ND_COLUMN, y, ed->srcRaw, STREXPANDED|attr);
if (attr) ed->srcRaw = checkIncDec(event, ed->srcRaw, INPUTSRC_FIRST, INPUTSRC_LAST, EE_MODEL|INCDEC_SOURCE|NO_INCDEC_MARKS, isInputSourceAvailable);
break;
case EXPO_FIELD_SCALE:
lcd_putsLeft(y, STR_SCALE);
putsTelemetryChannelValue(EXPO_ONE_2ND_COLUMN, y, (ed->srcRaw - MIXSRC_FIRST_TELEM)/3, convertTelemValue(ed->srcRaw - MIXSRC_FIRST_TELEM + 1, ed->scale), LEFT|attr);
if (attr) ed->scale = checkIncDec(event, ed->scale, 0, maxTelemValue(ed->srcRaw - MIXSRC_FIRST_TELEM + 1), EE_MODEL);
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_SOURCE));
putsMixerSource(EXPO_ONE_2ND_COLUMN, y, ed->srcRaw, STREXPANDED|(m_posHorz==0?attr:0));
if (attr && m_posHorz==0) ed->srcRaw = checkIncDec(event, ed->srcRaw, INPUTSRC_FIRST, INPUTSRC_LAST, EE_MODEL|INCDEC_SOURCE|NO_INCDEC_MARKS, isInputSourceAvailable);
if (ed->srcRaw >= MIXSRC_FIRST_TELEM) {
putsTelemetryChannelValue(EXPO_ONE_2ND_COLUMN+60, y, (ed->srcRaw - MIXSRC_FIRST_TELEM)/3, convertTelemValue(ed->srcRaw - MIXSRC_FIRST_TELEM + 1, ed->scale), LEFT|(m_posHorz==1?attr:0));
if (attr && m_posHorz == 1) ed->scale = checkIncDec(event, ed->scale, 0, maxTelemValue(ed->srcRaw - MIXSRC_FIRST_TELEM + 1), EE_MODEL);
}
else if (attr) {
m_posHorz = 0;
}
break;
case EXPO_FIELD_WEIGHT:
lcd_putsLeft(y, STR_WEIGHT);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_WEIGHT);
ed->weight = GVAR_MENU_ITEM(EXPO_ONE_2ND_COLUMN, y, ed->weight, MIN_EXPO_WEIGHT, 100, LEFT|attr, 0, event);
break;
case EXPO_FIELD_OFFSET:
lcd_putsLeft(y, NO_INDENT(STR_OFFSET));
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_OFFSET));
ed->offset = GVAR_MENU_ITEM(EXPO_ONE_2ND_COLUMN, y, ed->offset, -100, 100, LEFT|attr, 0, event);
break;
#if defined(CURVES)
case EXPO_FIELD_CURVE:
lcd_putsLeft(y, STR_CURVE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CURVE);
editCurveRef(EXPO_ONE_2ND_COLUMN, y, ed->curve, event, attr);
break;
#endif
#if defined(FLIGHT_MODES)
case EXPO_FIELD_FLIGHT_MODES:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_FLMODE);
ed->flightModes = editFlightModes(EXPO_ONE_2ND_COLUMN, y, event, ed->flightModes, attr);
break;
#endif
case EXPO_FIELD_SWITCH:
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SWITCH);
ed->swtch = switchMenuItem(EXPO_ONE_2ND_COLUMN, y, ed->swtch, attr, event);
break;
case EXPO_FIELD_SIDE:
ed->mode = 4 - selectMenuItem(EXPO_ONE_2ND_COLUMN, y, STR_SIDE, STR_VSIDE, 4-ed->mode, 1, 3, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SIDE);
ed->mode = 4 - selectMenuItem(EXPO_ONE_2ND_COLUMN, y, STR_VSIDE, 4-ed->mode, 1, 3, attr, event);
break;
case EXPO_FIELD_TRIM:
uint8_t not_stick = (ed->srcRaw > MIXSRC_Ail);
int8_t carryTrim = -ed->carryTrim;
lcd_putsLeft(y, STR_TRIM);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TRIM);
lcdDrawTextAtIndex(EXPO_ONE_2ND_COLUMN, y, STR_VMIXTRIMS, (not_stick && carryTrim == 0) ? 0 : carryTrim+1, m_posHorz==0 ? attr : 0);
if (attr) ed->carryTrim = -checkIncDecModel(event, carryTrim, not_stick ? TRIM_ON : -TRIM_OFF, -TRIM_AIL);
break;
@ -474,6 +506,7 @@ void gvarWeightItem(coord_t x, coord_t y, MixData *md, uint8_t attr, evt_t event
MD_UNION_TO_WEIGHT(weight, md);
}
#if 0
#define GAUGE_WIDTH 33
#define GAUGE_HEIGHT 6
void drawOffsetBar(uint8_t x, uint8_t y, MixData * md)
@ -492,15 +525,14 @@ void drawOffsetBar(uint8_t x, uint8_t y, MixData * md)
barMax = 101;
lcdDrawHorizontalLine(x-2, y, GAUGE_WIDTH+2, DOTTED);
lcdDrawHorizontalLine(x-2, y+GAUGE_HEIGHT, GAUGE_WIDTH+2, DOTTED);
// lcdDrawSolidVerticalLine(x-2, y+1, GAUGE_HEIGHT-1);
// lcdDrawSolidVerticalLine(x+GAUGE_WIDTH-1, y+1, GAUGE_HEIGHT-1);
lcdDrawSolidVerticalLine(x-2, y+1, GAUGE_HEIGHT-1);
lcdDrawSolidVerticalLine(x+GAUGE_WIDTH-1, y+1, GAUGE_HEIGHT-1);
if (barMin <= barMax) {
int8_t right = (barMax * GAUGE_WIDTH) / 200;
int8_t left = ((barMin * GAUGE_WIDTH) / 200)-1;
// lcdDrawSolidFilledRect(x+GAUGE_WIDTH/2+left, y+2, right-left, GAUGE_HEIGHT-3);
lcdDrawSolidFilledRect(x+GAUGE_WIDTH/2+left, y+2, right-left, GAUGE_HEIGHT-3);
}
// lcdDrawSolidVerticalLine(x+GAUGE_WIDTH/2-1, y, GAUGE_HEIGHT+1);
#if 0 // TODO
lcdDrawSolidVerticalLine(x+GAUGE_WIDTH/2-1, y, GAUGE_HEIGHT+1);
if (barMin == -101) {
for (uint8_t i=0; i<3; ++i) {
lcdDrawPoint(x+i, y+4-i);
@ -513,10 +545,10 @@ void drawOffsetBar(uint8_t x, uint8_t y, MixData * md)
lcdDrawPoint(x+GAUGE_WIDTH-5+i, y+4-i);
}
}
#endif
}
#undef GAUGE_WIDTH
#undef GAUGE_HEIGHT
#endif
bool menuModelMixOne(evt_t event)
{
@ -524,47 +556,45 @@ bool menuModelMixOne(evt_t event)
SUBMENU(s_currCh ? STR_INSERTMIX : STR_EDITMIX, MIX_FIELD_COUNT, 0, { 0, 0, 0, 0, 0, CASE_CURVES(1) CASE_FLIGHT_MODES((MAX_FLIGHT_MODES-1) | NAVIGATION_LINE_BY_LINE) 0 /*, ...*/ });
putsChn(MENU_TITLE_NEXT_POS, MENU_TITLE_TOP+2, md2->destCh+1, HEADER_COLOR);
putsChn(MENU_TITLE_NEXT_POS, MENU_TITLE_TOP+1, md2->destCh+1, TEXT_COLOR);
// The separation line between 2 columns
lcdDrawVerticalLine(MENU_COLUMN2_X, DEFAULT_SCROLLBAR_Y, DEFAULT_SCROLLBAR_H, SOLID, HEADER_COLOR);
lcdDrawSolidVerticalLine(MENU_COLUMN2_X-20, DEFAULT_SCROLLBAR_Y, DEFAULT_SCROLLBAR_H+5, TEXT_COLOR);
int8_t sub = m_posVert;
int8_t editMode = s_editMode;
for (int k=0; k<2*NUM_BODY_LINES; k++) {
coord_t y;
coord_t x;
if (k >= NUM_BODY_LINES) {
y = MENU_CONTENT_TOP + (k-NUM_BODY_LINES)*FH;
x = MENU_COLUMN2_X;
y = MENU_CONTENT_TOP + (k-NUM_BODY_LINES)*FH + 2;
}
else {
y = MENU_CONTENT_TOP + k*FH;
x = 0;
y = MENU_CONTENT_TOP + k*FH + 2;
}
int8_t i = k;
LcdFlags attr = (sub==i ? (editMode>0 ? BLINK|INVERS : INVERS) : 0);
switch(i) {
case MIX_FIELD_NAME:
editSingleName(x+MIXES_2ND_COLUMN, y, STR_MIXNAME, md2->name, sizeof(md2->name), event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MIXNAME);
editName(MIXES_2ND_COLUMN, y, md2->name, sizeof(md2->name), event, attr);
break;
case MIX_FIELD_SOURCE:
lcd_putsLeft(y, NO_INDENT(STR_SOURCE));
putsMixerSource(x+MIXES_2ND_COLUMN, y, md2->srcRaw, STREXPANDED|attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_SOURCE));
putsMixerSource(MIXES_2ND_COLUMN, y, md2->srcRaw, STREXPANDED|attr);
if (attr) CHECK_INCDEC_MODELSOURCE(event, md2->srcRaw, 1, MIXSRC_LAST);
break;
case MIX_FIELD_WEIGHT:
lcd_putsColumnLeft(x, y, STR_WEIGHT);
gvarWeightItem(x+MIXES_2ND_COLUMN, y, md2, attr|LEFT, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_WEIGHT);
gvarWeightItem(MIXES_2ND_COLUMN, y, md2, attr|LEFT, event);
break;
case MIX_FIELD_OFFSET:
{
lcd_putsColumnLeft(x, y, NO_INDENT(STR_OFFSET));
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_OFFSET));
u_int8int16_t offset;
MD_OFFSET_TO_UNION(md2, offset);
offset.word = GVAR_MENU_ITEM(x+MIXES_2ND_COLUMN, y, offset.word, GV_RANGELARGE_OFFSET_NEG, GV_RANGELARGE_OFFSET, attr|LEFT, 0, event);
offset.word = GVAR_MENU_ITEM(MIXES_2ND_COLUMN, y, offset.word, GV_RANGELARGE_OFFSET_NEG, GV_RANGELARGE_OFFSET, attr|LEFT, 0, event);
MD_UNION_TO_OFFSET(offset, md2);
#if 0
drawOffsetBar(x+MIXES_2ND_COLUMN+22, y, md2);
@ -572,50 +602,45 @@ bool menuModelMixOne(evt_t event)
break;
}
case MIX_FIELD_TRIM:
lcd_putsColumnLeft(x, y, STR_TRIM);
drawCheckBox(x+MIXES_2ND_COLUMN, y, !md2->carryTrim, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TRIM);
drawCheckBox(MIXES_2ND_COLUMN, y, !md2->carryTrim, attr);
if (attr) md2->carryTrim = !checkIncDecModel(event, !md2->carryTrim, 0, 1);
break;
#if defined(CURVES)
case MIX_FIELD_CURVE:
{
lcd_putsColumnLeft(x, y, STR_CURVE);
editCurveRef(x+MIXES_2ND_COLUMN, y, md2->curve, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CURVE);
editCurveRef(MIXES_2ND_COLUMN, y, md2->curve, event, attr);
break;
}
#endif
#if defined(FLIGHT_MODES)
case MIX_FIELD_FLIGHT_PHASE:
md2->flightModes = editFlightModes(x+MIXES_2ND_COLUMN, y, event, md2->flightModes, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_FLMODE);
md2->flightModes = editFlightModes(MIXES_2ND_COLUMN, y, event, md2->flightModes, attr);
break;
#endif
case MIX_FIELD_SWITCH:
md2->swtch = switchMenuItem(x+MIXES_2ND_COLUMN, y, md2->swtch, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SWITCH);
md2->swtch = switchMenuItem(MIXES_2ND_COLUMN, y, md2->swtch, attr, event);
break;
#if 0
case MIX_FIELD_WARNING:
lcd_putsColumnLeft(x+MIXES_2ND_COLUMN, y, STR_MIXWARNING);
if (md2->mixWarn)
lcdDrawNumber(x+MIXES_2ND_COLUMN, y, md2->mixWarn, attr|LEFT);
else
lcdDrawText(x+MIXES_2ND_COLUMN, y, STR_OFF, attr);
if (attr) CHECK_INCDEC_MODELVAR_ZERO(event, md2->mixWarn, 3);
break;
#endif
case MIX_FIELD_MLTPX:
md2->mltpx = selectMenuItem(x+MIXES_2ND_COLUMN, y, STR_MULTPX, STR_VMLTPX, md2->mltpx, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MULTPX);
md2->mltpx = selectMenuItem(MIXES_2ND_COLUMN, y, STR_VMLTPX, md2->mltpx, 0, 2, attr, event);
break;
case MIX_FIELD_DELAY_UP:
md2->delayUp = EDIT_DELAY(x, y, event, attr, STR_DELAYUP, md2->delayUp);
lcdDrawText(MENU_COLUMN2_X+MENUS_MARGIN_LEFT, y, STR_DELAYUP);
md2->delayUp = editDelay(MENU_COLUMN2_X, y, event, attr, md2->delayUp);
break;
case MIX_FIELD_DELAY_DOWN:
md2->delayDown = EDIT_DELAY(x, y, event, attr, STR_DELAYDOWN, md2->delayDown);
lcdDrawText(MENU_COLUMN2_X+MENUS_MARGIN_LEFT, y, STR_DELAYDOWN);
md2->delayDown = editDelay(MENU_COLUMN2_X, y, event, attr, md2->delayDown);
break;
case MIX_FIELD_SLOW_UP:
md2->speedUp = EDIT_DELAY(x, y, event, attr, STR_SLOWUP, md2->speedUp);
lcdDrawText(MENU_COLUMN2_X+MENUS_MARGIN_LEFT, y, STR_SLOWUP);
md2->speedUp = editDelay(MENU_COLUMN2_X, y, event, attr, md2->speedUp);
break;
case MIX_FIELD_SLOW_DOWN:
md2->speedDown = EDIT_DELAY(x, y, event, attr, STR_SLOWDOWN, md2->speedDown);
lcdDrawText(MENU_COLUMN2_X+MENUS_MARGIN_LEFT, y, STR_SLOWDOWN);
md2->speedDown = editDelay(MENU_COLUMN2_X, y, event, attr, md2->speedDown);
break;
}
}

97
radio/src/gui/Horus/menu_model_setup.cpp
View file

@ -122,7 +122,7 @@ void editTimerMode(int timerIdx, coord_t y, LcdFlags attr, evt_t event)
{
TimerData * timer = &g_model.timers[timerIdx];
if (attr && m_posHorz < 0) {
lcdDrawSolidFilledRect(MODEL_SETUP_2ND_COLUMN-INVERT_HORZ_MARGIN, y-INVERT_VERT_MARGIN, 90+2*INVERT_HORZ_MARGIN, INVERT_LINE_HEIGHT, TEXT_INVERTED_BGCOLOR);
lcdDrawSolidFilledRect(MODEL_SETUP_2ND_COLUMN-INVERT_HORZ_MARGIN, y-INVERT_VERT_MARGIN+1, 90+2*INVERT_HORZ_MARGIN, INVERT_LINE_HEIGHT, TEXT_INVERTED_BGCOLOR);
}
putsStrIdx(MENUS_MARGIN_LEFT, y, STR_TIMER, timerIdx+1);
putsTimerMode(MODEL_SETUP_2ND_COLUMN, y, timer->mode, (m_posHorz<=0 ? attr : 0));
@ -219,11 +219,12 @@ bool menuModelSetup(evt_t event)
switch(k) {
case ITEM_MODEL_NAME:
editSingleName(MODEL_SETUP_2ND_COLUMN, y, STR_MODELNAME, g_model.header.name, sizeof(g_model.header.name), event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODELNAME);
editName(MODEL_SETUP_2ND_COLUMN, y, g_model.header.name, sizeof(g_model.header.name), event, attr);
break;
case ITEM_MODEL_BITMAP:
lcd_putsLeft(y, STR_BITMAP);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BITMAP);
if (ZEXIST(g_model.header.bitmap))
lcdDrawTextWithLen(MODEL_SETUP_2ND_COLUMN, y, g_model.header.bitmap, sizeof(g_model.header.bitmap), attr);
else
@ -245,19 +246,23 @@ bool menuModelSetup(evt_t event)
break;
case ITEM_MODEL_TIMER1_NAME:
editSingleName(MODEL_SETUP_2ND_COLUMN, y, STR_TIMER_NAME, g_model.timers[0].name, LEN_TIMER_NAME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TIMER_NAME);
editName(MODEL_SETUP_2ND_COLUMN, y, g_model.timers[0].name, LEN_TIMER_NAME, event, attr);
break;
case ITEM_MODEL_TIMER1_MINUTE_BEEP:
g_model.timers[0].minuteBeep = onoffMenuItem(g_model.timers[0].minuteBeep, MODEL_SETUP_2ND_COLUMN, y, STR_MINUTEBEEP, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MINUTEBEEP);
g_model.timers[0].minuteBeep = onoffMenuItem(g_model.timers[0].minuteBeep, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_TIMER1_COUNTDOWN_BEEP:
g_model.timers[0].countdownBeep = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_BEEPCOUNTDOWN, STR_VBEEPCOUNTDOWN, g_model.timers[0].countdownBeep, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BEEPCOUNTDOWN);
g_model.timers[0].countdownBeep = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VBEEPCOUNTDOWN, g_model.timers[0].countdownBeep, 0, 2, attr, event);
break;
case ITEM_MODEL_TIMER1_PERSISTENT:
g_model.timers[0].persistent = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_PERSISTENT, STR_VPERSISTENT, g_model.timers[0].persistent, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PERSISTENT);
g_model.timers[0].persistent = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VPERSISTENT, g_model.timers[0].persistent, 0, 2, attr, event);
break;
#if TIMERS > 1
@ -266,19 +271,23 @@ bool menuModelSetup(evt_t event)
break;
case ITEM_MODEL_TIMER2_NAME:
editSingleName(MODEL_SETUP_2ND_COLUMN, y, STR_TIMER_NAME, g_model.timers[1].name, LEN_TIMER_NAME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TIMER_NAME);
editName(MODEL_SETUP_2ND_COLUMN, y, g_model.timers[1].name, LEN_TIMER_NAME, event, attr);
break;
case ITEM_MODEL_TIMER2_MINUTE_BEEP:
g_model.timers[1].minuteBeep = onoffMenuItem(g_model.timers[1].minuteBeep, MODEL_SETUP_2ND_COLUMN, y, STR_MINUTEBEEP, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MINUTEBEEP);
g_model.timers[1].minuteBeep = onoffMenuItem(g_model.timers[1].minuteBeep, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_TIMER2_COUNTDOWN_BEEP:
g_model.timers[1].countdownBeep = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_BEEPCOUNTDOWN, STR_VBEEPCOUNTDOWN, g_model.timers[1].countdownBeep, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BEEPCOUNTDOWN);
g_model.timers[1].countdownBeep = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VBEEPCOUNTDOWN, g_model.timers[1].countdownBeep, 0, 2, attr, event);
break;
case ITEM_MODEL_TIMER2_PERSISTENT:
g_model.timers[1].persistent = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_PERSISTENT, STR_VPERSISTENT, g_model.timers[1].persistent, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PERSISTENT);
g_model.timers[1].persistent = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VPERSISTENT, g_model.timers[1].persistent, 0, 2, attr, event);
break;
#endif
@ -288,28 +297,34 @@ bool menuModelSetup(evt_t event)
break;
case ITEM_MODEL_TIMER3_NAME:
editSingleName(MODEL_SETUP_2ND_COLUMN, y, STR_TIMER_NAME, g_model.timers[2].name, LEN_TIMER_NAME, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TIMER_NAME);
editName(MODEL_SETUP_2ND_COLUMN, y, g_model.timers[2].name, LEN_TIMER_NAME, event, attr);
break;
case ITEM_MODEL_TIMER3_MINUTE_BEEP:
g_model.timers[2].minuteBeep = onoffMenuItem(g_model.timers[2].minuteBeep, MODEL_SETUP_2ND_COLUMN, y, STR_MINUTEBEEP, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MINUTEBEEP);
g_model.timers[2].minuteBeep = onoffMenuItem(g_model.timers[2].minuteBeep, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_TIMER3_COUNTDOWN_BEEP:
g_model.timers[2].countdownBeep = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_BEEPCOUNTDOWN, STR_VBEEPCOUNTDOWN, g_model.timers[2].countdownBeep, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BEEPCOUNTDOWN);
g_model.timers[2].countdownBeep = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VBEEPCOUNTDOWN, g_model.timers[2].countdownBeep, 0, 2, attr, event);
break;
case ITEM_MODEL_TIMER3_PERSISTENT:
g_model.timers[2].persistent = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_PERSISTENT, STR_VPERSISTENT, g_model.timers[2].persistent, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PERSISTENT);
g_model.timers[2].persistent = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VPERSISTENT, g_model.timers[2].persistent, 0, 2, attr, event);
break;
#endif
case ITEM_MODEL_EXTENDED_LIMITS:
ON_OFF_MENU_ITEM(g_model.extendedLimits, MODEL_SETUP_2ND_COLUMN, y, STR_ELIMITS, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ELIMITS);
onoffMenuItem(g_model.extendedLimits, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_EXTENDED_TRIMS:
ON_OFF_MENU_ITEM(g_model.extendedTrims, MODEL_SETUP_2ND_COLUMN, y, STR_ETRIMS, m_posHorz<=0 ? attr : 0, event==EVT_KEY_BREAK(KEY_ENTER) ? event : 0);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ETRIMS);
onoffMenuItem(g_model.extendedTrims, MODEL_SETUP_2ND_COLUMN, y, m_posHorz<=0 ? attr : 0, event==EVT_KEY_BREAK(KEY_ENTER) ? event : 0);
lcdDrawText(MODEL_SETUP_2ND_COLUMN+18, y, STR_RESET_BTN, m_posHorz>0 && !s_noHi ? attr : 0);
if (attr && m_posHorz>0) {
s_editMode = 0;
@ -325,15 +340,17 @@ bool menuModelSetup(evt_t event)
break;
case ITEM_MODEL_DISPLAY_TRIMS:
g_model.displayTrims = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, "Display Trims", "\006No\0 ChangeYes", g_model.displayTrims, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_DISPLAY_TRIMS);
g_model.displayTrims = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, "\006No\0 ChangeYes", g_model.displayTrims, 0, 2, attr, event);
break;
case ITEM_MODEL_TRIM_INC:
g_model.trimInc = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_TRIMINC, STR_VTRIMINC, g_model.trimInc, -2, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TRIMINC);
g_model.trimInc = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VTRIMINC, g_model.trimInc, -2, 2, attr, event);
break;
case ITEM_MODEL_THROTTLE_LABEL:
lcd_putsLeft(y, STR_THROTTLE_LABEL);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_THROTTLE_LABEL);
break;
#if 0
@ -344,7 +361,7 @@ bool menuModelSetup(evt_t event)
case ITEM_MODEL_THROTTLE_TRACE:
{
lcd_putsLeft(y, STR_TTRACE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TTRACE);
if (attr) CHECK_INCDEC_MODELVAR_ZERO(event, g_model.thrTraceSrc, NUM_POTS+NUM_CHNOUT);
uint8_t idx = g_model.thrTraceSrc + MIXSRC_Thr;
if (idx > MIXSRC_Thr)
@ -356,24 +373,27 @@ bool menuModelSetup(evt_t event)
}
case ITEM_MODEL_THROTTLE_TRIM:
ON_OFF_MENU_ITEM(g_model.thrTrim, MODEL_SETUP_2ND_COLUMN, y, STR_TTRIM, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TTRIM);
onoffMenuItem(g_model.thrTrim, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_PREFLIGHT_LABEL:
lcd_putsLeft(y, STR_PREFLIGHT);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PREFLIGHT);
break;
case ITEM_MODEL_CHECKLIST_DISPLAY:
ON_OFF_MENU_ITEM(g_model.displayChecklist, MODEL_SETUP_2ND_COLUMN, y, STR_CHECKLIST, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CHECKLIST);
onoffMenuItem(g_model.displayChecklist, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_THROTTLE_WARNING:
g_model.disableThrottleWarning = !onoffMenuItem(!g_model.disableThrottleWarning, MODEL_SETUP_2ND_COLUMN, y, STR_THROTTLEWARNING, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_THROTTLEWARNING);
g_model.disableThrottleWarning = !onoffMenuItem(!g_model.disableThrottleWarning, MODEL_SETUP_2ND_COLUMN, y, attr, event);
break;
case ITEM_MODEL_SWITCHES_WARNING:
{
lcd_putsLeft(y, STR_SWITCHWARNING);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SWITCHWARNING);
if (!READ_ONLY() && attr && m_posHorz<0 && event==EVT_KEY_LONG(KEY_ENTER)) {
killEvents(event);
s_noHi = NO_HI_LEN;
@ -431,7 +451,7 @@ bool menuModelSetup(evt_t event)
case ITEM_MODEL_POT_WARNING:
{
lcd_putsLeft(y, STR_POTWARNING);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_POTWARNING);
if (attr) {
if (m_posHorz) s_editMode = 0;
if (!READ_ONLY() && m_posHorz) {
@ -470,7 +490,7 @@ bool menuModelSetup(evt_t event)
}
case ITEM_MODEL_BEEP_CENTER:
lcd_putsLeft(y, STR_BEEPCTR);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_BEEPCTR);
if (attr && m_posHorz < 0) {
lcdDrawSolidFilledRect(MODEL_SETUP_2ND_COLUMN-INVERT_HORZ_MARGIN, y-INVERT_VERT_MARGIN, (NUM_STICKS+NUM_POTS)*13+2*INVERT_HORZ_MARGIN, INVERT_LINE_HEIGHT, TEXT_INVERTED_BGCOLOR);
}
@ -493,21 +513,22 @@ bool menuModelSetup(evt_t event)
break;
case ITEM_MODEL_USE_GLOBAL_FUNCTIONS:
lcd_putsLeft(y, "Use Global Funcs");
lcdDrawText(MENUS_MARGIN_LEFT, y, "Use Global Funcs");
drawCheckBox(MODEL_SETUP_2ND_COLUMN, y, !g_model.noGlobalFunctions, attr);
if (attr) g_model.noGlobalFunctions = !checkIncDecModel(event, !g_model.noGlobalFunctions, 0, 1);
break;
case ITEM_MODEL_TRAINER_MODE:
g_model.trainerMode = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_MODE, STR_VTRAINERMODES, g_model.trainerMode, TRAINER_MODE_MASTER, TRAINER_MODE_SLAVE, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODE);
g_model.trainerMode = selectMenuItem(MODEL_SETUP_2ND_COLUMN, y, STR_VTRAINERMODES, g_model.trainerMode, TRAINER_MODE_MASTER, TRAINER_MODE_SLAVE, attr, event);
break;
case ITEM_MODEL_EXTERNAL_MODULE_LABEL:
lcd_putsLeft(y, TR_EXTERNALRF);
lcdDrawText(MENUS_MARGIN_LEFT, y, TR_EXTERNALRF);
break;
case ITEM_MODEL_EXTERNAL_MODULE_MODE:
lcd_putsLeft(y, STR_MODE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_MODE);
lcdDrawTextAtIndex(MODEL_SETUP_2ND_COLUMN, y, STR_TARANIS_PROTOCOLS, g_model.moduleData[EXTERNAL_MODULE].type, (m_posHorz==0 ? attr : 0));
if (IS_MODULE_XJT(EXTERNAL_MODULE))
lcdDrawTextAtIndex(MODEL_SETUP_2ND_COLUMN+40, y, STR_XJT_PROTOCOLS, 1+g_model.moduleData[EXTERNAL_MODULE].rfProtocol, (m_posHorz==1 ? attr : 0));
@ -540,7 +561,7 @@ bool menuModelSetup(evt_t event)
break;
case ITEM_MODEL_TRAINER_LABEL:
lcd_putsLeft(y, STR_TRAINER);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TRAINER);
break;
case ITEM_MODEL_EXTERNAL_MODULE_CHANNELS:
@ -548,7 +569,7 @@ bool menuModelSetup(evt_t event)
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
ModuleData & moduleData = g_model.moduleData[moduleIdx];
lcd_putsLeft(y, STR_CHANNELRANGE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CHANNELRANGE);
if ((int8_t)PORT_CHANNELS_ROWS(moduleIdx) >= 0) {
putsStrIdx(MODEL_SETUP_2ND_COLUMN, y, STR_CH, moduleData.channelsStart+1, m_posHorz==0 ? attr : 0);
lcdDrawText(MODEL_SETUP_2ND_COLUMN+30, y, "-");
@ -577,7 +598,7 @@ bool menuModelSetup(evt_t event)
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
ModuleData & moduleData = g_model.moduleData[moduleIdx];
if (IS_MODULE_PPM(moduleIdx)) {
lcd_putsLeft(y, STR_PPMFRAME);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PPMFRAME);
lcdDrawNumber(MODEL_SETUP_2ND_COLUMN, y, (int16_t)moduleData.ppmFrameLength*5 + 225, (m_posHorz<=0 ? attr : 0) | PREC1|LEFT, 0, NULL, STR_MS);
lcdDrawNumber(MODEL_SETUP_2ND_COLUMN+70, y, (moduleData.ppmDelay*50)+300, (CURSOR_ON_LINE() || m_posHorz==1) ? attr : 0, 0, NULL, "us");
lcdDrawText(MODEL_SETUP_2ND_COLUMN+90, y, moduleData.ppmPulsePol ? "+" : "-", (CURSOR_ON_LINE() || m_posHorz==2) ? attr : 0);
@ -601,11 +622,11 @@ bool menuModelSetup(evt_t event)
coord_t xOffsetBind = MODEL_SETUP_BIND_OFS;
if (IS_MODULE_XJT(moduleIdx) && IS_D8_RX(moduleIdx)) {
xOffsetBind = 0;
lcd_putsLeft(y, INDENT "Receiver");
lcdDrawText(MENUS_MARGIN_LEFT, y, INDENT "Receiver");
if (attr) l_posHorz += 1;
}
else {
lcd_putsLeft(y, STR_RXNUM);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_RXNUM);
}
if (IS_MODULE_XJT(moduleIdx) || IS_MODULE_DSM2(moduleIdx)) {
if (xOffsetBind) lcdDrawNumber(MODEL_SETUP_2ND_COLUMN, y, g_model.header.modelId[moduleIdx], (l_posHorz==0 ? attr : 0) | LEADING0|LEFT, 2);
@ -632,7 +653,7 @@ bool menuModelSetup(evt_t event)
{
uint8_t moduleIdx = CURRENT_MODULE_EDITED(k);
ModuleData & moduleData = g_model.moduleData[moduleIdx];
lcd_putsLeft(y, TR_FAILSAFE);
lcdDrawText(MENUS_MARGIN_LEFT, y, TR_FAILSAFE);
if (IS_MODULE_XJT(moduleIdx)) {
lcdDrawTextAtIndex(MODEL_SETUP_2ND_COLUMN, y, STR_VFAILSAFE, moduleData.failsafeMode, m_posHorz==0 ? attr : 0);
if (moduleData.failsafeMode == FAILSAFE_CUSTOM) lcdDrawText(MODEL_SETUP_2ND_COLUMN + MODEL_SETUP_SET_FAILSAFE_OFS, y, STR_SET, m_posHorz==1 ? attr : 0);

65
radio/src/gui/Horus/menu_model_telemetry.cpp
View file

@ -233,11 +233,13 @@ bool menuModelSensor(evt_t event)
switch (k) {
case SENSOR_FIELD_NAME:
editSingleName(SENSOR_2ND_COLUMN, y, STR_NAME, sensor->label, TELEM_LABEL_LEN, event, attr);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_NAME);
editName(SENSOR_2ND_COLUMN, y, sensor->label, TELEM_LABEL_LEN, event, attr);
break;
case SENSOR_FIELD_TYPE:
sensor->type = selectMenuItem(SENSOR_2ND_COLUMN, y, NO_INDENT(STR_TYPE), STR_VSENSORTYPES, sensor->type, 0, 1, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_TYPE));
sensor->type = selectMenuItem(SENSOR_2ND_COLUMN, y, STR_VSENSORTYPES, sensor->type, 0, 1, attr, event);
if (attr && checkIncDec_Ret) {
sensor->instance = 0;
if (sensor->type == TELEM_TYPE_CALCULATED) {
@ -250,7 +252,7 @@ bool menuModelSensor(evt_t event)
case SENSOR_FIELD_ID:
if (sensor->type == TELEM_TYPE_CUSTOM) {
lcd_putsLeft(y, STR_ID);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_ID);
lcd_outhex4(SENSOR_2ND_COLUMN, y, sensor->id, LEFT|(m_posHorz==0 ? attr : 0));
lcdDrawNumber(SENSOR_3RD_COLUMN, y, sensor->instance, LEFT|(m_posHorz==1 ? attr : 0));
if (attr) {
@ -266,7 +268,8 @@ bool menuModelSensor(evt_t event)
}
}
else {
sensor->formula = selectMenuItem(SENSOR_2ND_COLUMN, y, STR_FORMULA, STR_VFORMULAS, sensor->formula, 0, TELEM_FORMULA_LAST, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_FORMULA);
sensor->formula = selectMenuItem(SENSOR_2ND_COLUMN, y, STR_VFORMULAS, sensor->formula, 0, TELEM_FORMULA_LAST, attr, event);
if (attr && checkIncDec_Ret) {
sensor->param = 0;
if (sensor->formula == TELEM_FORMULA_CELL) {
@ -286,7 +289,7 @@ bool menuModelSensor(evt_t event)
break;
case SENSOR_FIELD_UNIT:
lcd_putsLeft(y, STR_UNIT);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_UNIT);
// TODO flash saving with selectMenuItem where I copied those 2 lines?
lcdDrawTextAtIndex(SENSOR_2ND_COLUMN, y, STR_VTELEMUNIT, sensor->unit, attr);
if (attr) {
@ -298,7 +301,8 @@ bool menuModelSensor(evt_t event)
break;
case SENSOR_FIELD_PRECISION:
sensor->prec = selectMenuItem(SENSOR_2ND_COLUMN, y, STR_PRECISION, STR_VPREC, sensor->prec, 0, 2, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_PRECISION);
sensor->prec = selectMenuItem(SENSOR_2ND_COLUMN, y, STR_VPREC, sensor->prec, 0, 2, attr, event);
if (attr && checkIncDec_Ret) {
telemetryItems[s_currIdx].clear();
}
@ -307,7 +311,7 @@ bool menuModelSensor(evt_t event)
case SENSOR_FIELD_PARAM1:
if (sensor->type == TELEM_TYPE_CALCULATED) {
if (sensor->formula == TELEM_FORMULA_CELL) {
lcd_putsLeft(y, STR_CELLSENSOR);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_CELLSENSOR);
putsMixerSource(SENSOR_2ND_COLUMN, y, sensor->cell.source ? MIXSRC_FIRST_TELEM+3*(sensor->cell.source-1) : 0, attr);
if (attr) {
sensor->cell.source = checkIncDec(event, sensor->cell.source, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isCellsSensor);
@ -315,7 +319,7 @@ bool menuModelSensor(evt_t event)
break;
}
else if (sensor->formula == TELEM_FORMULA_DIST) {
lcd_putsLeft(y, "GPS sensor");
lcdDrawText(MENUS_MARGIN_LEFT, y, "GPS sensor");
putsMixerSource(SENSOR_2ND_COLUMN, y, sensor->dist.gps ? MIXSRC_FIRST_TELEM+3*(sensor->dist.gps-1) : 0, attr);
if (attr) {
sensor->dist.gps = checkIncDec(event, sensor->dist.gps, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isGPSSensor);
@ -323,7 +327,7 @@ bool menuModelSensor(evt_t event)
break;
}
else if (sensor->formula == TELEM_FORMULA_CONSUMPTION) {
lcd_putsLeft(y, "Amps sensor");
lcdDrawText(MENUS_MARGIN_LEFT, y, "Amps sensor");
putsMixerSource(SENSOR_2ND_COLUMN, y, sensor->consumption.source ? MIXSRC_FIRST_TELEM+3*(sensor->consumption.source-1) : 0, attr);
if (attr) {
sensor->consumption.source = checkIncDec(event, sensor->consumption.source, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isCurrentSensor);
@ -332,7 +336,7 @@ bool menuModelSensor(evt_t event)
}
}
else {
lcd_putsLeft(y, "Ratio");
lcdDrawText(MENUS_MARGIN_LEFT, y, "Ratio");
if (attr) CHECK_INCDEC_MODELVAR(event, sensor->custom.ratio, 0, 30000);
if (sensor->custom.ratio == 0)
lcdDrawText(SENSOR_2ND_COLUMN, y, "-", attr);
@ -345,11 +349,12 @@ bool menuModelSensor(evt_t event)
case SENSOR_FIELD_PARAM2:
if (sensor->type == TELEM_TYPE_CALCULATED) {
if (sensor->formula == TELEM_FORMULA_CELL) {
sensor->cell.index = selectMenuItem(SENSOR_2ND_COLUMN, y, "Cell index", "\007Lowest\0001\0 2\0 3\0 4\0 5\0 6\0 HighestDelta\0", sensor->cell.index, 0, 8, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, "Cell index");
sensor->cell.index = selectMenuItem(SENSOR_2ND_COLUMN, y, "\007Lowest\0001\0 2\0 3\0 4\0 5\0 6\0 HighestDelta\0", sensor->cell.index, 0, 8, attr, event);
break;
}
else if (sensor->formula == TELEM_FORMULA_DIST) {
lcd_putsLeft(y, "Alt sensor");
lcdDrawText(MENUS_MARGIN_LEFT, y, "Alt sensor");
putsMixerSource(SENSOR_2ND_COLUMN, y, sensor->dist.alt ? MIXSRC_FIRST_TELEM+3*(sensor->dist.alt-1) : 0, attr);
if (attr) {
sensor->dist.alt = checkIncDec(event, sensor->dist.alt, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isAltSensor);
@ -358,7 +363,7 @@ bool menuModelSensor(evt_t event)
}
}
else {
lcd_putsLeft(y, NO_INDENT(STR_OFFSET));
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_OFFSET));
if (attr) CHECK_INCDEC_MODELVAR(event, sensor->custom.offset, -30000, +30000);
if (sensor->prec > 0) attr |= (sensor->prec == 2 ? PREC2 : PREC1);
lcdDrawNumber(SENSOR_2ND_COLUMN, y, sensor->custom.offset, LEFT|attr);
@ -387,15 +392,18 @@ bool menuModelSensor(evt_t event)
}
case SENSOR_FIELD_AUTOOFFSET:
ON_OFF_MENU_ITEM(sensor->autoOffset, SENSOR_2ND_COLUMN, y, STR_AUTOOFFSET, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_AUTOOFFSET);
onoffMenuItem(sensor->autoOffset, SENSOR_2ND_COLUMN, y, attr, event);
break;
case SENSOR_FIELD_FILTER:
ON_OFF_MENU_ITEM(sensor->filter, SENSOR_2ND_COLUMN, y, STR_FILTER, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_FILTER);
onoffMenuItem(sensor->filter, SENSOR_2ND_COLUMN, y, attr, event);
break;
case SENSOR_FIELD_PERSISTENT:
ON_OFF_MENU_ITEM(sensor->persistent, SENSOR_2ND_COLUMN, y, NO_INDENT(STR_PERSISTENT), attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, NO_INDENT(STR_PERSISTENT));
onoffMenuItem(sensor->persistent, SENSOR_2ND_COLUMN, y, attr, event);
break;
}
@ -470,7 +478,7 @@ bool menuModelTelemetry(evt_t event)
}
TelemetryItem & telemetryItem = telemetryItems[index];
if (telemetryItem.isAvailable()) {
LcdFlags color = telemetryItem.isOld() ? RED : WHITE;
LcdFlags color = telemetryItem.isOld() ? ALARM_COLOR : TEXT_COLOR;
putsTelemetryChannelValue(TELEM_COL2, y, index, getValue(MIXSRC_FIRST_TELEM+3*index), LEFT|color);
}
else {
@ -494,11 +502,12 @@ bool menuModelTelemetry(evt_t event)
switch (k) {
case ITEM_TELEMETRY_PROTOCOL_TYPE:
g_model.telemetryProtocol = selectMenuItem(TELEM_COL2, y, STR_TELEMETRY_TYPE, "\017FrSky S.PORT\0 FrSky D\0 FrSky D (cable)", g_model.telemetryProtocol, PROTOCOL_TELEMETRY_FIRST, PROTOCOL_FRSKY_D, attr, event);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TELEMETRY_TYPE);
g_model.telemetryProtocol = selectMenuItem(TELEM_COL2, y, "\017FrSky S.PORT\0 FrSky D\0 FrSky D (cable)", g_model.telemetryProtocol, PROTOCOL_TELEMETRY_FIRST, PROTOCOL_FRSKY_D, attr, event);
break;
case ITEM_TELEMETRY_SENSORS_LABEL:
lcd_putsLeft(y, STR_TELEMETRY_SENSORS);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_TELEMETRY_SENSORS);
break;
case ITEM_TELEMETRY_NEWSENSOR:
@ -514,13 +523,13 @@ bool menuModelTelemetry(evt_t event)
break;
case ITEM_TELEMETRY_RSSI_LABEL:
lcd_putsLeft(y, PSTR("RSSI"));
lcdDrawText(MENUS_MARGIN_LEFT, y, PSTR("RSSI"));
break;
case ITEM_TELEMETRY_RSSI_ALARM1:
case ITEM_TELEMETRY_RSSI_ALARM2: {
uint8_t alarm = k-ITEM_TELEMETRY_RSSI_ALARM1;
lcd_putsLeft(y, (alarm==0 ? STR_LOWALARM : STR_CRITICALALARM));
lcdDrawText(MENUS_MARGIN_LEFT, y, (alarm==0 ? STR_LOWALARM : STR_CRITICALALARM));
lcdDrawNumber(TELEM_COL2, y, getRssiAlarmValue(alarm), LEFT|attr, 3);
if (attr && s_editMode>0) {
CHECK_INCDEC_MODELVAR(event, g_model.frsky.rssiAlarms[alarm].value, -30, 30);
@ -530,11 +539,11 @@ bool menuModelTelemetry(evt_t event)
#if defined(VARIO)
case ITEM_TELEMETRY_VARIO_LABEL:
lcd_putsLeft(y, STR_VARIO);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_VARIO);
break;
case ITEM_TELEMETRY_VARIO_SOURCE:
lcd_putsLeft(y, STR_SOURCE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_SOURCE);
putsMixerSource(TELEM_COL2, y, g_model.frsky.varioSource ? MIXSRC_FIRST_TELEM+3*(g_model.frsky.varioSource-1) : 0, attr);
if (attr) {
g_model.frsky.varioSource = checkIncDec(event, g_model.frsky.varioSource, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isSensorAvailable);
@ -542,7 +551,7 @@ bool menuModelTelemetry(evt_t event)
break;
case ITEM_TELEMETRY_VARIO_RANGE:
lcd_putsLeft(y, STR_LIMIT);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_LIMIT);
lcdDrawNumber(TELEM_COL2, y, -10+g_model.frsky.varioMin, (m_posHorz<=0 ? attr : 0)|LEFT);
lcdDrawNumber(TELEM_COL2+70, y, -5+g_model.frsky.varioCenterMin, ((CURSOR_ON_LINE() || m_posHorz==1) ? attr : 0)|PREC1);
lcdDrawNumber(TELEM_COL2+115, y, 5+g_model.frsky.varioCenterMax, ((CURSOR_ON_LINE() || m_posHorz==2) ? attr : 0)|PREC1);
@ -567,11 +576,11 @@ bool menuModelTelemetry(evt_t event)
#endif
case ITEM_TELEMETRY_TOP_BAR_LABEL:
lcd_putsLeft(y, "Main Telemetry Fields");
lcdDrawText(MENUS_MARGIN_LEFT, y, "Main Telemetry Fields");
break;
case ITEM_TELEMETRY_TOP_BAR_VOLTAGE:
lcd_putsLeft(y, STR_VOLTAGE);
lcdDrawText(MENUS_MARGIN_LEFT, y, STR_VOLTAGE);
putsMixerSource(TELEM_COL2, y, g_model.frsky.voltsSource ? MIXSRC_FIRST_TELEM+3*(g_model.frsky.voltsSource-1) : 0, attr);
if (attr) {
g_model.frsky.voltsSource = checkIncDec(event, g_model.frsky.voltsSource, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isVoltsSensor);
@ -579,7 +588,7 @@ bool menuModelTelemetry(evt_t event)
break;
case ITEM_TELEMETRY_TOP_BAR_ALTITUDE:
lcd_putsLeft(y, INDENT "Altitude Source");
lcdDrawText(MENUS_MARGIN_LEFT, y, INDENT "Altitude Source");
putsMixerSource(TELEM_COL2, y, g_model.frsky.altitudeSource ? MIXSRC_FIRST_TELEM+3*(g_model.frsky.altitudeSource-1) : 0, attr);
if (attr) {
g_model.frsky.altitudeSource = checkIncDec(event, g_model.frsky.altitudeSource, 0, MAX_SENSORS, EE_MODEL|NO_INCDEC_MARKS, isAltSensor);
@ -594,7 +603,7 @@ bool menuModelTelemetry(evt_t event)
uint8_t screenIndex = TELEMETRY_CURRENT_EDIT_SCREEN(k);
putsStrIdx(MENUS_MARGIN_LEFT, y, STR_SCREEN, screenIndex+1);
TelemetryScreenType oldScreenType = TELEMETRY_SCREEN_TYPE(screenIndex);
TelemetryScreenType newScreenType = (TelemetryScreenType)selectMenuItem(TELEM_SCRTYPE_COL, y, PSTR(""), STR_VTELEMSCREENTYPE, oldScreenType, 0, TELEMETRY_SCREEN_TYPE_MAX, (m_posHorz==0 ? attr : 0), event);
TelemetryScreenType newScreenType = (TelemetryScreenType)selectMenuItem(TELEM_SCRTYPE_COL, y, STR_VTELEMSCREENTYPE, oldScreenType, 0, TELEMETRY_SCREEN_TYPE_MAX, (m_posHorz==0 ? attr : 0), event);
if (newScreenType != oldScreenType) {
g_model.frsky.screensType = (g_model.frsky.screensType & (~(0x03 << (2*screenIndex)))) | (newScreenType << (2*screenIndex));
memset(&g_model.frsky.screens[screenIndex], 0, sizeof(g_model.frsky.screens[screenIndex]));

10
radio/src/gui/Horus/menus.h
View file

@ -50,8 +50,6 @@
#define MENU_COLUMN2_X 280
#define lcd_putsColumnLeft(x, y, str) lcdDrawText((x > MENU_COLUMN2_X+MENUS_MARGIN_LEFT+68) ? MENU_COLUMN2_X+MENUS_MARGIN_LEFT : MENUS_MARGIN_LEFT, y, str)
typedef int16_t vertpos_t;
typedef evt_t & check_event_t;
@ -220,7 +218,7 @@ void drawSlider(coord_t x, coord_t y, uint8_t value, uint8_t max, uint8_t attr);
#define SUBMENU(title, lines_count, scrollbar_X, ...) \
MENU_TAB(__VA_ARGS__); \
if (!check(event, 0, NULL, 0, mstate_tab, DIM(mstate_tab)-1, lines_count)) return false; \
drawMenuTemplate(title, scrollbar_X);
drawSubmenuTemplate(title, scrollbar_X);
#define SIMPLE_SUBMENU_NOTITLE(lines_count) \
if (!check_submenu_simple(event, lines_count)) return false
@ -231,12 +229,10 @@ void drawSlider(coord_t x, coord_t y, uint8_t value, uint8_t max, uint8_t attr);
typedef int select_menu_value_t;
select_menu_value_t selectMenuItem(coord_t x, coord_t y, const pm_char *label, const pm_char *values, select_menu_value_t value, select_menu_value_t min, select_menu_value_t max, LcdFlags attr, evt_t event);
uint8_t onoffMenuItem(uint8_t value, coord_t x, coord_t y, const pm_char *label, LcdFlags attr, evt_t event);
select_menu_value_t selectMenuItem(coord_t x, coord_t y, const pm_char * values, select_menu_value_t value, select_menu_value_t min, select_menu_value_t max, LcdFlags attr, evt_t event);
uint8_t onoffMenuItem(uint8_t value, coord_t x, coord_t y, LcdFlags attr, evt_t event);
int8_t switchMenuItem(coord_t x, coord_t y, int8_t value, LcdFlags attr, evt_t event);
#define ON_OFF_MENU_ITEM(value, x, y, label, attr, event) value = onoffMenuItem(value, x, y, label, attr, event)
#if defined(GVARS)
#define GVAR_MENU_ITEM(x, y, v, min, max, lcdattr, editflags, event) gvarMenuItem(x, y, v, min, max, lcdattr, editflags, event)
#else

35
radio/src/gui/Horus/navigation.cpp
View file

@ -422,8 +422,12 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
} while (CURSOR_NOT_ALLOWED_IN_ROW(m_posVert));
s_editMode = 0; // if we go down, we must be in this mode
uint8_t newmaxcol = MAXCOL(m_posVert);
if (m_posHorz < 0 || (m_posHorz==0 && maxcol==0) || m_posHorz > newmaxcol)
if (COLATTR(m_posVert) & NAVIGATION_LINE_BY_LINE) {
m_posHorz = -1;
}
else if (m_posHorz < 0 || m_posHorz > newmaxcol) {
m_posHorz = POS_HORZ_INIT(m_posVert);
}
break;
}
@ -442,7 +446,7 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
do {
DEC(m_posVert, MENU_FIRST_LINE_EDIT, rowcount-1);
} while (CURSOR_NOT_ALLOWED_IN_ROW(m_posVert));
if ((COLATTR(m_posVert) & NAVIGATION_LINE_BY_LINE))
if (COLATTR(m_posVert) & NAVIGATION_LINE_BY_LINE)
m_posHorz = -1;
else
m_posHorz = min((uint8_t)m_posHorz, MAXCOL(m_posVert));
@ -456,18 +460,21 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
} while (CURSOR_NOT_ALLOWED_IN_ROW(m_posVert));
s_editMode = 0; // if we go up, we must be in this mode
uint8_t newmaxcol = MAXCOL(m_posVert);
if (m_posHorz < 0 || (m_posHorz==0 && maxcol==0) || m_posHorz > newmaxcol) {
if ((COLATTR(m_posVert) & NAVIGATION_LINE_BY_LINE))
if ((COLATTR(m_posVert) & NAVIGATION_LINE_BY_LINE)) {
m_posHorz = -1;
else
}
else if (m_posHorz < 0) {
m_posHorz = POS_HORZ_INIT(m_posVert);
}
else if (m_posHorz > newmaxcol) {
m_posHorz = min((uint8_t)m_posHorz, newmaxcol);
}
break;
}
}
linesCount = rowcount;
int maxBodyLines = (menuTab ? NUM_BODY_LINES : NUM_BODY_LINES+1);
if (m_posVert <= MENU_FIRST_LINE_EDIT) {
s_pgOfs = 0;
@ -481,7 +488,7 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
}
}
else if (horTab) {
if (rowcount > NUM_BODY_LINES) {
if (rowcount > maxBodyLines) {
while (1) {
vertpos_t firstLine = 0;
for (int numLines=0; firstLine<rowcount && numLines<s_pgOfs; firstLine++) {
@ -494,8 +501,8 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
}
else {
vertpos_t lastLine = firstLine;
for (int numLines=0; lastLine<rowcount && numLines<NUM_BODY_LINES; lastLine++) {
if (lastLine>=horTabMax || horTab[lastLine] != HIDDEN_ROW) {
for (int numLines=0; lastLine<rowcount && numLines<maxBodyLines; lastLine++) {
if (lastLine >= horTabMax || horTab[lastLine] != HIDDEN_ROW) {
numLines++;
}
}
@ -503,9 +510,9 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
s_pgOfs++;
}
else {
linesCount = s_pgOfs + NUM_BODY_LINES;
linesCount = s_pgOfs + maxBodyLines;
for (int i=lastLine; i<rowcount; i++) {
if (i>horTabMax || horTab[i] != HIDDEN_ROW) {
if (i > horTabMax || horTab[i] != HIDDEN_ROW) {
linesCount++;
}
}
@ -516,10 +523,10 @@ bool check(check_event_t event, uint8_t curr, const MenuFuncP * menuTab, uint8_t
}
}
else {
if (m_posVert>=NUM_BODY_LINES+s_pgOfs) {
s_pgOfs = m_posVert-NUM_BODY_LINES+1;
if (m_posVert >= maxBodyLines + s_pgOfs) {
s_pgOfs = m_posVert-maxBodyLines+1;
}
else if (m_posVert<s_pgOfs) {
else if (m_posVert < s_pgOfs) {
s_pgOfs = m_posVert;
}
}

4
radio/src/gui/Horus/popups.cpp
View file

@ -205,10 +205,10 @@ const char * displayMenu(evt_t event)
for (uint8_t i=0; i<display_count; i++) {
if (i == s_menu_item) {
lcdDrawSolidFilledRect(MENU_X+1, i*(FH+1) + y + 1, MENU_W-2, FH+1, TEXT_INVERTED_BGCOLOR);
lcdDrawText(MENU_X+6, i*(FH+1) + y + 5, s_menu[i], TEXT_INVERTED_COLOR|s_menu_flags);
lcdDrawText(MENU_X+6, i*(FH+1) + y + 4, s_menu[i], TEXT_INVERTED_COLOR|s_menu_flags);
}
else {
lcdDrawText(MENU_X+6, i*(FH+1) + y + 5, s_menu[i], s_menu_flags);
lcdDrawText(MENU_X+6, i*(FH+1) + y + 4, s_menu[i], s_menu_flags);
}
}

8
radio/src/gui/Horus/view_statistics.cpp
View file

@ -134,21 +134,21 @@ bool menuStatisticsDebug(evt_t event)
drawScreenTemplate(STR_MENUDEBUG);
lcd_putsLeft(MENU_DEBUG_Y_FREE_RAM, "Free Mem");
lcdDrawText(MENUS_MARGIN_LEFT, MENU_DEBUG_Y_FREE_RAM, "Free Mem");
lcdDrawNumber(MENU_DEBUG_COL1_OFS, MENU_DEBUG_Y_FREE_RAM, availableMemory(), LEFT, 0, NULL, "b");
#if defined(LUA)
lcd_putsLeft(MENU_DEBUG_Y_LUA, "Lua scripts");
lcdDrawText(MENUS_MARGIN_LEFT, MENU_DEBUG_Y_LUA, "Lua scripts");
lcdDrawText(MENU_DEBUG_COL1_OFS, MENU_DEBUG_Y_LUA+1, "[Duration]", HEADER_COLOR|SMLSIZE);
lcdDrawNumber(MENU_DEBUG_COL1_OFS+30, MENU_DEBUG_Y_LUA, 10*maxLuaDuration, LEFT);
lcdDrawText(MENU_DEBUG_COL1_OFS+60, MENU_DEBUG_Y_LUA+1, "[Interval]", HEADER_COLOR|SMLSIZE);
lcdDrawNumber(MENU_DEBUG_COL1_OFS+90, MENU_DEBUG_Y_LUA, 10*maxLuaInterval, LEFT);
#endif
lcd_putsLeft(MENU_DEBUG_Y_MIXMAX, STR_TMIXMAXMS);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_DEBUG_Y_MIXMAX, STR_TMIXMAXMS);
lcdDrawNumber(MENU_DEBUG_COL1_OFS, MENU_DEBUG_Y_MIXMAX, DURATION_MS_PREC2(maxMixerDuration), PREC2|LEFT, 0, NULL, "ms");
lcd_putsLeft(MENU_DEBUG_Y_RTOS, STR_FREESTACKMINB);
lcdDrawText(MENUS_MARGIN_LEFT, MENU_DEBUG_Y_RTOS, STR_FREESTACKMINB);
lcdDrawText(MENU_DEBUG_COL1_OFS, MENU_DEBUG_Y_RTOS+1, "[Menus]", HEADER_COLOR|SMLSIZE);
lcdDrawNumber(MENU_DEBUG_COL1_OFS+30, MENU_DEBUG_Y_RTOS, menusStack.available(), LEFT);
lcdDrawText(MENU_DEBUG_COL1_OFS+60, MENU_DEBUG_Y_RTOS+1, "[Mix]", HEADER_COLOR|SMLSIZE);

42
radio/src/gui/Horus/widgets.cpp
View file

@ -118,7 +118,7 @@ void drawScrollbar(coord_t x, coord_t y, coord_t h, uint16_t offset, uint16_t co
void drawProgressBar(const char *label)
{
lcd_putsLeft(4*FH, label);
lcdDrawText(MENUS_MARGIN_LEFT, 4*FH, label);
lcdDrawRect(3, 6*FH+4, 204, 7);
lcdRefresh();
}
@ -163,6 +163,38 @@ void drawScreenTemplate(const char * title)
#define MENU_ICONS_SPACING 31
void drawSubmenuTemplate(const char * name, uint16_t scrollbar_X)
{
// clear the screen
lcdDrawSolidFilledRect(0, 0, LCD_W, MENU_HEADER_HEIGHT, HEADER_BGCOLOR);
lcdDrawSolidFilledRect(0, MENU_HEADER_HEIGHT, LCD_W, MENU_TITLE_TOP-MENU_HEADER_HEIGHT, TEXT_BGCOLOR);
lcdDrawSolidFilledRect(0, MENU_TITLE_TOP, LCD_W, LCD_H-MENU_TITLE_TOP, TEXT_BGCOLOR);
lcdDrawBitmapPattern(0, 0, LBM_TOPMENU_POLYGON, TITLE_BGCOLOR);
lcdDrawSolidFilledRect(58+menuPageIndex*MENU_ICONS_SPACING-9, 0, 32, MENU_HEADER_HEIGHT, TITLE_BGCOLOR);
const uint8_t * const * icons = (g_menuPos[0] == 0 ? LBM_MODEL_ICONS : LBM_RADIO_ICONS);
lcdDrawBitmapPattern(5, 7, icons[0], MENU_TITLE_COLOR);
for (int i=0; i<menuPageCount; i++) {
lcdDrawBitmapPattern(50+i*MENU_ICONS_SPACING, 7, icons[i+1], MENU_TITLE_COLOR);
}
drawTopmenuDatetime();
if (name) {
// must be done at the end so that we can write something at the right of the menu title
lcdDrawText(MENUS_MARGIN_LEFT, MENU_TITLE_TOP+1, name, TEXT_COLOR);
lcdDrawSolidFilledRect(MENUS_MARGIN_LEFT-4, MENU_TITLE_TOP+19, 220, 2, TITLE_BGCOLOR);
}
if (scrollbar_X && linesCount > NUM_BODY_LINES) {
drawScrollbar(scrollbar_X, DEFAULT_SCROLLBAR_Y, DEFAULT_SCROLLBAR_H, s_pgOfs, linesCount, NUM_BODY_LINES);
}
}
void drawMenuTemplate(const char * name, uint16_t scrollbar_X)
{
// clear the screen
@ -207,23 +239,21 @@ void drawMenuTemplate(const char * name, uint16_t scrollbar_X)
}
}
select_menu_value_t selectMenuItem(coord_t x, coord_t y, const pm_char *label, const pm_char *values, select_menu_value_t value, select_menu_value_t min, select_menu_value_t max, LcdFlags attr, evt_t event)
select_menu_value_t selectMenuItem(coord_t x, coord_t y, const pm_char * values, select_menu_value_t value, select_menu_value_t min, select_menu_value_t max, LcdFlags attr, evt_t event)
{
lcd_putsColumnLeft(x, y, label);
if (attr) value = checkIncDec(event, value, min, max, (g_menuPos[0] == 0) ? EE_MODEL : EE_GENERAL);
if (values) lcdDrawTextAtIndex(x, y, values, value-min, attr);
return value;
}
uint8_t onoffMenuItem(uint8_t value, coord_t x, coord_t y, const pm_char *label, LcdFlags attr, evt_t event )
uint8_t onoffMenuItem(uint8_t value, coord_t x, coord_t y, LcdFlags attr, evt_t event )
{
drawCheckBox(x, y, value, attr);
return selectMenuItem(x, y, label, NULL, value, 0, 1, attr, event);
return selectMenuItem(x, y, NULL, value, 0, 1, attr, event);
}
int8_t switchMenuItem(coord_t x, coord_t y, int8_t value, LcdFlags attr, evt_t event)
{
lcd_putsColumnLeft(x, y, STR_SWITCH);
if (attr) CHECK_INCDEC_MODELSWITCH(event, value, SWSRC_FIRST_IN_MIXES, SWSRC_LAST_IN_MIXES, isSwitchAvailableInMixes);
putsSwitches(x, y, value, attr);
return value;

2
radio/src/gui/Taranis/lcd.cpp
View file

@ -639,7 +639,7 @@ void putsStickName(coord_t x, coord_t y, uint8_t idx, LcdFlags att)
void putsMixerSource(coord_t x, coord_t y, uint32_t idx, LcdFlags att)
{
if (idx == 0) {
if (idx == MIXSRC_NONE) {
lcdDrawTextAtIndex(x, y, STR_VSRCRAW, 0, att); // TODO macro
}
else if (idx <= MIXSRC_LAST_INPUT) {

8
radio/src/myeeprom.h
View file

@ -118,7 +118,7 @@
#define MAX_SCRIPTS 7
#define MAX_INPUTS 32
#define NUM_TRAINER 16
#define NUM_POTS 3
#define NUM_POTS 7
#define NUM_XPOTS 3
#define MAX_SENSORS 32
#elif defined(PCBFLAMENCO)
@ -1943,7 +1943,9 @@ enum MixSources {
MIXSRC_FIRST_SLIDER,
MIXSRC_SLIDER1 = MIXSRC_FIRST_SLIDER, LUA_EXPORT("ls", "Left slider")
MIXSRC_SLIDER2, LUA_EXPORT("rs", "Right slider")
MIXSRC_LAST_POT = MIXSRC_SLIDER2,
MIXSRC_SLIDER3, LUA_EXPORT("ls2", "Left center slider")
MIXSRC_SLIDER4, LUA_EXPORT("rs2", "Right center slider")
MIXSRC_LAST_POT = MIXSRC_SLIDER4,
#elif defined(PCBFLAMENCO)
MIXSRC_POT1 = MIXSRC_FIRST_POT, LUA_EXPORT("sd", "Potentiometer D")
MIXSRC_SLIDER1, LUA_EXPORT("ls", "Left slider")
@ -1971,7 +1973,7 @@ enum MixSources {
MIXSRC_P2,
MIXSRC_P3,
MIXSRC_LAST_POT = MIXSRC_P3,
#endif
#endif
#if defined(PCBSKY9X)
MIXSRC_REa,

6
radio/src/strhelpers.cpp
View file

@ -97,7 +97,7 @@ int zchar2str(char *dest, const char *src, int size)
#endif
#if defined(CPUARM)
unsigned int effectiveLen(const char *str, unsigned int size)
unsigned int effectiveLen(const char * str, unsigned int size)
{
while (size > 0) {
if (str[size-1] != ' ')
@ -107,7 +107,7 @@ unsigned int effectiveLen(const char *str, unsigned int size)
return 0;
}
bool zexist(const char *str, uint8_t size)
bool zexist(const char * str, uint8_t size)
{
for (int i=0; i<size; i++) {
if (str[i] != 0)
@ -116,7 +116,7 @@ bool zexist(const char *str, uint8_t size)
return false;
}
uint8_t zlen(const char *str, uint8_t size)
uint8_t zlen(const char * str, uint8_t size)
{
while (size > 0) {
if (str[size-1] != 0)

5
radio/src/translations/en.h.txt
View file

@ -465,7 +465,10 @@
#define TR_STICKS_VSRCRAW TR("Rud\0""Ele\0""Thr\0""Ail\0", "\307Rud""\307Ele""\307Thr""\307Ail")
#define TR_TRIMS_VSRCRAW TR("TrmR""TrmE""TrmT""TrmA", "\313Rud""\313Ele""\313Thr""\313Ail")
#if defined(PCBFLAMENCO)
#if defined(PCBHORUS)
#define TR_POTS_VSRCRAW "\310F1\0""\310F2\0""\310F3\0""\311S1\0""\311S2\0""\311LS\0""\311RS\0"
#define TR_SW_VSRCRAW "\312SA\0""\312SB\0""\312SC\0""\312SD\0""\312SE\0""\312SF\0""\312SG\0""\312SH\0"
#elif defined(PCBFLAMENCO)
#define TR_POTS_VSRCRAW "SD\0 ""LS\0 ""RS\0 "
#define TR_SW_VSRCRAW "SA\0 ""SB\0 ""SC\0 ""SE\0 ""SF\0 "
#elif defined(PCBTARANIS) && defined(REV9E)

6
radio/util/font2png.py
View file

@ -49,12 +49,12 @@ def createFontBitmap(filename, fontname, fontsize, fontbold, foreground, backgro
width = getFontWidth(fontsize, metrics)
top, bottom = getFontTopBottom(fontsize, metrics)
extraImage = QtGui.QImage("fonts/extra_%dpx.png" % (fontsize+1))
extraImage = QtGui.QImage("fonts/extra_%dpx.png" % fontsize)
if extraImage.isNull():
extraWidth = 0
else:
extraWidth = extraImage.size().width()
image = QtGui.QImage(width + extraWidth, fontsize+1, QtGui.QImage.Format_RGB32)
image = QtGui.QImage(width + extraWidth, fontsize+2, QtGui.QImage.Format_RGB32)
image.fill(background)
painter = QtGui.QPainter()
painter.begin(image)
@ -73,7 +73,7 @@ def createFontBitmap(filename, fontname, fontsize, fontbold, foreground, backgro
if fontsize >= 24:
painter.drawText(width-rect.left()+1, fontsize-2, c) # fontsize-bottom+1 -17 / 7
else:
painter.drawText(width-rect.left(), fontsize-2, c) # fontsize-bottom+1 -17 / 7
painter.drawText(width-rect.left(), fontsize-1, c) # fontsize-bottom+1 -17 / 7
width += getCharWidth(fontsize, metrics, i)
if extraWidth:
painter.drawImage(QtCore.QPoint(width, 0), extraImage)