请教：傻孩子菜单的函数执行菜单怎样用？

jssd

菜单A                                            菜单B
项目1                                            数量x
项目2  -->（按确认键后进入）-->    UP,DOWN按键调整
项目3                                            OK          按键返回

如上面菜单所示：
在菜单A中，按UP,DOWN键选择项目，按 OK 键进入下一级菜单（如选择项目2进入菜单B）
菜单B是调整数量x的，按UP,DOWN按键调整，按OK按键返回

问题来了：菜单B是否要定义成MenuItem？UP,DOWN按键是怎样处理的？

菜单链接，在100楼
[古董贴][交流]怎样在点阵屏上绘图——基于LCD12864
https://www.amobbs.com/thread-591361-1-1.html
(出处: amoBBS 阿莫电子论坛)

Gorgon_Meducer

我看了下原贴子，我提供处理代码了呀？哪里看不明白？

jssd

Gorgon_Meducer 发表于 2018-3-13 21:19
我看了下原贴子，我提供处理代码了呀？哪里看不明白？

谢谢傻孩子考试回复，不是不明白，菜单跳转也都没问题，但如果菜单带有变量要显示呢？这个变量要随着按键调整呢？也就是不同的界面对应不同的按键功能。

jssd

Gorgon_Meducer 发表于 2018-3-13 21:19
我看了下原贴子，我提供处理代码了呀？哪里看不明白？

如果把变量那些加到结构体里，结构体会变得很庞大，如果单独放出来，又很难处理

Gorgon_Meducer

jssd 发表于 2018-3-13 21:59
如果把变量那些加到结构体里，结构体会变得很庞大，如果单独放出来，又很难处理 ...

如果不同的菜单对应不同的按键，那的确不能直接使用统一的菜单引擎了，但答案也很明显啊。
你在每个菜单的结构体里再加入一个函数指针，指向这个菜单专用的处理引擎函数就行了，
这样对于普通的菜单，那就统一指向一个默认的菜单处理引擎函数；对于有特殊要求的菜单，
就指向自己专用的菜单引擎处理函数就行了。

不知道我说的你是否理解了？

我更新了下菜单的数据结构，希望有所启示:

1. 
   
2. 
   
3. #ifndef __FSM_RT_TYPE__
   
4. #define __FSM_RT_TYPE__
   
5. //! \name finit state machine state
   
6. //! @{
   
7. typedef enum {
   
8.     fsm_rt_err          = -1,    //!< fsm error, error code can be get from other interface
   
9.     fsm_rt_cpl          = 0,     //!< fsm complete
   
10.     fsm_rt_on_going     = 1,     //!< fsm on-going
    
11.     fsm_rt_wait_for_obj = 2,     //!< fsm wait for object
    
12.     fsm_rt_asyn         = 3,     //!< fsm asynchronose complete, you can check it later.
    
13. } fsm_rt_t;
    
14. //! @}
    
15. 
    
16. #endif
    
17. 
    
18. 
    
19. typedef struct __menu_item  menu_item_t;
    
20. typedef struct __menut      menu_t;
    
21. 
    
22. typedef fsm_rt_t menu_item_handler_t(menu_item_t *);
    
23. 
    
24. struct __menu_item {
    
25.     menu_item_handler_t *fnHandle;                      //!< handler
    
26.     menu_t              *ptChild;                       //!< Child Menu
    
27.    
    
28.     //! depends on your application, you can add/remove/change following members
    
29.     char                *pchTitle;                      //!< Menu Title
    
30.     char                *pchDescription;                //!< Description for this menu item
    
31.     char                chShortCutKey;                  //!< Shortcut Key value in current menu
    
32. };
    
33. 
    
34. typedef fsm_rt_t menu_engine_t(menu_t *);
    
35. 
    
36. struct __menut {
    
37.     menu_item_t        *ptItems;                        //!< menu item list
    
38.     uint_fast8_t        chCount;                        //!< menu item count
    
39.     menu_t             *ptParent;                       //!< parent menu;
    
40.     menu_engine_t      *fnEngine;                       //!< engine for process current menu
    
41. };
    
42. 
    

复制代码

一个可能的初始化形式是：

1. 
   
2. extern fsm_rt_t top_menu_engine(menu_t *ptMenu);
   
3. 
   
4. extern fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem);
   
5. extern fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem);
   
6. extern fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem);
   
7. 
   
8. extern const menu_t c_tTopMenu;
   
9. 
   
10. menu_item_t c_tTopMenuItems[] = {
    
11.     {
    
12.         top_menu_item_a_handler,
    
13.         NULL,                                           //!< child menu
    
14.         "Top Menu A",
    
15.         "This is Top Menu A",
    
16.     },
    
17.     {
    
18.         top_menu_item_b_handler,
    
19.         NULL,                                           //!< child menu
    
20.         "Top Menu B",
    
21.         "This is Top Menu B"
    
22.     },
    
23.     {
    
24.         top_menu_item_c_handler,
    
25.         NULL,                                           //!< child menu
    
26.         "Top Menu C",
    
27.         "This is Top Menu C"
    
28.     }
    
29. };
    
30. 
    
31. const menu_t c_tTopMenu = {
    
32.     c_tTopMenuItems,                                    //!< menu item list
    
33.     UBOUND(c_tTopMenuItems),                            //!< menu item count
    
34.     NULL,                                               //!< top menu has no parent
    
35.     top_menu_engine,                                    
    
36. };
    
37. 
    
38. 
    
39. fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem)
    
40. {
    
41.     return fsm_rt_cpl;
    
42. }
    
43. 
    
44. fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem)
    
45. {
    
46.     return fsm_rt_cpl;
    
47. }
    
48. 
    
49. fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem)
    
50. {
    
51.     return fsm_rt_cpl;
    
52. }
    
53. 
    
54. fsm_rt_t top_menu_engine(menu_t *ptMenu)
    
55. {
    
56.     return fsm_rt_cpl;
    
57. }
    

复制代码

通过加入一些辅助宏，我们可以让这个初始化的菜单的定义过程更简单（只消耗ROM）：

1. 
   
2. #define __def_menu(__NAME, __PARENT, __ENGINE)                                  \
   
3. extern const menu_t c_tMenu##__NAME;                                            \
   
4. menu_item_t c_tMenu##__NAME##Items[] = {
   
5. #define def_menu(__NAME, __PARENT, __ENGINE)                                    \
   
6.             __def_menu(__NAME, (__PARENT), (__ENGINE))
   
7. 
   
8. #define __end_def_menu(__NAME, __PARENT, __ENGINE)                              \
   
9.     };                                                                          \
   
10.     const menu_t c_tMenu##__NAME = {                                            \
    
11.         c_tMenu##__NAME##Items,                                                 \
    
12.         (sizeof(c_tMenu##__NAME##Items)/sizeof(menu_item_t)),                   \
    
13.         (__PARENT),                                                             \
    
14.         &(__ENGINE),                                                            \
    
15.     };
    
16. #define end_def_menu(__NAME, __PARENT, __ENGINE)                                \
    
17.             __end_def_menu(__NAME, (__PARENT), (__ENGINE))
    
18.             
    
19.             
    
20. #define __extern_menu(__NAME)   extern const menu_t c_tMenu##__NAME;
    
21. #define extern_menu(__NAME)     __extern_menu(__NAME)
    
22.             
    
23. #define __menu(__NAME)          c_tMenu##__NAME
    
24. #define menu(__NAME)            __menu(__NAME)   
    
25. 
    
26. #define __menu_item(__HANDLER, __CHILD_MENU, ...)                               \
    
27.     {                                                                           \
    
28.         &(__HANDLER),                                                           \
    
29.         (__CHILD_MENU),                                                         \
    
30.         __VA_ARGS__,                                                            \
    
31.     },
    
32. #define menu_item(__HANDLER, __CHILD_MENU, ...)                                 \
    
33.             __menu_item((__HANDLER), (__CHILD_MENU), __VA_ARGS__)
    

复制代码

因此，前面初始化的例子就等效的可以简化为：

1. 
   
2. extern fsm_rt_t top_menu_engine(menu_t *ptMenu);
   
3. 
   
4. extern fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem);
   
5. extern fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem);
   
6. extern fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem);
   
7. 
   
8. 
   
9. def_menu(TopMenu, NULL, top_menu_engine)
   
10.     menu_item(
    
11.         top_menu_item_a_handler,
    
12.         NULL,
    
13.         "Top Menu A",
    
14.         "This is Top Menu A"
    
15.     )
    
16.     menu_item(
    
17.         top_menu_item_a_handler,
    
18.         NULL,
    
19.         "Top Menu B",
    
20.         "This is Top Menu B"
    
21.     )
    
22.     menu_item(
    
23.         top_menu_item_a_handler,
    
24.         NULL,
    
25.         "Top Menu C",
    
26.         "This is Top Menu C"
    
27.     )
    
28. end_def_menu(TopMenu, NULL, top_menu_engine)
    
29. 
    
30. 
    
31. fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem)
    
32. {
    
33.     return fsm_rt_cpl;
    
34. }
    
35. 
    
36. fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem)
    
37. {
    
38.     return fsm_rt_cpl;
    
39. }
    
40. 
    
41. fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem)
    
42. {
    
43.     return fsm_rt_cpl;
    
44. }
    
45. 
    
46. fsm_rt_t top_menu_engine(menu_t *ptMenu)
    
47. {
    
48.     return fsm_rt_cpl;
    
49. }
    

复制代码

定义好的menu怎么用呢？

需要用到变量的时候，用menu宏，例如：

1. 
   
2.     menu_t *ptThis = &menu(TopMenu);                        
   

复制代码

如果要extern给其它.c文件使用怎么办呢？使用extern_menu宏，例如：

1. 
   
2. ...
   
3.     extern_menu(TopMenu);
   
4. ...                       
   

复制代码

我专门开了一个帖子来详细讨论菜单技术：
https://www.amobbs.com/thread-5688720-1-1.html

jssd

Gorgon_Meducer 发表于 2018-3-14 18:43
如果不同的菜单对应不同的按键，那的确不能直接使用统一的菜单引擎了，但答案也很明显啊。
你在每个菜单 ...

谢谢解答！在专用的处理引擎函数处理各自的界面和按键处理之类的是可以解决，我也试过这样写，相当一个弹出式的菜单，然后发现整个菜单会被搞得乱七八糟的，还不如直接用一个switch结构来的清晰。
仔细看了下你的新帖子，发现功力不够，不是很明白，我再静心看多几次。非常感谢

Gorgon_Meducer

jssd 发表于 2018-3-15 09:52
谢谢解答！在专用的处理引擎函数处理各自的界面和按键处理之类的是可以解决，我也试过这样写，相当一个弹 ...

具体什么地方不明白，还请务必在帖子里提出，我给你答案。
相信我，你遇到的问题一定对其它人有很大的帮助。

jssd

Gorgon_Meducer 发表于 2018-3-15 17:48
具体什么地方不明白，还请务必在帖子里提出，我给你答案。
相信我，你遇到的问题一定对其它人有很大的帮 ...

因为涉及工作的东西，所以不能全部弄出来 ，请见谅。但我会整理一下，以最接近的形式提出。

Gorgon_Meducer

jssd 发表于 2018-3-16 16:45
因为涉及工作的东西，所以不能全部弄出来 ，请见谅。但我会整理一下，以最接近的形式提出。 ...

期待你的具体问题。