ModelMenu split - 7th part

companion/src/firmwares/opentx/opentxGruvin9xsimulator.cpp

@@ -75,6 +75,11 @@ namespace Open9xGruvin9x {
 #include "radio/src/vario.cpp"
 #include "radio/src/gui/menus.cpp"
 #include "radio/src/gui/menu_model.cpp"
+#include "radio/src/gui/menu_model_select.cpp"
+#include "radio/src/gui/menu_model_setup.cpp"
+#include "radio/src/gui/menu_model_heli.cpp"
+#include "radio/src/gui/menu_model_flightmodes.cpp"
+#include "radio/src/gui/menu_model_inputs_mixes.cpp"
 #include "radio/src/gui/menu_model_logical_switches.cpp"
 #include "radio/src/gui/menu_model_custom_functions.cpp"
 #include "radio/src/gui/menu_model_curves.cpp"

companion/src/firmwares/opentx/opentxM128simulator.cpp

@@ -76,6 +76,11 @@ namespace OpenTxM128 {
 #include "radio/src/vario.cpp"
 #include "radio/src/gui/menus.cpp"
 #include "radio/src/gui/menu_model.cpp"
+#include "radio/src/gui/menu_model_select.cpp"
+#include "radio/src/gui/menu_model_setup.cpp"
+#include "radio/src/gui/menu_model_heli.cpp"
+#include "radio/src/gui/menu_model_flightmodes.cpp"
+#include "radio/src/gui/menu_model_inputs_mixes.cpp"
 #include "radio/src/gui/menu_model_curves.cpp"
 #include "radio/src/gui/menu_model_logical_switches.cpp"
 #include "radio/src/gui/menu_model_custom_functions.cpp"

companion/src/firmwares/opentx/opentxM64simulator.cpp

@@ -81,6 +81,11 @@ namespace OpenTxM64 {
 #include "radio/src/vario.cpp"
 #include "radio/src/gui/menus.cpp"
 #include "radio/src/gui/menu_model.cpp"
+#include "radio/src/gui/menu_model_select.cpp"
+#include "radio/src/gui/menu_model_setup.cpp"
+#include "radio/src/gui/menu_model_heli.cpp"
+#include "radio/src/gui/menu_model_flightmodes.cpp"
+#include "radio/src/gui/menu_model_inputs_mixes.cpp"
 #include "radio/src/gui/menu_model_curves.cpp"
 #include "radio/src/gui/menu_model_logical_switches.cpp"
 #include "radio/src/gui/menu_model_custom_functions.cpp"

companion/src/firmwares/opentx/opentxSky9xsimulator.cpp

@@ -90,6 +90,11 @@ namespace Open9xSky9x {
 #include "radio/src/vario.cpp"
 #include "radio/src/gui/menus.cpp"
 #include "radio/src/gui/menu_model.cpp"
+#include "radio/src/gui/menu_model_select.cpp"
+#include "radio/src/gui/menu_model_setup.cpp"
+#include "radio/src/gui/menu_model_heli.cpp"
+#include "radio/src/gui/menu_model_flightmodes.cpp"
+#include "radio/src/gui/menu_model_inputs_mixes.cpp"
 #include "radio/src/gui/menu_model_curves.cpp"
 #include "radio/src/gui/menu_model_logical_switches.cpp"
 #include "radio/src/gui/menu_model_custom_functions.cpp"

companion/src/firmwares/opentx/opentxTaranisSimulator.cpp

@@ -96,6 +96,11 @@ inline int geteepromsize() {
 #include "radio/src/vario.cpp"
 #include "radio/src/gui/menus.cpp"
 #include "radio/src/gui/menu_model.cpp"
+#include "radio/src/gui/menu_model_select.cpp"
+#include "radio/src/gui/menu_model_setup.cpp"
+#include "radio/src/gui/menu_model_heli.cpp"
+#include "radio/src/gui/menu_model_flightmodes.cpp"
+#include "radio/src/gui/menu_model_inputs_mixes.cpp"
 #include "radio/src/gui/menu_model_curves.cpp"
 #include "radio/src/gui/menu_model_logical_switches.cpp"
 #include "radio/src/gui/menu_model_custom_functions.cpp"

companion/src/firmwares/opentx/opentxTaranisX9ESimulator.cpp

@@ -98,12 +98,17 @@ inline int geteepromsize() {
 #include "radio/src/vario.cpp"
 #include "radio/src/gui/menus.cpp"
 #include "radio/src/gui/menu_model.cpp"
+#include "radio/src/gui/menu_model_select.cpp"
+#include "radio/src/gui/menu_model_setup.cpp"
+#include "radio/src/gui/menu_model_heli.cpp"
+#include "radio/src/gui/menu_model_flightmodes.cpp"
+#include "radio/src/gui/menu_model_inputs_mixes.cpp"
+#include "radio/src/gui/menu_model_limits.cpp"
 #include "radio/src/gui/menu_model_curves.cpp"
 #include "radio/src/gui/menu_model_logical_switches.cpp"
 #include "radio/src/gui/menu_model_custom_functions.cpp"
 #include "radio/src/gui/menu_model_custom_scripts.cpp"
 #include "radio/src/gui/menu_model_gvars.cpp"
-#include "radio/src/gui/menu_model_limits.cpp"
 #include "radio/src/gui/menu_model_telemetry.cpp"
 #include "radio/src/gui/menu_general.cpp"
 #include "radio/src/gui/Taranis/view_main.cpp"

radio/src/Makefile

@@ -365,7 +365,7 @@ M128_VARIANT    = +32768
 M2561_VARIANT   = +16384
 EEPROM_VARIANT  = 0
 
-GUIMODELSRC = gui/menu_model.cpp gui/menu_model_limits.cpp gui/menu_model_logical_switches.cpp gui/menu_model_custom_functions.cpp gui/menu_model_telemetry.cpp
+GUIMODELSRC = gui/menu_model.cpp gui/menu_model_select.cpp gui/menu_model_setup.cpp gui/menu_model_inputs_mixes.cpp gui/menu_model_limits.cpp gui/menu_model_logical_switches.cpp gui/menu_model_custom_functions.cpp gui/menu_model_telemetry.cpp
 
 ifeq ($(PCB), $(filter $(PCB), STD 9X 9XR))
   # 9x/9xr radio
@@ -1012,6 +1012,7 @@ endif
 
 ifeq ($(FLIGHT_MODES), YES)
   CPPDEFS += -DFLIGHT_MODES
+  GUIMODELSRC += gui/menu_model_flightmodes.cpp
 endif
 
 ifeq ($(CURVES), YES)
@@ -1166,6 +1167,7 @@ endif
 
 ifeq ($(HELI), YES)
   CPPDEFS += -DHELI
+  GUIMODELSRC += gui/menu_model_heli.cpp
 endif
 
 ifeq ($(TEMPLATES), YES)

radio/src/gui/menu_model_flightmodes.cpp

@@ -0,0 +1,411 @@
+/*
+ * Authors (alphabetical order)
+ * - Andre Bernet <bernet.andre@gmail.com>
+ * - Andreas Weitl
+ * - Bertrand Songis <bsongis@gmail.com>
+ * - Bryan J. Rentoul (Gruvin) <gruvin@gmail.com>
+ * - Cameron Weeks <th9xer@gmail.com>
+ * - Erez Raviv
+ * - Gabriel Birkus
+ * - Jean-Pierre Parisy
+ * - Karl Szmutny
+ * - Michael Blandford
+ * - Michal Hlavinka
+ * - Pat Mackenzie
+ * - Philip Moss
+ * - Rob Thomson
+ * - Thomas Husterer
+ *
+ * opentx is based on code named
+ * gruvin9x by Bryan J. Rentoul: http://code.google.com/p/gruvin9x/,
+ * er9x by Erez Raviv: http://code.google.com/p/er9x/,
+ * and the original (and ongoing) project by
+ * Thomas Husterer, th9x: http://code.google.com/p/th9x/
+ *
+ * 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"
+
+#if defined(PCBTARANIS)
+void displayFlightModes(coord_t x, coord_t y, FlightModesType value)
+{
+  lcd_puts(x, y, STR_FP);
+  x = lcdNextPos + 1;
+  for (uint8_t p=0; p<MAX_FLIGHT_MODES; p++) {
+    lcd_putc(x, y, ((value & (1<<p)) ? '-' : '0'+p));
+    x += 5;
+  }
+}
+#else
+void displayFlightModes(coord_t x, coord_t y, FlightModesType value)
+{
+  uint8_t p = MAX_FLIGHT_MODES;
+  do {
+    --p;
+    if (!(value & (1<<p)))
+      lcd_putc(x, y, '0'+p);
+    x -= FWNUM;
+  } while (p!=0);
+}
+#endif
+
+#if defined(PCBTARANIS)
+
+enum FlightModesItems {
+  ITEM_FLIGHT_MODES_NAME,
+  ITEM_FLIGHT_MODES_SWITCH,
+  ITEM_FLIGHT_MODES_TRIM_RUD,
+  ITEM_FLIGHT_MODES_TRIM_ELE,
+  ITEM_FLIGHT_MODES_TRIM_THR,
+  ITEM_FLIGHT_MODES_TRIM_AIL,
+  ITEM_FLIGHT_MODES_FADE_IN,
+  ITEM_FLIGHT_MODES_FADE_OUT,
+  ITEM_FLIGHT_MODES_COUNT,
+  ITEM_FLIGHT_MODES_LAST = ITEM_FLIGHT_MODES_COUNT-1
+};
+
+bool isTrimModeAvailable(int mode)
+{
+  return (mode < 0 || (mode%2) == 0 || (mode/2) != (m_posVert-1));
+}
+
+void menuModelFlightModesAll(uint8_t event)
+{
+  MENU(STR_MENUFLIGHTPHASES, menuTabModel, e_FlightModesAll, 1+MAX_FLIGHT_MODES+1, {0, NAVIGATION_LINE_BY_LINE|(ITEM_FLIGHT_MODES_LAST-1), NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, 0});
+
+  int8_t sub = m_posVert - 1;
+
+  horzpos_t posHorz = m_posHorz;
+  if (sub==0 && posHorz > 0) { posHorz += 1; }
+
+  if (sub<MAX_FLIGHT_MODES && posHorz>=0) {
+    displayColumnHeader(STR_PHASES_HEADERS, posHorz);
+  }
+
+  for (uint8_t i=0; i<LCD_LINES-1; i++) {
+    coord_t y = MENU_TITLE_HEIGHT + 1 + i*FH;
+    uint8_t k = i+s_pgOfs;
+
+    if (k==MAX_FLIGHT_MODES) {
+      // last line available - add the "check trims" line
+      lcd_putsLeft((LCD_LINES-1)*FH+1, STR_CHECKTRIMS);
+      putsFlightMode(OFS_CHECKTRIMS, (LCD_LINES-1)*FH+1, mixerCurrentFlightMode+1);
+      if (sub==MAX_FLIGHT_MODES) {
+        if (!trimsCheckTimer) {
+          if (event == EVT_KEY_FIRST(KEY_ENTER)) {
+            trimsCheckTimer = 200; // 2 seconds trims cancelled
+            s_editMode = 1;
+            killEvents(event);
+          }
+          else {
+            lcd_status_line();
+            s_editMode = 0;
+          }
+        }
+        else {
+          if (event == EVT_KEY_FIRST(KEY_EXIT)) {
+            trimsCheckTimer = 0;
+            s_editMode = 0;
+            killEvents(event);
+          }
+        }
+      }
+      return;
+    }
+
+    FlightModeData *p = flightModeAddress(k);
+
+    putsFlightMode(0, y, k+1, (getFlightMode()==k ? BOLD : 0) | ((sub==k && m_posHorz<0) ? INVERS : 0));
+
+    for (uint8_t j=0; j<ITEM_FLIGHT_MODES_COUNT; j++) {
+      uint8_t attr = ((sub==k && posHorz==j) ? ((s_editMode>0) ? BLINK|INVERS : INVERS) : 0);
+      uint8_t active = (attr && (s_editMode>0 || p1valdiff)) ;
+      switch (j) {
+        case ITEM_FLIGHT_MODES_NAME:
+          editName(4*FW-1, y, p->name, sizeof(p->name), event, attr);
+          break;
+
+        case ITEM_FLIGHT_MODES_SWITCH:
+          putsSwitches((5+LEN_FLIGHT_MODE_NAME)*FW+FW/2, y, p->swtch, attr);
+          if (active) CHECK_INCDEC_MODELSWITCH(event, p->swtch, SWSRC_FIRST_IN_MIXES, SWSRC_LAST_IN_MIXES, isSwitchAvailableInMixes);
+          break;
+
+        case ITEM_FLIGHT_MODES_TRIM_RUD:
+        case ITEM_FLIGHT_MODES_TRIM_ELE:
+        case ITEM_FLIGHT_MODES_TRIM_THR:
+        case ITEM_FLIGHT_MODES_TRIM_AIL:
+        {
+          uint8_t t = j-ITEM_FLIGHT_MODES_TRIM_RUD;
+          putsTrimMode((4+LEN_FLIGHT_MODE_NAME)*FW+j*(5*FW/2), y, k, t, attr);
+          if (active) {
+            trim_t & v = p->trim[t];
+            v.mode = checkIncDec(event, v.mode==TRIM_MODE_NONE ? -1 : v.mode, -1, k==0 ? 0 : 2*MAX_FLIGHT_MODES-1, EE_MODEL, isTrimModeAvailable);
+          }
+          break;
+        }
+
+        case ITEM_FLIGHT_MODES_FADE_IN:
+          lcd_outdezAtt(32*FW-2, y, (10/DELAY_STEP)*p->fadeIn, attr|PREC1);
+          if (active) p->fadeIn = checkIncDec(event, p->fadeIn, 0, DELAY_MAX, EE_MODEL|NO_INCDEC_MARKS);
+          break;
+
+        case ITEM_FLIGHT_MODES_FADE_OUT:
+          lcd_outdezAtt(35*FW, y, (10/DELAY_STEP)*p->fadeOut, attr|PREC1);
+          if (active) p->fadeOut = checkIncDec(event, p->fadeOut, 0, DELAY_MAX, EE_MODEL|NO_INCDEC_MARKS);
+          break;
+
+      }
+    }
+  }
+}
+
+#else // PCBTARANIS
+
+enum menuModelPhaseItems {
+  ITEM_MODEL_PHASE_NAME,
+  ITEM_MODEL_PHASE_SWITCH,
+  ITEM_MODEL_PHASE_TRIMS,
+  IF_ROTARY_ENCODERS(ITEM_MODEL_PHASE_ROTARY_ENCODERS)
+  ITEM_MODEL_PHASE_FADE_IN,
+  ITEM_MODEL_PHASE_FADE_OUT,
+#if defined(GVARS) && !defined(PCBSTD)
+  ITEM_MODEL_PHASE_GVARS_LABEL,
+  ITEM_MODEL_PHASE_GV1,
+  ITEM_MODEL_PHASE_GV2,
+  ITEM_MODEL_PHASE_GV3,
+  ITEM_MODEL_PHASE_GV4,
+  ITEM_MODEL_PHASE_GV5,
+#if defined(CPUARM)
+  ITEM_MODEL_PHASE_GV6,
+  ITEM_MODEL_PHASE_GV7,
+  ITEM_MODEL_PHASE_GV8,
+  ITEM_MODEL_PHASE_GV9,
+#endif
+#endif
+  ITEM_MODEL_PHASE_MAX
+};
+
+void menuModelPhaseOne(uint8_t event)
+{
+  FlightModeData *fm = flightModeAddress(s_currIdx);
+  putsFlightMode(13*FW, 0, s_currIdx+1, (getFlightMode()==s_currIdx ? BOLD : 0));
+
+#if defined(GVARS) && !defined(PCBSTD)
+  static const pm_uint8_t mstate_tab_fm1[] PROGMEM = {0, 0, 0, (uint8_t)-1, 1, 1, 1, 1, 1};
+  static const pm_uint8_t mstate_tab_others[] PROGMEM = {0, 0, 3, IF_ROTARY_ENCODERS(NUM_ROTARY_ENCODERS-1) 0, 0, (uint8_t)-1, 2, 2, 2, 2, 2};
+
+  check(event, 0, NULL, 0, (s_currIdx == 0) ? mstate_tab_fm1 : mstate_tab_others, DIM(mstate_tab_others)-1, ITEM_MODEL_PHASE_MAX - 1 - (s_currIdx==0 ? (ITEM_MODEL_PHASE_FADE_IN-ITEM_MODEL_PHASE_SWITCH) : 0));
+
+  TITLE(STR_MENUFLIGHTPHASE);
+
+  #define PHASE_ONE_FIRST_LINE (1+1*FH)
+#else
+  SUBMENU(STR_MENUFLIGHTPHASE, 3 + (s_currIdx==0 ? 0 : 2 + (bool)NUM_ROTARY_ENCODERS), {0, 0, 3, IF_ROTARY_ENCODERS(NUM_ROTARY_ENCODERS-1) 0/*, 0*/});
+  #define PHASE_ONE_FIRST_LINE (1+1*FH)
+#endif
+
+  int8_t sub = m_posVert;
+  int8_t editMode = s_editMode;
+
+#if defined(GVARS) && !defined(PCBSTD)
+  if (s_currIdx == 0 && sub>=ITEM_MODEL_PHASE_SWITCH) sub += ITEM_MODEL_PHASE_FADE_IN-ITEM_MODEL_PHASE_SWITCH;
+
+  for (uint8_t k=0; k<LCD_LINES-1; k++) {
+    coord_t y = MENU_TITLE_HEIGHT + 1 + k*FH;
+    int8_t i = k + s_pgOfs;
+    if (s_currIdx == 0 && i>=ITEM_MODEL_PHASE_SWITCH) i += ITEM_MODEL_PHASE_FADE_IN-ITEM_MODEL_PHASE_SWITCH;
+    uint8_t attr = (sub==i ? (editMode>0 ? BLINK|INVERS : INVERS) : 0);
+#else
+  for (uint8_t i=0, k=0, y=PHASE_ONE_FIRST_LINE; i<ITEM_MODEL_PHASE_MAX; i++, k++, y+=FH) {
+    if (s_currIdx == 0 && i==ITEM_MODEL_PHASE_SWITCH) i = ITEM_MODEL_PHASE_FADE_IN;
+    uint8_t attr = (sub==k ? (editMode>0 ? BLINK|INVERS : INVERS) : 0);
+#endif
+    switch(i) {
+      case ITEM_MODEL_PHASE_NAME:
+        editSingleName(MIXES_2ND_COLUMN, y, STR_PHASENAME, fm->name, sizeof(fm->name), event, attr);
+        break;
+      case ITEM_MODEL_PHASE_SWITCH:
+        fm->swtch = switchMenuItem(MIXES_2ND_COLUMN, y, fm->swtch, attr, event);
+        break;
+      case ITEM_MODEL_PHASE_TRIMS:
+        lcd_putsLeft(y, STR_TRIMS);
+        for (uint8_t t=0; t<NUM_STICKS; t++) {
+          putsTrimMode(MIXES_2ND_COLUMN+(t*FW), y, s_currIdx, t, m_posHorz==t ? attr : 0);
+          if (attr && m_posHorz==t && ((editMode>0) || p1valdiff)) {
+            int16_t v = getRawTrimValue(s_currIdx, t);
+            if (v < TRIM_EXTENDED_MAX) v = TRIM_EXTENDED_MAX;
+            v = checkIncDec(event, v, TRIM_EXTENDED_MAX, TRIM_EXTENDED_MAX+MAX_FLIGHT_MODES-1, EE_MODEL);
+            if (checkIncDec_Ret) {
+              if (v == TRIM_EXTENDED_MAX) v = 0;
+              setTrimValue(s_currIdx, t, v);
+            }
+          }
+        }
+        break;
+
+#if ROTARY_ENCODERS > 0
+      case ITEM_MODEL_PHASE_ROTARY_ENCODERS:
+        lcd_putsLeft(y, STR_ROTARY_ENCODER);
+        for (uint8_t t=0; t<NUM_ROTARY_ENCODERS; t++) {
+          putsRotaryEncoderMode(MIXES_2ND_COLUMN+(t*FW), y, s_currIdx, t, m_posHorz==t ? attr : 0);
+          if (attr && m_posHorz==t && ((editMode>0) || p1valdiff)) {
+            int16_t v = flightModeAddress(s_currIdx)->rotaryEncoders[t];
+            if (v < ROTARY_ENCODER_MAX) v = ROTARY_ENCODER_MAX;
+            v = checkIncDec(event, v, ROTARY_ENCODER_MAX, ROTARY_ENCODER_MAX+MAX_FLIGHT_MODES-1, EE_MODEL);
+            if (checkIncDec_Ret) {
+              if (v == ROTARY_ENCODER_MAX) v = 0;
+              flightModeAddress(s_currIdx)->rotaryEncoders[t] = v;
+            }
+          }
+        }
+        break;
+#endif
+
+      case ITEM_MODEL_PHASE_FADE_IN:
+        fm->fadeIn = EDIT_DELAY(0, y, event, attr, STR_FADEIN, fm->fadeIn);
+        break;
+
+      case ITEM_MODEL_PHASE_FADE_OUT:
+        fm->fadeOut = EDIT_DELAY(0, y, event, attr, STR_FADEOUT, fm->fadeOut);
+        break;
+
+#if defined(GVARS) && !defined(PCBSTD)
+      case ITEM_MODEL_PHASE_GVARS_LABEL:
+        lcd_putsLeft(y, STR_GLOBAL_VARS);
+        break;
+
+      default:
+      {
+        uint8_t idx = i-ITEM_MODEL_PHASE_GV1;
+        uint8_t posHorz = m_posHorz;
+        if (attr && posHorz > 0 && s_currIdx==0) posHorz++;
+
+        putsStrIdx(INDENT_WIDTH, y, STR_GV, idx+1);
+
+        editName(4*FW, y, g_model.gvars[idx].name, LEN_GVAR_NAME, event, posHorz==0 ? attr : 0);
+
+        int16_t v = fm->gvars[idx];
+        if (v > GVAR_MAX) {
+          uint8_t p = v - GVAR_MAX - 1;
+          if (p >= s_currIdx) p++;
+          putsFlightMode(11*FW, y, p+1, posHorz==1 ? attr : 0);
+        }
+        else {
+          lcd_putsAtt(11*FW, y, STR_OWN, posHorz==1 ? attr : 0);
+        }
+        if (attr && s_currIdx>0 && posHorz==1 && (editMode>0 || p1valdiff)) {
+          if (v < GVAR_MAX) v = GVAR_MAX;
+          v = checkIncDec(event, v, GVAR_MAX, GVAR_MAX+MAX_FLIGHT_MODES-1, EE_MODEL);
+          if (checkIncDec_Ret) {
+            if (v == GVAR_MAX) v = 0;
+            fm->gvars[idx] = v;
+          }
+        }
+
+        uint8_t p = getGVarFlightPhase(s_currIdx, idx);
+        lcd_outdezAtt(21*FW, y, GVAR_VALUE(idx, p), posHorz==2 ? attr : 0);
+        if (attr && posHorz==2 && ((editMode>0) || p1valdiff)) {
+          GVAR_VALUE(idx, p) = checkIncDec(event, GVAR_VALUE(idx, p), -GVAR_LIMIT, GVAR_LIMIT, EE_MODEL);
+        }
+
+        break;
+      }
+#endif
+    }
+  }
+}
+
+#if defined(ROTARY_ENCODERS)
+  #if ROTARY_ENCODERS > 2
+    #define NAME_OFS (-4-12)
+    #define SWITCH_OFS (-FW/2-2-13)
+    #define TRIMS_OFS  (-FW/2-4-15)
+    #define ROTARY_ENC_OFS (0)
+  #else
+    #define NAME_OFS (-4)
+    #define SWITCH_OFS (-FW/2-2)
+    #define TRIMS_OFS  (-FW/2-4)
+    #define ROTARY_ENC_OFS (2)
+  #endif
+#else
+  #define NAME_OFS 0
+  #define SWITCH_OFS (FW/2)
+  #define TRIMS_OFS  (FW/2)
+#endif
+
+void menuModelFlightModesAll(uint8_t event)
+{
+  SIMPLE_MENU(STR_MENUFLIGHTPHASES, menuTabModel, e_FlightModesAll, 1+MAX_FLIGHT_MODES+1);
+
+  int8_t sub = m_posVert - 1;
+
+  switch (event) {
+    CASE_EVT_ROTARY_BREAK
+    case EVT_KEY_FIRST(KEY_ENTER):
+      if (sub == MAX_FLIGHT_MODES) {
+        s_editMode = 0;
+        trimsCheckTimer = 200; // 2 seconds
+      }
+      // no break
+    case EVT_KEY_FIRST(KEY_RIGHT):
+      if (sub >= 0 && sub < MAX_FLIGHT_MODES) {
+        s_currIdx = sub;
+        pushMenu(menuModelPhaseOne);
+      }
+      break;
+  }
+
+  uint8_t att;
+  for (uint8_t i=0; i<MAX_FLIGHT_MODES; i++) {
+#if defined(CPUARM)
+    coord_t y = MENU_TITLE_HEIGHT + 1 + (i-s_pgOfs)*FH;
+    if (y<MENU_TITLE_HEIGHT+1 || y>(LCD_LINES-1)*FH+MENU_TITLE_HEIGHT-FH) continue;
+#else
+    coord_t y = MENU_TITLE_HEIGHT + 1 + i*FH;
+#endif
+    att = (i==sub ? INVERS : 0);
+    FlightModeData *p = flightModeAddress(i);
+    putsFlightMode(0, y, i+1, att|(getFlightMode()==i ? BOLD : 0));
+
+    lcd_putsnAtt(4*FW+NAME_OFS, y, p->name, sizeof(p->name), ZCHAR);
+    if (i == 0) {
+      lcd_puts((5+LEN_FLIGHT_MODE_NAME)*FW+SWITCH_OFS, y, STR_DEFAULT);
+    }
+    else {
+      putsSwitches((5+LEN_FLIGHT_MODE_NAME)*FW+SWITCH_OFS, y, p->swtch, 0);
+      for (uint8_t t=0; t<NUM_STICKS; t++) {
+        putsTrimMode((9+LEN_FLIGHT_MODE_NAME+t)*FW+TRIMS_OFS, y, i, t, 0);
+      }
+#if defined(PCBGRUVIN9X)
+      for (uint8_t t=0; t<NUM_ROTARY_ENCODERS; t++) {
+        putsRotaryEncoderMode((13+LEN_FLIGHT_MODE_NAME+t)*FW+TRIMS_OFS+ROTARY_ENC_OFS, y, i, t, 0);
+      }
+#endif
+    }
+
+    if (p->fadeIn || p->fadeOut)
+      lcd_putc(LCD_W-FW-MENUS_SCROLLBAR_WIDTH, y, (p->fadeIn && p->fadeOut) ? '*' : (p->fadeIn ? 'I' : 'O'));
+
+  }
+
+#if defined(CPUARM)
+  if (s_pgOfs != MAX_FLIGHT_MODES-(LCD_LINES-2)) return;
+#endif
+
+  lcd_putsLeft((LCD_LINES-1)*FH+1, STR_CHECKTRIMS);
+  putsFlightMode(OFS_CHECKTRIMS, (LCD_LINES-1)*FH+1, mixerCurrentFlightMode+1);
+  if (sub==MAX_FLIGHT_MODES && !trimsCheckTimer) {
+    lcd_status_line();
+  }
+}
+
+#endif // defined(PCBTARANIS)

radio/src/gui/menu_model_heli.cpp

@@ -0,0 +1,96 @@
+/*
+ * Authors (alphabetical order)
+ * - Andre Bernet <bernet.andre@gmail.com>
+ * - Andreas Weitl
+ * - Bertrand Songis <bsongis@gmail.com>
+ * - Bryan J. Rentoul (Gruvin) <gruvin@gmail.com>
+ * - Cameron Weeks <th9xer@gmail.com>
+ * - Erez Raviv
+ * - Gabriel Birkus
+ * - Jean-Pierre Parisy
+ * - Karl Szmutny
+ * - Michael Blandford
+ * - Michal Hlavinka
+ * - Pat Mackenzie
+ * - Philip Moss
+ * - Rob Thomson
+ * - Thomas Husterer
+ *
+ * opentx is based on code named
+ * gruvin9x by Bryan J. Rentoul: http://code.google.com/p/gruvin9x/,
+ * er9x by Erez Raviv: http://code.google.com/p/er9x/,
+ * and the original (and ongoing) project by
+ * Thomas Husterer, th9x: http://code.google.com/p/th9x/
+ *
+ * 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"
+
+enum menuModelHeliItems {
+  ITEM_HELI_SWASHTYPE,
+  ITEM_HELI_COLLECTIVE,
+  ITEM_HELI_SWASHRING,
+  ITEM_HELI_ELEDIRECTION,
+  ITEM_HELI_AILDIRECTION,
+  ITEM_HELI_COLDIRECTION
+};
+
+#if LCD_W >= 212
+  #define HELI_PARAM_OFS (23*FW)
+#else
+  #define HELI_PARAM_OFS (14*FW)
+#endif
+
+void menuModelHeli(uint8_t event)
+{
+  SIMPLE_MENU(STR_MENUHELISETUP, menuTabModel, e_Heli, 7);
+
+  uint8_t sub = m_posVert - 1;
+
+  for (uint8_t i=0; i<6; i++) {
+    coord_t y = MENU_TITLE_HEIGHT + 1 + i*FH;
+    uint8_t attr = (sub == i ? ((s_editMode>0) ? BLINK|INVERS : INVERS) : 0);
+    switch(i) {
+      case ITEM_HELI_SWASHTYPE:
+        g_model.swashR.type = selectMenuItem(HELI_PARAM_OFS, y, STR_SWASHTYPE, STR_VSWASHTYPE, g_model.swashR.type, 0, SWASH_TYPE_MAX, attr, event);
+        break;
+
+      case ITEM_HELI_COLLECTIVE:
+#if defined(PCBTARANIS)
+        lcd_putsLeft(y, STR_COLLECTIVE);
+        if (attr) CHECK_INCDEC_MODELSOURCE(event, g_model.swashR.collectiveSource, 0, MIXSRC_LAST_CH);
+#else
+        g_model.swashR.collectiveSource = selectMenuItem(HELI_PARAM_OFS, y, STR_COLLECTIVE, NULL, g_model.swashR.collectiveSource, 0, MIXSRC_LAST_CH, attr, event);
+#endif
+        putsMixerSource(HELI_PARAM_OFS, y, g_model.swashR.collectiveSource, attr);
+        break;
+
+      case ITEM_HELI_SWASHRING:
+        lcd_putsLeft(y, STR_SWASHRING);
+        lcd_outdezAtt(HELI_PARAM_OFS, y, g_model.swashR.value,  LEFT|attr);
+        if (attr) CHECK_INCDEC_MODELVAR_ZERO(event, g_model.swashR.value, 100);
+        break;
+
+      case ITEM_HELI_ELEDIRECTION:
+        g_model.swashR.invertELE = selectMenuItem(HELI_PARAM_OFS, y, STR_ELEDIRECTION, STR_MMMINV, g_model.swashR.invertELE, 0, 1, attr, event);
+        break;
+
+      case ITEM_HELI_AILDIRECTION:
+        g_model.swashR.invertAIL = selectMenuItem(HELI_PARAM_OFS, y, STR_AILDIRECTION, STR_MMMINV, g_model.swashR.invertAIL, 0, 1, attr, event);
+        break;
+
+      case ITEM_HELI_COLDIRECTION:
+        g_model.swashR.invertCOL = selectMenuItem(HELI_PARAM_OFS, y, STR_COLDIRECTION, STR_MMMINV, g_model.swashR.invertCOL, 0, 1, attr, event);
+        break;
+    }
+  }
+}

radio/src/gui/menu_model_select.cpp

@@ -0,0 +1,591 @@
+/*
+ * Authors (alphabetical order)
+ * - Andre Bernet <bernet.andre@gmail.com>
+ * - Andreas Weitl
+ * - Bertrand Songis <bsongis@gmail.com>
+ * - Bryan J. Rentoul (Gruvin) <gruvin@gmail.com>
+ * - Cameron Weeks <th9xer@gmail.com>
+ * - Erez Raviv
+ * - Gabriel Birkus
+ * - Jean-Pierre Parisy
+ * - Karl Szmutny
+ * - Michael Blandford
+ * - Michal Hlavinka
+ * - Pat Mackenzie
+ * - Philip Moss
+ * - Rob Thomson
+ * - Thomas Husterer
+ *
+ * opentx is based on code named
+ * gruvin9x by Bryan J. Rentoul: http://code.google.com/p/gruvin9x/,
+ * er9x by Erez Raviv: http://code.google.com/p/er9x/,
+ * and the original (and ongoing) project by
+ * Thomas Husterer, th9x: http://code.google.com/p/th9x/
+ *
+ * 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"
+
+uint8_t eeFindEmptyModel(uint8_t id, bool down)
+{
+  uint8_t i = id;
+  for (;;) {
+    i = (MAX_MODELS + (down ? i+1 : i-1)) % MAX_MODELS;
+    if (!eeModelExists(i)) break;
+    if (i == id) return 0xff; // no free space in directory left
+  }
+  return i;
+}
+
+void selectModel(uint8_t sub)
+{
+  displayPopup(STR_LOADINGMODEL);
+  saveTimers();
+  eeCheck(true); // force writing of current model data before this is changed
+  g_eeGeneral.currModel = sub;
+  eeDirty(EE_GENERAL);
+  eeLoadModel(sub);
+}
+
+#if defined(SDCARD)
+#define LIST_NONE_SD_FILE  1
+bool listSdFiles(const char *path, const char *extension, const uint8_t maxlen, const char *selection, uint8_t flags=0)
+{
+  FILINFO fno;
+  DIR dir;
+  char *fn;   /* This function is assuming non-Unicode cfg. */
+#if _USE_LFN
+  TCHAR lfn[_MAX_LFN + 1];
+  fno.lfname = lfn;
+  fno.lfsize = sizeof(lfn);
+#endif
+
+  static uint16_t s_last_menu_offset = 0;
+
+#if defined(CPUARM)
+  static uint8_t s_last_flags;
+
+  if (selection) {
+    s_last_flags = flags;
+    memset(reusableBuffer.modelsel.menu_bss, 0, sizeof(reusableBuffer.modelsel.menu_bss));
+    strcpy(reusableBuffer.modelsel.menu_bss[0], path);
+    strcat(reusableBuffer.modelsel.menu_bss[0], "/");
+    strncat(reusableBuffer.modelsel.menu_bss[0], selection, maxlen);
+    strcat(reusableBuffer.modelsel.menu_bss[0], extension);
+    if (f_stat(reusableBuffer.modelsel.menu_bss[0], &fno) != FR_OK) {
+      selection = NULL;
+    }
+  }
+  else {
+    flags = s_last_flags;
+  }
+#endif
+
+  if (s_menu_offset == 0) {
+    s_last_menu_offset = 0;
+    memset(reusableBuffer.modelsel.menu_bss, 0, sizeof(reusableBuffer.modelsel.menu_bss));
+  }
+  else if (s_menu_offset == s_menu_count - MENU_MAX_LINES) {
+    s_last_menu_offset = 0xffff;
+    memset(reusableBuffer.modelsel.menu_bss, 0, sizeof(reusableBuffer.modelsel.menu_bss));
+  }
+  else if (s_menu_offset == s_last_menu_offset) {
+    // should not happen, only there because of Murphy's law
+    return true;
+  }
+  else if (s_menu_offset > s_last_menu_offset) {
+    memmove(reusableBuffer.modelsel.menu_bss[0], reusableBuffer.modelsel.menu_bss[1], (MENU_MAX_LINES-1)*MENU_LINE_LENGTH);
+    memset(reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1], 0xff, MENU_LINE_LENGTH);
+  }
+  else {
+    memmove(reusableBuffer.modelsel.menu_bss[1], reusableBuffer.modelsel.menu_bss[0], (MENU_MAX_LINES-1)*MENU_LINE_LENGTH);
+    memset(reusableBuffer.modelsel.menu_bss[0], 0, MENU_LINE_LENGTH);
+  }
+
+  s_menu_count = 0;
+  s_menu_flags = BSS;
+
+  FRESULT res = f_opendir(&dir, path);        /* Open the directory */
+  if (res == FR_OK) {
+
+    if (flags & LIST_NONE_SD_FILE) {
+      s_menu_count++;
+      if (selection) {
+        s_last_menu_offset++;
+      }
+      else if (s_menu_offset==0 || s_menu_offset < s_last_menu_offset) {
+        char *line = reusableBuffer.modelsel.menu_bss[0];
+        memset(line, 0, MENU_LINE_LENGTH);
+        strcpy(line, "---");
+        s_menu[0] = line;
+      }
+    }
+
+    for (;;) {
+      res = f_readdir(&dir, &fno);                   /* Read a directory item */
+      if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
+
+#if _USE_LFN
+      fn = *fno.lfname ? fno.lfname : fno.fname;
+#else
+      fn = fno.fname;
+#endif
+
+      uint8_t len = strlen(fn);
+      if (len < 5 || len > maxlen+4 || strcasecmp(fn+len-4, extension) || (fno.fattrib & AM_DIR)) continue;
+
+      s_menu_count++;
+      fn[len-4] = '\0';
+
+      if (s_menu_offset == 0) {
+        if (selection && strncasecmp(fn, selection, maxlen) < 0) {
+          s_last_menu_offset++;
+        }
+        else {
+          for (uint8_t i=0; i<MENU_MAX_LINES; i++) {
+            char *line = reusableBuffer.modelsel.menu_bss[i];
+            if (line[0] == '\0' || strcasecmp(fn, line) < 0) {
+              if (i < MENU_MAX_LINES-1) memmove(reusableBuffer.modelsel.menu_bss[i+1], line, sizeof(reusableBuffer.modelsel.menu_bss[i]) * (MENU_MAX_LINES-1-i));
+              memset(line, 0, MENU_LINE_LENGTH);
+              strcpy(line, fn);
+              break;
+            }
+          }
+        }
+        for (uint8_t i=0; i<min(s_menu_count, (uint16_t)MENU_MAX_LINES); i++)
+          s_menu[i] = reusableBuffer.modelsel.menu_bss[i];
+      }
+      else if (s_last_menu_offset == 0xffff) {
+        for (int i=MENU_MAX_LINES-1; i>=0; i--) {
+          char *line = reusableBuffer.modelsel.menu_bss[i];
+          if (line[0] == '\0' || strcasecmp(fn, line) > 0) {
+            if (i > 0) memmove(reusableBuffer.modelsel.menu_bss[0], reusableBuffer.modelsel.menu_bss[1], sizeof(reusableBuffer.modelsel.menu_bss[i]) * i);
+            memset(line, 0, MENU_LINE_LENGTH);
+            strcpy(line, fn);
+            break;
+          }
+        }
+        for (uint8_t i=0; i<min(s_menu_count, (uint16_t)MENU_MAX_LINES); i++)
+          s_menu[i] = reusableBuffer.modelsel.menu_bss[i];
+      }
+      else if (s_menu_offset > s_last_menu_offset) {
+        if (strcasecmp(fn, reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-2]) > 0 && strcasecmp(fn, reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1]) < 0) {
+          memset(reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1], 0, MENU_LINE_LENGTH);
+          strcpy(reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1], fn);
+        }
+      }
+      else {
+        if (strcasecmp(fn, reusableBuffer.modelsel.menu_bss[1]) < 0 && strcasecmp(fn, reusableBuffer.modelsel.menu_bss[0]) > 0) {
+          memset(reusableBuffer.modelsel.menu_bss[0], 0, MENU_LINE_LENGTH);
+          strcpy(reusableBuffer.modelsel.menu_bss[0], fn);
+        }
+      }
+    }
+  }
+
+  if (s_menu_offset > 0)
+    s_last_menu_offset = s_menu_offset;
+  else
+    s_menu_offset = s_last_menu_offset;
+
+  return s_menu_count;
+}
+#endif
+
+#if defined(PCBTARANIS)
+  static int8_t modelselBitmapIdx;
+  static uint8_t modelselBitmap[MODEL_BITMAP_SIZE];
+  #define MODELSEL_W 133
+  #define BMP_DIRTY()  modelselBitmapIdx = -1
+#else
+  #define MODELSEL_W LCD_W
+  #define BMP_DIRTY()
+#endif
+
+#if defined(NAVIGATION_MENUS)
+void onModelSelectMenu(const char *result)
+{
+  int8_t sub = m_posVert;
+
+  if (result == STR_SELECT_MODEL || result == STR_CREATE_MODEL) {
+    selectModel(sub);
+  }
+  else if (result == STR_COPY_MODEL) {
+    s_copyMode = COPY_MODE;
+    s_copyTgtOfs = 0;
+    s_copySrcRow = -1;
+  }
+  else if (result == STR_MOVE_MODEL) {
+    s_copyMode = MOVE_MODE;
+    s_copyTgtOfs = 0;
+    s_copySrcRow = -1;
+  }
+#if defined(SDCARD)
+  else if (result == STR_BACKUP_MODEL) {
+    eeCheck(true); // force writing of current model data before this is changed
+    POPUP_WARNING(eeBackupModel(sub));
+  }
+  else if (result == STR_RESTORE_MODEL || result == STR_UPDATE_LIST) {
+    if (!listSdFiles(MODELS_PATH, MODELS_EXT, MENU_LINE_LENGTH-1, NULL)) {
+      POPUP_WARNING(STR_NO_MODELS_ON_SD);
+      s_menu_flags = 0;
+    }
+  }
+#endif
+  else if (result == STR_DELETE_MODEL) {
+    POPUP_CONFIRMATION(STR_DELETEMODEL);
+#if defined(CPUARM)
+    SET_WARNING_INFO(modelHeaders[sub].name, sizeof(g_model.header.name), ZCHAR);
+#else
+    char * name = reusableBuffer.modelsel.mainname;
+    eeLoadModelName(sub, name);
+    SET_WARNING_INFO(name, sizeof(g_model.header.name), ZCHAR);
+#endif
+  }
+#if defined(SDCARD)
+  else {
+    // The user choosed a file on SD to restore
+    POPUP_WARNING(eeRestoreModel(sub, (char *)result));
+    BMP_DIRTY();
+    if (!s_warning && g_eeGeneral.currModel == sub)
+      eeLoadModel(sub);
+  }
+#endif
+}
+#endif
+
+void menuModelSelect(uint8_t event)
+{
+  if (s_warning_result) {
+    s_warning_result = 0;
+    eeDeleteModel(m_posVert); // delete file
+    s_copyMode = 0;
+    event = EVT_ENTRY_UP;
+    BMP_DIRTY();
+  }
+
+  uint8_t _event_ = (IS_ROTARY_BREAK(event) || IS_ROTARY_LONG(event) ? 0 : event);
+
+#if defined(PCBTARANIS)
+  if ((s_copyMode && EVT_KEY_MASK(event) == KEY_EXIT) || event == EVT_KEY_BREAK(KEY_EXIT))
+    _event_ -= KEY_EXIT;
+#else
+  if (s_copyMode && EVT_KEY_MASK(event) == KEY_EXIT)
+    _event_ -= KEY_EXIT;
+#endif
+
+  int8_t oldSub = m_posVert;
+
+  check_submenu_simple(_event_, MAX_MODELS-1);
+
+#if defined(NAVIGATION_POT2)
+  if (event==0 && p2valdiff<0) {
+    event = EVT_KEY_FIRST(KEY_RIGHT);
+  }
+#endif
+
+  if (s_editMode > 0) s_editMode = 0;
+
+#if !defined(CPUARM)
+  if (event) {
+    eeFlush(); // flush eeprom write
+  }
+#endif
+
+  int8_t sub = m_posVert;
+
+  switch (event)
+  {
+      case EVT_ENTRY:
+        m_posVert = sub = g_eeGeneral.currModel;
+        if (sub >= LCD_LINES-1) s_pgOfs = sub-LCD_LINES+2;
+        s_copyMode = 0;
+        s_editMode = EDIT_MODE_INIT;
+        BMP_DIRTY();
+        eeCheck(true);
+        break;
+      case EVT_KEY_LONG(KEY_EXIT):
+        if (s_copyMode && s_copyTgtOfs == 0 && g_eeGeneral.currModel != sub && eeModelExists(sub)) {
+          POPUP_CONFIRMATION(STR_DELETEMODEL);
+#if defined(CPUARM)
+          SET_WARNING_INFO(modelHeaders[sub].name, sizeof(g_model.header.name), ZCHAR);
+#else
+          char * name = reusableBuffer.modelsel.mainname;
+          eeLoadModelName(sub, name);
+          SET_WARNING_INFO(name, sizeof(g_model.header.name), ZCHAR);
+#endif
+          killEvents(event);
+          break;
+        }
+        // no break
+#if defined(ROTARY_ENCODER_NAVIGATION)
+      case EVT_ROTARY_LONG:
+        killEvents(event);
+        if (s_editMode < 0) {
+          popMenu();
+          break;
+        }
+        else if (!s_copyMode) {
+          m_posVert = sub = g_eeGeneral.currModel;
+          s_copyMode = 0;
+          s_editMode = EDIT_MODE_INIT;
+        }
+        // no break
+#endif
+      case EVT_KEY_BREAK(KEY_EXIT):
+        if (s_copyMode) {
+          sub = m_posVert = (s_copyMode == MOVE_MODE || s_copySrcRow<0) ? (MAX_MODELS+sub+s_copyTgtOfs) % MAX_MODELS : s_copySrcRow;
+          s_copyMode = 0;
+        }
+#if defined(PCBTARANIS)
+        else {
+          if (m_posVert != g_eeGeneral.currModel) {
+            m_posVert = g_eeGeneral.currModel;
+            s_pgOfs = 0;
+          }
+          else if (event != EVT_KEY_LONG(KEY_EXIT)) {
+            popMenu();
+          }
+        }
+#endif
+        break;
+#if defined(ROTARY_ENCODER_NAVIGATION)
+      case EVT_ROTARY_BREAK:
+        if (s_editMode == -1) {
+          s_editMode = 0;
+          break;
+        }
+        // no break;
+#endif
+      case EVT_KEY_LONG(KEY_ENTER):
+      case EVT_KEY_BREAK(KEY_ENTER):
+        s_editMode = 0;
+        if (READ_ONLY()) {
+          if (g_eeGeneral.currModel != sub && eeModelExists(sub)) {
+            selectModel(sub);
+          }
+        }
+        else if (s_copyMode && (s_copyTgtOfs || s_copySrcRow>=0)) {
+          displayPopup(s_copyMode==COPY_MODE ? STR_COPYINGMODEL : STR_MOVINGMODEL);
+          eeCheck(true); // force writing of current model data before this is changed
+
+          uint8_t cur = (MAX_MODELS + sub + s_copyTgtOfs) % MAX_MODELS;
+
+          if (s_copyMode == COPY_MODE) {
+            if (eeCopyModel(cur, s_copySrcRow))
+              BMP_DIRTY();
+            else
+              cur = sub;
+          }
+
+          s_copySrcRow = g_eeGeneral.currModel; // to update the currModel value
+          while (sub != cur) {
+            uint8_t src = cur;
+            cur = (s_copyTgtOfs > 0 ? cur+MAX_MODELS-1 : cur+1) % MAX_MODELS;
+            eeSwapModels(src, cur);
+            BMP_DIRTY();
+            if (src == s_copySrcRow)
+              s_copySrcRow = cur;
+            else if (cur == s_copySrcRow)
+              s_copySrcRow = src;
+          }
+
+          if (s_copySrcRow != g_eeGeneral.currModel) {
+            g_eeGeneral.currModel = s_copySrcRow;
+            eeDirty(EE_GENERAL);
+          }
+
+          s_copyMode = 0;
+          event = EVT_ENTRY_UP;
+        }
+        else if (event == EVT_KEY_LONG(KEY_ENTER)
+#if !defined(PCBTARANIS)
+            || IS_ROTARY_BREAK(event)
+#endif
+            ) {
+          s_copyMode = 0;
+          killEvents(event);
+#if defined(NAVIGATION_MENUS)
+          if (g_eeGeneral.currModel != sub) {
+            if (eeModelExists(sub)) {
+              MENU_ADD_ITEM(STR_SELECT_MODEL);
+              MENU_ADD_SD_ITEM(STR_BACKUP_MODEL);
+              MENU_ADD_ITEM(STR_COPY_MODEL);
+              MENU_ADD_ITEM(STR_MOVE_MODEL);
+              MENU_ADD_ITEM(STR_DELETE_MODEL);
+            }
+            else {
+#if defined(SDCARD)
+              MENU_ADD_ITEM(STR_CREATE_MODEL);
+              MENU_ADD_ITEM(STR_RESTORE_MODEL);
+#else
+              selectModel(sub);
+#endif
+            }
+          }
+          else {
+            MENU_ADD_SD_ITEM(STR_BACKUP_MODEL);
+            MENU_ADD_ITEM(STR_COPY_MODEL);
+            MENU_ADD_ITEM(STR_MOVE_MODEL);
+          }
+          menuHandler = onModelSelectMenu;
+#else
+          if (g_eeGeneral.currModel != sub) {
+            selectModel(sub);
+          }
+#endif
+        }
+        else if (eeModelExists(sub)) {
+          s_copyMode = (s_copyMode == COPY_MODE ? MOVE_MODE : COPY_MODE);
+          s_copyTgtOfs = 0;
+          s_copySrcRow = -1;
+        }
+        break;
+
+#if defined(PCBTARANIS)
+      case EVT_KEY_BREAK(KEY_PAGE):
+      case EVT_KEY_LONG(KEY_PAGE):
+        chainMenu(event == EVT_KEY_BREAK(KEY_PAGE) ? menuModelSetup : menuTabModel[DIM(menuTabModel)-1]);
+        killEvents(event);
+        break;
+#else
+#if defined(ROTARY_ENCODER_NAVIGATION)
+      case EVT_ROTARY_LEFT:
+      case EVT_ROTARY_RIGHT:
+#endif
+      case EVT_KEY_FIRST(KEY_LEFT):
+      case EVT_KEY_FIRST(KEY_RIGHT):
+#if defined(ROTARY_ENCODER_NAVIGATION)
+        if ((!IS_ROTARY_RIGHT(event) && !IS_ROTARY_LEFT(event)) || s_editMode < 0) {
+#endif
+        if (sub == g_eeGeneral.currModel) {
+          chainMenu((IS_ROTARY_RIGHT(event) || event == EVT_KEY_FIRST(KEY_RIGHT)) ? menuModelSetup : menuTabModel[DIM(menuTabModel)-1]);
+        }
+        else {
+          AUDIO_WARNING2();
+        }
+        break;
+#if defined(ROTARY_ENCODER_NAVIGATION)
+        }
+        // no break
+#endif
+#endif
+
+      case EVT_KEY_FIRST(KEY_MOVE_UP):
+      case EVT_KEY_REPT(KEY_MOVE_UP):
+      case EVT_KEY_FIRST(KEY_MOVE_DOWN):
+      case EVT_KEY_REPT(KEY_MOVE_DOWN):
+        if (s_copyMode) {
+          int8_t next_ofs = s_copyTgtOfs + oldSub - m_posVert;
+          if (next_ofs == MAX_MODELS || next_ofs == -MAX_MODELS)
+            next_ofs = 0;
+
+          if (s_copySrcRow < 0 && s_copyMode==COPY_MODE) {
+            s_copySrcRow = oldSub;
+            // find a hole (in the first empty slot above / below)
+            sub = eeFindEmptyModel(s_copySrcRow, IS_ROTARY_DOWN(event) || event==EVT_KEY_FIRST(KEY_MOVE_DOWN));
+            if (sub < 0) {
+              // no free room for duplicating the model
+              AUDIO_ERROR();
+              sub = oldSub;
+              s_copyMode = 0;
+            }
+            next_ofs = 0;
+            m_posVert = sub;
+          }
+          s_copyTgtOfs = next_ofs;
+        }
+        break;
+  }
+
+#if defined(PCBHORUS)
+#elif defined(PCBTARANIS)
+  lcd_puts(27*FW-(LEN_FREE-4)*FW, 0, STR_FREE);
+  if (event) reusableBuffer.modelsel.eepromfree = EeFsGetFree();
+  lcd_outdezAtt(20*FW, 0, reusableBuffer.modelsel.eepromfree, 0);
+  lcd_puts(21*FW, 0, STR_BYTES);
+#elif !defined(PCBSKY9X)
+  lcd_puts(9*FW-(LEN_FREE-4)*FW, 0, STR_FREE);
+  if (event) reusableBuffer.modelsel.eepromfree = EeFsGetFree();
+  lcd_outdezAtt(17*FW, 0, reusableBuffer.modelsel.eepromfree, 0);
+#endif
+
+#if defined(PCBHORUS)
+  // nothing
+#elif defined(PCBTARANIS)
+  displayScreenIndex(e_ModelSelect, DIM(menuTabModel), 0);
+  lcd_filled_rect(0, 0, LCD_W, FH, SOLID, FILL_WHITE|GREY_DEFAULT);
+#elif defined(ROTARY_ENCODER_NAVIGATION)
+  displayScreenIndex(e_ModelSelect, DIM(menuTabModel), (sub == g_eeGeneral.currModel) ? ((IS_RE_NAVIGATION_ENABLE() && s_editMode < 0) ? INVERS|BLINK : INVERS) : 0);
+#else
+  displayScreenIndex(e_ModelSelect, DIM(menuTabModel), (sub == g_eeGeneral.currModel) ? INVERS : 0);
+#endif
+
+  TITLE(STR_MENUMODELSEL);
+
+  for (uint8_t i=0; i<LCD_LINES-1; i++) {
+    coord_t y = MENU_TITLE_HEIGHT + 1 + i*FH;
+    uint8_t k = i+s_pgOfs;
+    lcd_outdezNAtt(3*FW+2, y, k+1, LEADING0+((!s_copyMode && sub==k) ? INVERS : 0), 2);
+
+    if (s_copyMode == MOVE_MODE || (s_copyMode == COPY_MODE && s_copySrcRow >= 0)) {
+      if (k == sub) {
+        if (s_copyMode == COPY_MODE) {
+          k = s_copySrcRow;
+          lcd_putc(MODELSEL_W-FW, y, '+');
+        }
+        else {
+          k = sub + s_copyTgtOfs;
+        }
+      }
+      else if (s_copyTgtOfs < 0 && ((k < sub && k >= sub+s_copyTgtOfs) || (k-MAX_MODELS < sub && k-MAX_MODELS >= sub+s_copyTgtOfs)))
+        k += 1;
+      else if (s_copyTgtOfs > 0 && ((k > sub && k <= sub+s_copyTgtOfs) || (k+MAX_MODELS > sub && k+MAX_MODELS <= sub+s_copyTgtOfs)))
+        k += MAX_MODELS-1;
+    }
+
+    k %= MAX_MODELS;
+
+    if (eeModelExists(k)) {
+#if defined(PCBSKY9X)
+      putsModelName(4*FW, y, modelHeaders[k].name, k, 0);
+#elif defined(CPUARM)
+      putsModelName(4*FW, y, modelHeaders[k].name, k, 0);
+      lcd_outdezAtt(20*FW, y, eeModelSize(k), 0);
+#else
+      char * name = reusableBuffer.modelsel.listnames[i];
+      if (event) eeLoadModelName(k, name);
+      putsModelName(4*FW, y, name, k, 0);
+      lcd_outdezAtt(20*FW, y, eeModelSize(k), 0);
+#endif
+      if (k==g_eeGeneral.currModel && (s_copyMode!=COPY_MODE || s_copySrcRow<0 || i+s_pgOfs!=(vertpos_t)sub)) lcd_putc(1, y, '*');
+    }
+
+    if (s_copyMode && (vertpos_t)sub==i+s_pgOfs) {
+      lcd_filled_rect(9, y, MODELSEL_W-1-9, 7);
+      lcd_rect(8, y-1, MODELSEL_W-1-7, 9, s_copyMode == COPY_MODE ? SOLID : DOTTED);
+    }
+  }
+
+#if defined(PCBTARANIS)
+  if (modelselBitmapIdx != m_posVert) {
+    modelselBitmapIdx = m_posVert;
+    if (modelselBitmapIdx == g_eeGeneral.currModel)
+      memcpy(modelselBitmap, modelBitmap, MODEL_BITMAP_SIZE);
+    else
+      loadModelBitmap(modelHeaders[sub].bitmap, modelselBitmap);
+  }
+#if !defined(PCBHORUS)
+  lcd_bmp(22*FW+2, 2*FH+FH/2, modelselBitmap);
+#endif
+#endif
+}