menu.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467
  1. //menu.cpp
  2. #include "menu.h"
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <stdarg.h>
  6. #include <avr/pgmspace.h>
  7. #include "lcd.h"
  8. #include "Configuration.h"
  9. #include "Marlin.h"
  10. #include "ultralcd.h"
  11. #include "language.h"
  12. #include "static_assert.h"
  13. #include "sound.h"
  14. extern int32_t lcd_encoder;
  15. #define MENU_DEPTH_MAX 6
  16. static menu_record_t menu_stack[MENU_DEPTH_MAX];
  17. uint8_t menu_data[MENU_DATA_SIZE];
  18. #ifndef __AVR__
  19. #error "menu_data is non-portable to non 8bit processor"
  20. #endif
  21. uint8_t menu_depth = 0;
  22. uint8_t menu_block_entering_on_serious_errors = SERIOUS_ERR_NONE;
  23. uint8_t menu_line = 0;
  24. uint8_t menu_item = 0;
  25. uint8_t menu_row = 0;
  26. uint8_t menu_top = 0;
  27. uint8_t menu_clicked = 0;
  28. uint8_t menu_entering = 0;
  29. uint8_t menu_leaving = 0;
  30. menu_func_t menu_menu = 0;
  31. static_assert(sizeof(menu_data)>= sizeof(menu_data_edit_t),"menu_data_edit_t doesn't fit into menu_data");
  32. void menu_goto(menu_func_t menu, const uint32_t encoder, const bool feedback, bool reset_menu_state)
  33. {
  34. asm("cli");
  35. if (menu_menu != menu)
  36. {
  37. menu_menu = menu;
  38. lcd_encoder = encoder;
  39. asm("sei");
  40. if (reset_menu_state)
  41. {
  42. // Resets the global shared C union.
  43. // This ensures, that the menu entered will find out, that it shall initialize itself.
  44. memset(&menu_data, 0, sizeof(menu_data));
  45. }
  46. if (feedback) lcd_quick_feedback();
  47. }
  48. else
  49. asm("sei");
  50. }
  51. void menu_start(void)
  52. {
  53. if (lcd_encoder > 0x8000) lcd_encoder = 0;
  54. if (lcd_encoder < 0)
  55. {
  56. lcd_encoder = 0;
  57. Sound_MakeSound(e_SOUND_TYPE_BlindAlert);
  58. }
  59. if (lcd_encoder < menu_top)
  60. menu_top = lcd_encoder;
  61. menu_line = menu_top;
  62. menu_clicked = LCD_CLICKED;
  63. }
  64. void menu_end(void)
  65. {
  66. if (lcd_encoder >= menu_item)
  67. {
  68. lcd_encoder = menu_item - 1;
  69. Sound_MakeSound(e_SOUND_TYPE_BlindAlert);
  70. }
  71. if (((uint8_t)lcd_encoder) >= menu_top + LCD_HEIGHT)
  72. {
  73. menu_top = lcd_encoder - LCD_HEIGHT + 1;
  74. lcd_draw_update = 1;
  75. menu_line = menu_top - 1;
  76. menu_row = -1;
  77. }
  78. }
  79. void menu_back(uint8_t nLevel)
  80. {
  81. menu_depth = ((menu_depth > nLevel) ? (menu_depth - nLevel) : 0);
  82. menu_goto(menu_stack[menu_depth].menu, menu_stack[menu_depth].position, true, true);
  83. }
  84. void menu_back(void)
  85. {
  86. menu_back(1);
  87. }
  88. static void menu_back_no_reset(void)
  89. {
  90. if (menu_depth > 0)
  91. {
  92. menu_depth--;
  93. menu_goto(menu_stack[menu_depth].menu, menu_stack[menu_depth].position, true, false);
  94. }
  95. }
  96. void menu_back_if_clicked(void)
  97. {
  98. if (lcd_clicked())
  99. menu_back();
  100. }
  101. void menu_back_if_clicked_fb(void)
  102. {
  103. if (lcd_clicked())
  104. {
  105. lcd_quick_feedback();
  106. menu_back();
  107. }
  108. }
  109. void menu_submenu(menu_func_t submenu)
  110. {
  111. if (menu_depth < MENU_DEPTH_MAX)
  112. {
  113. menu_stack[menu_depth].menu = menu_menu;
  114. menu_stack[menu_depth++].position = lcd_encoder;
  115. menu_goto(submenu, 0, true, true);
  116. }
  117. }
  118. static void menu_submenu_no_reset(menu_func_t submenu)
  119. {
  120. if (menu_depth < MENU_DEPTH_MAX)
  121. {
  122. menu_stack[menu_depth].menu = menu_menu;
  123. menu_stack[menu_depth++].position = lcd_encoder;
  124. menu_goto(submenu, 0, true, false);
  125. }
  126. }
  127. uint8_t menu_item_ret(void)
  128. {
  129. lcd_beeper_quick_feedback();
  130. lcd_draw_update = 2;
  131. lcd_button_pressed = false;
  132. return 1;
  133. }
  134. /*
  135. int menu_draw_item_printf_P(char type_char, const char* format, ...)
  136. {
  137. va_list args;
  138. va_start(args, format);
  139. int ret = 0;
  140. lcd_set_cursor(0, menu_row);
  141. if (lcd_encoder == menu_item)
  142. lcd_print('>');
  143. else
  144. lcd_print(' ');
  145. int cnt = vfprintf_P(lcdout, format, args);
  146. for (int i = cnt; i < 18; i++)
  147. lcd_print(' ');
  148. lcd_print(type_char);
  149. va_end(args);
  150. return ret;
  151. }
  152. */
  153. static char menu_selection_mark(){
  154. return (lcd_encoder == menu_item)?'>':' ';
  155. }
  156. static void menu_draw_item_puts_P(char type_char, const char* str)
  157. {
  158. lcd_set_cursor(0, menu_row);
  159. lcd_printf_P(PSTR("%c%-18.18S%c"), menu_selection_mark(), str, type_char);
  160. }
  161. //! @brief Format sheet name
  162. //!
  163. //! @param[in] sheet_E Sheet in EEPROM
  164. //! @param[out] buffer for formatted output
  165. void menu_format_sheet_E(const Sheet &sheet_E, SheetFormatBuffer &buffer)
  166. {
  167. uint_least8_t index = sprintf_P(buffer.c, PSTR("%.10S "), _T(MSG_SHEET));
  168. eeprom_read_block(&(buffer.c[index]), sheet_E.name, 7);
  169. //index += 7;
  170. buffer.c[index + 7] = '\0';
  171. }
  172. static void menu_draw_item_puts_E(char type_char, const Sheet &sheet)
  173. {
  174. lcd_set_cursor(0, menu_row);
  175. SheetFormatBuffer buffer;
  176. menu_format_sheet_E(sheet, buffer);
  177. lcd_printf_P(PSTR("%c%-18.18s%c"), menu_selection_mark(), buffer.c, type_char);
  178. }
  179. static void menu_draw_item_puts_P(char type_char, const char* str, char num)
  180. {
  181. lcd_set_cursor(0, menu_row);
  182. lcd_printf_P(PSTR("%c%-.16S "), menu_selection_mark(), str);
  183. lcd_putc(num);
  184. lcd_set_cursor(19, menu_row);
  185. lcd_putc(type_char);
  186. }
  187. /*
  188. int menu_draw_item_puts_P_int16(char type_char, const char* str, int16_t val, )
  189. {
  190. lcd_set_cursor(0, menu_row);
  191. int cnt = lcd_printf_P(PSTR("%c%-18S%c"), (lcd_encoder == menu_item)?'>':' ', str, type_char);
  192. return cnt;
  193. }
  194. */
  195. void menu_item_dummy(void)
  196. {
  197. menu_item++;
  198. }
  199. uint8_t menu_item_text_P(const char* str)
  200. {
  201. if (menu_item == menu_line)
  202. {
  203. if (lcd_draw_update) menu_draw_item_puts_P(' ', str);
  204. if (menu_clicked && (lcd_encoder == menu_item))
  205. return menu_item_ret();
  206. }
  207. menu_item++;
  208. return 0;
  209. }
  210. uint8_t menu_item_submenu_P(const char* str, menu_func_t submenu)
  211. {
  212. if (menu_item == menu_line)
  213. {
  214. if (lcd_draw_update) menu_draw_item_puts_P(LCD_STR_ARROW_RIGHT[0], str);
  215. if (menu_clicked && (lcd_encoder == menu_item))
  216. {
  217. menu_submenu(submenu);
  218. return menu_item_ret();
  219. }
  220. }
  221. menu_item++;
  222. return 0;
  223. }
  224. uint8_t menu_item_submenu_E(const Sheet &sheet, menu_func_t submenu)
  225. {
  226. if (menu_item == menu_line)
  227. {
  228. if (lcd_draw_update) menu_draw_item_puts_E(LCD_STR_ARROW_RIGHT[0], sheet);
  229. if (menu_clicked && (lcd_encoder == menu_item))
  230. {
  231. menu_submenu(submenu);
  232. return menu_item_ret();
  233. }
  234. }
  235. menu_item++;
  236. return 0;
  237. }
  238. uint8_t menu_item_back_P(const char* str)
  239. {
  240. if (menu_item == menu_line)
  241. {
  242. if (lcd_draw_update) menu_draw_item_puts_P(LCD_STR_UPLEVEL[0], str);
  243. if (menu_clicked && (lcd_encoder == menu_item))
  244. {
  245. menu_back();
  246. return menu_item_ret();
  247. }
  248. }
  249. menu_item++;
  250. return 0;
  251. }
  252. uint8_t menu_item_function_P(const char* str, menu_func_t func)
  253. {
  254. if (menu_item == menu_line)
  255. {
  256. if (lcd_draw_update) menu_draw_item_puts_P(' ', str);
  257. if (menu_clicked && (lcd_encoder == menu_item))
  258. {
  259. menu_clicked = false;
  260. lcd_consume_click();
  261. lcd_update_enabled = 0;
  262. if (func) func();
  263. lcd_update_enabled = 1;
  264. return menu_item_ret();
  265. }
  266. }
  267. menu_item++;
  268. return 0;
  269. }
  270. //! @brief Menu item function taking single parameter
  271. //!
  272. //! Ideal for numbered lists calling functions with number parameter.
  273. //! @param str Item caption
  274. //! @param number aditional character to be added after str, e.g. number
  275. //! @param func pointer to function taking uint8_t with no return value
  276. //! @param fn_par value to be passed to function
  277. //! @retval 0
  278. //! @retval 1 Item was clicked
  279. uint8_t menu_item_function_P(const char* str, char number, void (*func)(uint8_t), uint8_t fn_par)
  280. {
  281. if (menu_item == menu_line)
  282. {
  283. if (lcd_draw_update) menu_draw_item_puts_P(' ', str, number);
  284. if (menu_clicked && (lcd_encoder == menu_item))
  285. {
  286. menu_clicked = false;
  287. lcd_consume_click();
  288. lcd_update_enabled = 0;
  289. if (func) func(fn_par);
  290. lcd_update_enabled = 1;
  291. return menu_item_ret();
  292. }
  293. }
  294. menu_item++;
  295. return 0;
  296. }
  297. uint8_t menu_item_gcode_P(const char* str, const char* str_gcode)
  298. {
  299. if (menu_item == menu_line)
  300. {
  301. if (lcd_draw_update) menu_draw_item_puts_P(' ', str);
  302. if (menu_clicked && (lcd_encoder == menu_item))
  303. {
  304. if (str_gcode) enquecommand_P(str_gcode);
  305. return menu_item_ret();
  306. }
  307. }
  308. menu_item++;
  309. return 0;
  310. }
  311. const char menu_20x_space[] PROGMEM = " ";
  312. const char menu_fmt_int3[] PROGMEM = "%c%.15S:%s%3d";
  313. const char menu_fmt_float31[] PROGMEM = "%-12.12S%+8.1f";
  314. const char menu_fmt_float13[] PROGMEM = "%c%-13.13S%+5.3f";
  315. const char menu_fmt_float13off[] PROGMEM = "%c%-13.13S%6.6s";
  316. template<typename T>
  317. static void menu_draw_P(char chr, const char* str, int16_t val);
  318. template<>
  319. void menu_draw_P<int16_t*>(char chr, const char* str, int16_t val)
  320. {
  321. int text_len = strlen_P(str);
  322. if (text_len > 15) text_len = 15;
  323. char spaces[21];
  324. strcpy_P(spaces, menu_20x_space);
  325. if (val <= -100) spaces[15 - text_len - 1] = 0;
  326. else spaces[15 - text_len] = 0;
  327. lcd_printf_P(menu_fmt_int3, chr, str, spaces, val);
  328. }
  329. template<>
  330. void menu_draw_P<uint8_t*>(char chr, const char* str, int16_t val)
  331. {
  332. menu_data_edit_t* _md = (menu_data_edit_t*)&(menu_data[0]);
  333. float factor = 1.0f + static_cast<float>(val) / 1000.0f;
  334. if (val <= _md->minEditValue)
  335. {
  336. lcd_printf_P(menu_fmt_float13off, chr, str, " [off]");
  337. }
  338. else
  339. {
  340. lcd_printf_P(menu_fmt_float13, chr, str, factor);
  341. }
  342. }
  343. //! @brief Draw up to 10 chars of text and a float number in format from +0.0 to +12345.0. The increased range is necessary
  344. //! for displaying large values of extruder positions, which caused text overflow in the previous implementation.
  345. //!
  346. //! @param str string label to print
  347. //! @param val value to print aligned to the right side of the display
  348. //!
  349. //! Implementation comments:
  350. //! The text needs to come with a colon ":", this function does not append it anymore.
  351. //! That resulted in a much shorter implementation (234628B -> 234476B)
  352. //! There are similar functions around which may be shortened in a similar way
  353. void menu_draw_float31(const char* str, float val)
  354. {
  355. lcd_printf_P(menu_fmt_float31, str, val);
  356. }
  357. //! @brief Draw up to 14 chars of text and a float number in format +1.234
  358. //!
  359. //! @param str string label to print
  360. //! @param val value to print aligned to the right side of the display
  361. //!
  362. //! Implementation comments:
  363. //! This function uses similar optimization principles as menu_draw_float31
  364. //! (i.e. str must include a ':' at its end)
  365. //! FLASH usage dropped 234476B -> 234392B
  366. //! Moreover, this function gets inlined in the final code, so removing it doesn't really help ;)
  367. void menu_draw_float13(const char* str, float val)
  368. {
  369. lcd_printf_P(menu_fmt_float13, ' ', str, val);
  370. }
  371. template <typename T>
  372. static void _menu_edit_P(void)
  373. {
  374. menu_data_edit_t* _md = (menu_data_edit_t*)&(menu_data[0]);
  375. if (lcd_draw_update)
  376. {
  377. if (lcd_encoder < _md->minEditValue) lcd_encoder = _md->minEditValue;
  378. if (lcd_encoder > _md->maxEditValue) lcd_encoder = _md->maxEditValue;
  379. lcd_set_cursor(0, 1);
  380. menu_draw_P<T>(' ', _md->editLabel, (int)lcd_encoder);
  381. }
  382. if (LCD_CLICKED)
  383. {
  384. *((T)(_md->editValue)) = lcd_encoder;
  385. menu_back_no_reset();
  386. }
  387. }
  388. template <typename T>
  389. uint8_t menu_item_edit_P(const char* str, T pval, int16_t min_val, int16_t max_val)
  390. {
  391. menu_data_edit_t* _md = (menu_data_edit_t*)&(menu_data[0]);
  392. if (menu_item == menu_line)
  393. {
  394. if (lcd_draw_update)
  395. {
  396. lcd_set_cursor(0, menu_row);
  397. menu_draw_P<T>(menu_selection_mark(), str, *pval);
  398. }
  399. if (menu_clicked && (lcd_encoder == menu_item))
  400. {
  401. menu_submenu_no_reset(_menu_edit_P<T>);
  402. _md->editLabel = str;
  403. _md->editValue = pval;
  404. _md->minEditValue = min_val;
  405. _md->maxEditValue = max_val;
  406. lcd_encoder = *pval;
  407. return menu_item_ret();
  408. }
  409. }
  410. menu_item++;
  411. return 0;
  412. }
  413. template uint8_t menu_item_edit_P<int16_t*>(const char* str, int16_t *pval, int16_t min_val, int16_t max_val);
  414. template uint8_t menu_item_edit_P<uint8_t*>(const char* str, uint8_t *pval, int16_t min_val, int16_t max_val);
  415. #undef _menu_data