radio/src/gui/480x272/menus.h

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #ifndef _MENUS_H_
  22 #define _MENUS_H_
  23
  24 #include "keys.h"
  25 #include "audio.h"
  26
  27 #define MENU_COLUMN2_X         280
  28 #define MIXES_2ND_COLUMN       140
  29 #define COLUMN_HEADER_X        150
  30
  31 extern uint8_t menuPageIndex;
  32 extern uint8_t menuPageCount;
  33 extern uint16_t linesCount;
  34 extern uint8_t linesDisplayed;
  35 extern int menuVerticalPosition;
  36 extern int menuHorizontalPosition;
  37 extern int menuVerticalOffset;
  38 extern uint8_t menuCalibrationState;
  39
  40 // Temporary no highlight
  41 extern uint8_t noHighlightCounter;
  42 #define NO_HIGHLIGHT()        (noHighlightCounter > 0)
  43 #define START_NO_HIGHLIGHT()  do { noHighlightCounter = 25; } while(0)
  44
  45 typedef bool (*MenuHandlerFunc)(event_t event);
  46
  47 extern MenuHandlerFunc menuHandlers[5];
  48 extern uint8_t menuVerticalPositions[4];
  49 extern uint8_t menuLevel;
  50 extern event_t menuEvent;
  51
  52 void chainMenu(MenuHandlerFunc newMenu);
  53 void pushMenu(MenuHandlerFunc newMenu);
  54 void popMenu();
  55 void abortPopMenu();
  56
  57 inline bool isRadioMenuDisplayed()
  58 {
  59   return menuVerticalPositions[0] == 1;
  60 }
  61
  62 inline bool isModelMenuDisplayed()
  63 {
  64   return menuVerticalPositions[0] == 0;
  65 }
  66
  67 enum MenuIcons {
  68   ICON_OPENTX,
  69   ICON_RADIO,
  70   ICON_RADIO_SETUP,
  71   ICON_RADIO_SD_MANAGER,
  72   ICON_RADIO_TOOLS,
  73   ICON_RADIO_GLOBAL_FUNCTIONS,
  74   ICON_RADIO_TRAINER,
  75   ICON_RADIO_HARDWARE,
  76   ICON_RADIO_CALIBRATION,
  77   ICON_RADIO_VERSION,
  78   ICON_MODEL,
  79   ICON_MODEL_SETUP,
  80   ICON_MODEL_HELI,
  81   ICON_MODEL_FLIGHT_MODES,
  82   ICON_MODEL_INPUTS,
  83   ICON_MODEL_MIXER,
  84   ICON_MODEL_OUTPUTS,
  85   ICON_MODEL_CURVES,
  86   ICON_MODEL_GVARS,
  87   ICON_MODEL_LOGICAL_SWITCHES,
  88   ICON_MODEL_SPECIAL_FUNCTIONS,
  89   ICON_MODEL_LUA_SCRIPTS,
  90   ICON_MODEL_TELEMETRY,
  91   ICON_THEME,
  92   ICON_THEME_SETUP,
  93   ICON_THEME_VIEW1,
  94   ICON_THEME_VIEW2,
  95   ICON_THEME_VIEW3,
  96   ICON_THEME_VIEW4,
  97   ICON_THEME_VIEW5,
  98   ICON_THEME_ADD_VIEW,
  99   ICON_STATS,
 100   ICON_STATS_THROTTLE_GRAPH,
 101   ICON_STATS_TIMERS,
 102   ICON_STATS_ANALOGS,
 103   ICON_STATS_DEBUG,
 104   ICON_MONITOR,
 105   ICON_MONITOR_CHANNELS1,
 106   ICON_MONITOR_CHANNELS2,
 107   ICON_MONITOR_CHANNELS3,
 108   ICON_MONITOR_CHANNELS4,
 109   ICON_MONITOR_LOGICAL_SWITCHES,
 110   ICON_RADIO_SPECTRUM_ANALYSER,
 111   MENUS_ICONS_COUNT
 112 };
 113
 114 enum EnumTabModel {
 115   MENU_MODEL_SETUP,
 116   CASE_HELI(MENU_MODEL_HELI)
 117   CASE_FLIGHT_MODES(MENU_MODEL_FLIGHT_MODES)
 118   MENU_MODEL_INPUTS,
 119   MENU_MODEL_MIXES,
 120   MENU_MODEL_OUTPUTS,
 121   MENU_MODEL_CURVES,
 122   CASE_GVARS(MENU_MODEL_GVARS)
 123   MENU_MODEL_LOGICAL_SWITCHES,
 124   MENU_MODEL_SPECIAL_FUNCTIONS,
 125 #if defined(LUA_MODEL_SCRIPTS)
 126   MENU_MODEL_CUSTOM_SCRIPTS,
 127 #endif
 128   MENU_MODEL_TELEMETRY,
 129   MENU_MODEL_PAGES_COUNT
 130 };
 131
 132 const uint8_t MODEL_ICONS[MENU_MODEL_PAGES_COUNT + 1] = {
 133   ICON_MODEL,
 134   ICON_MODEL_SETUP,
 135   CASE_HELI(ICON_MODEL_HELI)
 136   CASE_FLIGHT_MODES(ICON_MODEL_FLIGHT_MODES)
 137   ICON_MODEL_INPUTS,
 138   ICON_MODEL_MIXER,
 139   ICON_MODEL_OUTPUTS,
 140   ICON_MODEL_CURVES,
 141   CASE_GVARS(ICON_MODEL_GVARS)
 142   ICON_MODEL_LOGICAL_SWITCHES,
 143   ICON_MODEL_SPECIAL_FUNCTIONS,
 144 #if defined(LUA_MODEL_SCRIPTS)
 145   ICON_MODEL_LUA_SCRIPTS,
 146 #endif
 147   ICON_MODEL_TELEMETRY
 148 };
 149
 150 const uint8_t STATS_ICONS[] = {
 151   ICON_STATS,
 152   ICON_STATS_THROTTLE_GRAPH,
 153   ICON_STATS_DEBUG,
 154   ICON_STATS_ANALOGS,
 155 #if defined(DEBUG_TRACE_BUFFER)
 156   ICON_STATS_TIMERS
 157 #endif
 158 };
 159
 160 const uint8_t MONITOR_ICONS[] = {
 161   ICON_MONITOR,
 162   ICON_MONITOR_CHANNELS1,
 163   ICON_MONITOR_CHANNELS2,
 164   ICON_MONITOR_CHANNELS3,
 165   ICON_MONITOR_CHANNELS4,
 166   ICON_MONITOR_LOGICAL_SWITCHES
 167 };
 168
 169 bool menuModelSetup(event_t event);
 170 bool menuModelFailsafe(event_t event);
 171 bool menuModelHeli(event_t event);
 172 bool menuModelFlightModesAll(event_t event);
 173 bool menuModelExposAll(event_t event);
 174 bool menuModelMixAll(event_t event);
 175 bool menuModelLimits(event_t event);
 176 bool menuModelCurvesAll(event_t event);
 177 bool menuModelCurveOne(event_t event);
 178 bool menuModelGVars(event_t event);
 179 bool menuModelLogicalSwitches(event_t event);
 180 bool menuModelSpecialFunctions(event_t event);
 181 bool menuModelCustomScripts(event_t event);
 182 bool menuModelTelemetry(event_t event);
 183 bool menuModelSensor(event_t event);
 184 bool menuModelExpoOne(event_t event);
 185 bool menuModelModuleOptions(event_t event);
 186 bool menuModelReceiverOptions(event_t event);
 187 bool menuRadioDiagKeys(event_t event);
 188 bool menuRadioDiagAnalogs(event_t event);
 189
 190 extern const MenuHandlerFunc menuTabModel[MENU_MODEL_PAGES_COUNT];
 191
 192 enum EnumTabRadio {
 193   MENU_RADIO_SETUP,
 194   MENU_RADIO_SD_MANAGER,
 195 #if defined(LUA) || defined(PXX2)
 196   MENU_RADIO_TOOLS,
 197 #endif
 198   MENU_RADIO_SPECIAL_FUNCTIONS,
 199   MENU_RADIO_TRAINER,
 200   MENU_RADIO_HARDWARE,
 201   MENU_RADIO_VERSION,
 202   MENU_RADIO_PAGES_COUNT
 203 };
 204
 205 const uint8_t RADIO_ICONS[MENU_RADIO_PAGES_COUNT + 1] = {
 206   ICON_RADIO,
 207   ICON_RADIO_SETUP,
 208   ICON_RADIO_SD_MANAGER,
 209 #if defined(LUA) || defined(PXX2)
 210   ICON_RADIO_TOOLS,
 211 #endif
 212   ICON_RADIO_GLOBAL_FUNCTIONS,
 213   ICON_RADIO_TRAINER,
 214   ICON_RADIO_HARDWARE,
 215   ICON_RADIO_VERSION
 216 };
 217
 218 bool menuRadioSetup(event_t event);
 219 bool menuRadioSdManager(event_t event);
 220 bool menuRadioTools(event_t event);
 221 bool menuRadioSpecialFunctions(event_t event);
 222 bool menuRadioTrainer(event_t event);
 223 bool menuRadioVersion(event_t event);
 224 bool menuRadioHardware(event_t event);
 225 bool menuRadioCalibration(event_t event);
 226 bool menuRadioSpectrumAnalyser(event_t event);
 227 bool menuRadioPowerMeter(event_t event);
 228
 229 extern const MenuHandlerFunc menuTabGeneral[MENU_RADIO_PAGES_COUNT];
 230
 231 enum MenuRadioIndexes
 232 {
 233   e_StatsGraph,
 234   e_StatsDebug,
 235   e_StatsAnalogs,
 236 #if defined(DEBUG_TRACE_BUFFER)
 237   e_StatsTraces,
 238 #endif
 239 };
 240
 241 bool menuStatsGraph(event_t event);
 242 bool menuStatsDebug(event_t event);
 243 bool menuStatsAnalogs(event_t event);
 244 bool menuStatsTraces(event_t event);
 245
 246 static const MenuHandlerFunc menuTabStats[]  = {
 247   menuStatsGraph,
 248   menuStatsDebug,
 249   menuStatsAnalogs,
 250 #if defined(DEBUG_TRACE_BUFFER)
 251   menuStatsTraces,
 252 #endif
 253 };
 254
 255 enum EnumTabMonitors
 256 {
 257   e_MonChannelsFirst,
 258   e_MonChannels1 = e_MonChannelsFirst,
 259   e_MonChannels2,
 260   e_MonChannels3,
 261   e_MonChannels4,
 262   e_MonLogicalSwitches,
 263   e_MonTabChannelsPagesCount
 264 };
 265
 266 extern const MenuHandlerFunc menuTabMonitors[e_MonTabChannelsPagesCount];
 267 extern uint8_t lastMonitorPage;
 268 extern void drawSingleMixerBar(coord_t, coord_t, coord_t, coord_t, uint8_t);
 269 extern void drawSingleOutputBar(coord_t, coord_t, coord_t, coord_t, uint8_t);
 270
 271 extern const MenuHandlerFunc menuTabScreensSetup[1+MAX_CUSTOM_SCREENS] ;
 272
 273 bool menuFirstCalib(event_t event);
 274 bool menuMainView(event_t event);
 275 bool menuSpecialFunctions(event_t event, CustomFunctionData * functions, CustomFunctionsContext & functionsContext);
 276 bool menuModelSelect(event_t event);
 277 bool menuAboutView(event_t event);
 278 bool menuMainViewChannelsMonitor(event_t event);
 279 bool menuTextView(event_t event);
 280 bool menuScreensTheme(event_t event);
 281
 282 extern int8_t checkIncDec_Ret;  // global helper vars
 283
 284 #define EDIT_SELECT_FIELD  0
 285 #define EDIT_MODIFY_FIELD  1
 286 #define EDIT_MODIFY_STRING 2
 287 extern int8_t s_editMode;       // global editmode
 288
 289 // checkIncDec flags
 290 #define EE_GENERAL                     0x01
 291 #define EE_MODEL                       0x02
 292 #define NO_INCDEC_MARKS                0x04
 293 #define INCDEC_SWITCH                  0x08
 294 #define INCDEC_SOURCE                  0x10
 295 #define INCDEC_REP10                   0x40
 296 #define NO_DBLKEYS                     0x80
 297
 298 // mawrow special values
 299 #define ORPHAN_ROW                     ((uint8_t)-3)
 300 #define NAVIGATION_LINE_BY_LINE        0x40
 301 #define CURSOR_ON_LINE()               (menuHorizontalPosition<0)
 302
 303 struct CheckIncDecStops {
 304   const int count;
 305   const int stops[];
 306   int min() const
 307   {
 308     return stops[0];
 309   }
 310   int max() const
 311   {
 312     return stops[count-1];
 313   }
 314   bool contains(int value) const
 315   {
 316     for (int i=0; i<count; ++i) {
 317       int stop = stops[i];
 318       if (value == stop)
 319         return true;
 320       else if (value < stop)
 321         return false;
 322     }
 323     return false;
 324   }
 325 };
 326 extern const CheckIncDecStops &stops100;
 327 extern const CheckIncDecStops &stops1000;
 328 extern const CheckIncDecStops &stopsSwitch;
 329
 330 #define INIT_STOPS(var, ...)                                        \
 331   const int _ ## var[] = { __VA_ARGS__ };                           \
 332   const CheckIncDecStops &var  = (const CheckIncDecStops&)_ ## var;
 333 #define CATEGORY_END(val)                                          \
 334   (val), (val+1)
 335
 336 int checkIncDec(event_t event, int val, int i_min, int i_max, unsigned int i_flags=0, IsValueAvailable isValueAvailable=NULL, const CheckIncDecStops &stops=stops100);
 337
 338 #define checkIncDecModel(event, i_val, i_min, i_max) checkIncDec(event, i_val, i_min, i_max, EE_MODEL)
 339 #define checkIncDecModelZero(event, i_val, i_max) checkIncDec(event, i_val, 0, i_max, EE_MODEL)
 340 #define checkIncDecGen(event, i_val, i_min, i_max) checkIncDec(event, i_val, i_min, i_max, EE_GENERAL)
 341
 342 #define CHECK_INCDEC_MODELVAR(event, var, min, max) \
 343   var = checkIncDecModel(event, var, min, max)
 344
 345 #define CHECK_INCDEC_MODELVAR_ZERO(event, var, max) \
 346   var = checkIncDecModelZero(event, var, max)
 347
 348 #define CHECK_INCDEC_MODELVAR_CHECK(event, var, min, max, check) \
 349   var = checkIncDec(event, var, min, max, EE_MODEL, check)
 350
 351 #define CHECK_INCDEC_MODELVAR_ZERO_CHECK(event, var, max, check) \
 352   var = checkIncDec(event, var, 0, max, EE_MODEL, check)
 353
 354 #define AUTOSWITCH_ENTER_LONG() (attr && event==EVT_KEY_LONG(KEY_ENTER))
 355 #define CHECK_INCDEC_SWITCH(event, var, min, max, flags, available) \
 356   var = checkIncDec(event, var, min, max, (flags)|INCDEC_SWITCH, available)
 357 #define CHECK_INCDEC_MODELSWITCH(event, var, min, max, available) \
 358   CHECK_INCDEC_SWITCH(event, var, min, max, EE_MODEL, available)
 359
 360 #define CHECK_INCDEC_MODELSOURCE(event, var, min, max) \
 361   var = checkIncDec(event, var, min, max, EE_MODEL|INCDEC_SOURCE|NO_INCDEC_MARKS, isSourceAvailable)
 362
 363 #define CHECK_INCDEC_GENVAR(event, var, min, max) \
 364   var = checkIncDecGen(event, var, min, max)
 365
 366 #define INCDEC_DECLARE_VARS(f)         uint8_t incdecFlag = (f); IsValueAvailable isValueAvailable = NULL
 367 #define INCDEC_SET_FLAG(f)             incdecFlag = (f)
 368 #define INCDEC_ENABLE_CHECK(fn)        isValueAvailable = fn
 369 #define CHECK_INCDEC_PARAM(event, var, min, max) \
 370                                        checkIncDec(event, var, min, max, incdecFlag, isValueAvailable)
 371
 372 int8_t navigate(event_t event, int count, int rows, int columns=1, bool loop=true);
 373 bool check(event_t event, uint8_t curr, const MenuHandlerFunc * menuTab, uint8_t menuTabSize, const uint8_t * horTab, uint8_t horTabMax, int maxrow, uint8_t flags=0);
 374 bool check_simple(event_t event, uint8_t curr, const MenuHandlerFunc * menuTab, uint8_t menuTabSize, int maxrow);
 375 bool check_submenu_simple(event_t event, uint8_t maxrow);
 376
 377 #define MENU_TAB(...) const uint8_t mstate_tab[] = __VA_ARGS__
 378
 379 #define MENU_WITH_OPTIONS(title, icons, tab, tabCount, menu, lines_count, ...) \
 380   MENU_TAB(__VA_ARGS__); \
 381   if (event == EVT_ENTRY || event == EVT_ENTRY_UP) TRACE("Menu %s displayed ...", title); \
 382   if (!check(event, menu, tab, tabCount, mstate_tab, DIM(mstate_tab)-1, lines_count)) return false; \
 383   drawMenuTemplate(title, 0, icons, OPTION_MENU_TITLE_BAR);
 384
 385 #define CUSTOM_MENU_WITH_OPTIONS(title, icons, tab, tabCount, menu, lines_count) \
 386     if (event == EVT_ENTRY || event == EVT_ENTRY_UP) TRACE("Menu %s displayed ...", title); \
 387     if (!check(event, menu, tab, tabCount, mstate_tab, DIM(mstate_tab)-1, lines_count)) return false; \
 388     drawMenuTemplate(title, 0, icons, OPTION_MENU_TITLE_BAR);
 389
 390 #define MENU(title, icons, tab, menu, lines_count, ...) \
 391   MENU_WITH_OPTIONS(title, icons, tab, DIM(tab), menu, lines_count, __VA_ARGS__)
 392
 393 #define SIMPLE_MENU_WITH_OPTIONS(title, icons, tab, tabCount, menu, lines_count) \
 394   if (event == EVT_ENTRY || event == EVT_ENTRY_UP) TRACE("Menu %s displayed ...", title); \
 395   if (!check_simple(event, menu, tab, tabCount, lines_count)) return false; \
 396   drawMenuTemplate(title, 0, icons, OPTION_MENU_TITLE_BAR);
 397
 398 #define SIMPLE_MENU(title, icons, tab, menu, lines_count) \
 399   SIMPLE_MENU_WITH_OPTIONS(title, icons, tab, DIM(tab), menu, lines_count)
 400
 401 #define SUBMENU(title, icon, lines_count, ...) \
 402   MENU_TAB(__VA_ARGS__); \
 403   if (!check(event, 0, NULL, 0, mstate_tab, DIM(mstate_tab)-1, lines_count)) return false; \
 404   drawMenuTemplate(title, icon);
 405
 406 #define SUBMENU_WITH_OPTIONS(title, icon, lines_count, options, ...) \
 407   MENU_TAB(__VA_ARGS__); \
 408   if (!check(event, 0, NULL, 0, mstate_tab, DIM(mstate_tab)-1, lines_count)) return false; \
 409   drawMenuTemplate(title, icon, NULL, options);
 410
 411 #define CUSTOM_SUBMENU_WITH_OPTIONS(title, icon, lines_count, options) \
 412   if (!check(event, 0, NULL, 0, mstate_tab, DIM(mstate_tab)-1, lines_count)) return false; \
 413   drawMenuTemplate(title, icon, NULL, options);
 414
 415 #define SIMPLE_SUBMENU(title, icon, lines_count) \
 416   if (!check_submenu_simple(event, lines_count)) return false; \
 417   drawMenuTemplate(title, icon, NULL)
 418
 419 #define SIMPLE_SUBMENU_WITH_OPTIONS(title, icon, lines_count, options) \
 420   if (!check_submenu_simple(event, lines_count)) return false; \
 421   drawMenuTemplate(title, icon, NULL, options)
 422
 423 #if defined(GVARS)
 424   #define GVAR_MENU_ITEM(x, y, v, min, max, lcdattr, editflags, event) editGVarFieldValue(x, y, v, min, max, lcdattr, editflags, event)
 425 #else
 426   #define GVAR_MENU_ITEM(x, y, v, min, max, lcdattr, editflags, event) editGVarFieldValue(x, y, v, min, max, lcdattr, event)
 427 #endif
 428
 429 #if defined(GVARS)
 430   int16_t editGVarFieldValue(coord_t x, coord_t y, int16_t value, int16_t min, int16_t max, LcdFlags attr, uint8_t editflags, event_t event);
 431   #define displayGVar(x, y, v, min, max) GVAR_MENU_ITEM(x, y, v, min, max, 0, 0, 0)
 432 #else
 433   int16_t editGVarFieldValue(coord_t x, coord_t y, int16_t value, int16_t min, int16_t max, LcdFlags attr, event_t event);
 434   #define displayGVar(x, y, v, min, max) lcdDrawNumber(x, y, v)
 435 #endif
 436
 437 extern uint8_t editNameCursorPos;
 438 void editName(coord_t x, coord_t y, char *name, uint8_t size, event_t event, uint8_t active, LcdFlags flags=ZCHAR);
 439
 440 uint8_t editDelay(coord_t x, coord_t y, event_t event, uint8_t attr, uint8_t delay);
 441 void editCurveRef(coord_t x, coord_t y, CurveRef & curve, event_t event, LcdFlags flags);
 442
 443 extern uint8_t s_curveChan;
 444
 445 enum
 446 {
 447   WARNING_TYPE_WAIT,
 448   WARNING_TYPE_INFO,
 449   WARNING_TYPE_ASTERISK,
 450   WARNING_TYPE_CONFIRM,
 451   WARNING_TYPE_INPUT,
 452   WARNING_TYPE_ALERT
 453 };
 454
 455 extern const char * warningText;
 456 extern const char * warningInfoText;
 457 extern uint8_t         warningInfoLength;
 458 extern uint8_t         warningResult;
 459 extern uint8_t         warningType;
 460
 461 #define COPY_MODE 1
 462 #define MOVE_MODE 2
 463 extern uint8_t s_copyMode;
 464 extern int8_t s_copySrcRow;
 465 extern int8_t s_copyTgtOfs;
 466 extern uint8_t s_currIdx;
 467 extern int8_t s_currCh;
 468 extern uint8_t s_copySrcIdx;
 469 extern uint8_t s_copySrcCh;
 470
 471 uint8_t getExposCount();
 472 void deleteExpo(uint8_t idx);
 473 void insertExpo(uint8_t idx);
 474
 475 uint8_t getMixesCount();
 476 void deleteMix(uint8_t idx);
 477 void insertMix(uint8_t idx);
 478
 479 #define MENU_X                 80
 480 #define MENU_W                 LCD_W-(2*MENU_X)
 481 #define POPUP_X                120
 482 #define POPUP_Y                70
 483 #define POPUP_W                300
 484 #define POPUP_H                130
 485 #define WARNING_LINE_LEN       32
 486 #define WARNING_LINE_X         (POPUP_X+66)
 487 #define WARNING_LINE_Y         (POPUP_Y+9)
 488 #define WARNING_INFOLINE_Y     (WARNING_LINE_Y+68)
 489
 490 void copySelection(char * dst, const char * src, uint8_t size);
 491 void drawPopupBackgroundAndBorder(coord_t x, coord_t y, coord_t w, coord_t h);
 492 void showMessageBox(const char * title);
 493 void runPopupWarning(event_t event);
 494
 495 typedef void (* PopupFunc)(event_t event);
 496 extern PopupFunc popupFunc;
 497
 498 extern uint8_t warningInfoFlags;
 499
 500 inline void DISPLAY_WARNING(event_t event)
 501 {
 502   (*popupFunc)(event);
 503 }
 504
 505 #define POPUP_MENU_MAX_LINES           12
 506 #define MENU_MAX_DISPLAY_LINES         9
 507 #define MENU_LINE_LENGTH               (LEN_MODEL_NAME+12)
 508
 509 extern const char * popupMenuItems[POPUP_MENU_MAX_LINES];
 510 extern uint16_t popupMenuItemsCount;
 511 extern uint16_t popupMenuOffset;
 512 enum {
 513   MENU_OFFSET_INTERNAL,
 514   MENU_OFFSET_EXTERNAL
 515 };
 516 extern uint8_t popupMenuOffsetType;
 517 extern uint8_t popupMenuSelectedItem;
 518 const char * runPopupMenu(event_t event);
 519
 520 typedef void (* PopupMenuHandler)(const char * result);
 521 extern PopupMenuHandler popupMenuHandler;
 522
 523 inline void POPUP_INPUT(const char * s, PopupFunc func)
 524 {
 525   warningText = s;
 526   warningInfoText = nullptr;
 527   warningType = WARNING_TYPE_INPUT;
 528   popupFunc = func;
 529 }
 530
 531 inline void SET_WARNING_INFO(const char * info, uint8_t length, uint8_t flags)
 532 {
 533   warningInfoText = info;
 534   warningInfoLength = length;
 535   warningInfoFlags = flags;
 536 }
 537
 538 inline void POPUP_MENU_ADD_ITEM(const char * s)
 539 {
 540   popupMenuOffsetType = MENU_OFFSET_INTERNAL;
 541   if (popupMenuItemsCount < POPUP_MENU_MAX_LINES)
 542     popupMenuItems[popupMenuItemsCount++] = s;
 543 }
 544
 545 inline void POPUP_MENU_SELECT_ITEM(uint8_t index)
 546 {
 547   popupMenuSelectedItem =  (index > 0 ? (index < popupMenuItemsCount ? index : popupMenuItemsCount - 1) : 0);
 548 }
 549
 550 inline void POPUP_MENU_START(PopupMenuHandler handler)
 551 {
 552   if (handler != popupMenuHandler) {
 553     killAllEvents();
 554     AUDIO_KEY_PRESS();
 555     popupMenuHandler = handler;
 556   }
 557 }
 558
 559 inline void CLEAR_POPUP()
 560 {
 561   warningText = nullptr;
 562   warningInfoText = nullptr;
 563   popupMenuHandler = nullptr;
 564   popupMenuItemsCount = 0;
 565 }
 566
 567 inline void POPUP_WAIT(const char * s)
 568 {
 569   warningText = s;
 570   warningInfoText = nullptr;
 571   warningType = WARNING_TYPE_WAIT;
 572   popupFunc = runPopupWarning;
 573 }
 574
 575 inline void POPUP_INFORMATION(const char * s)
 576 {
 577   warningText = s;
 578   warningInfoText = nullptr;
 579   warningType = WARNING_TYPE_INFO;
 580   popupFunc = runPopupWarning;
 581 }
 582
 583 inline void POPUP_WARNING(const char * s)
 584 {
 585   warningText = s;
 586   warningInfoText = nullptr;
 587   warningType = WARNING_TYPE_ASTERISK;
 588   popupFunc = runPopupWarning;
 589 }
 590
 591 typedef void (* PopupMenuHandler)(const char * result);
 592 extern PopupMenuHandler popupMenuHandler;
 593
 594 inline void POPUP_CONFIRMATION(const char *s, PopupMenuHandler confirmHandler)
 595 {
 596   warningText = s;
 597   warningType = WARNING_TYPE_CONFIRM;
 598   warningInfoText = nullptr;
 599   popupFunc = runPopupWarning;
 600   popupMenuHandler = confirmHandler;
 601 }
 602
 603 void pushMenuTextView(const char * filename);
 604 void pushModelNotes();
 605 void readModelNotes();
 606
 607 #define CURSOR_MOVED_LEFT(event)       (event==EVT_ROTARY_LEFT || EVT_KEY_MASK(event) == KEY_LEFT)
 608 #define CURSOR_MOVED_RIGHT(event)      (event==EVT_ROTARY_RIGHT || EVT_KEY_MASK(event) == KEY_RIGHT)
 609 #define REPEAT_LAST_CURSOR_MOVE(last, refresh) { if (CURSOR_MOVED_RIGHT(event)) menuHorizontalPosition = (menuHorizontalPosition >= (last) ? 0 : menuHorizontalPosition + 1); else menuHorizontalPosition = (menuHorizontalPosition <= (0) ? last : menuHorizontalPosition - 1); if (refresh) putEvent(EVT_REFRESH); }
 610 #define POS_HORZ_INIT(posVert)         ((COLATTR(posVert) & NAVIGATION_LINE_BY_LINE) ? -1 : 0)
 611 #define EDIT_MODE_INIT                 0 // TODO enum
 612
 613 typedef int (*FnFuncP) (int x);
 614 void drawFunction(FnFuncP fn, int x, int y, int width);
 615
 616 void onSourceLongEnterPress(const char *result);
 617
 618 uint8_t switchToMix(uint8_t source);
 619
 620 #endif // _MENUS_H_