選單技術

出處：https://www.amobbs.com/thread-5688720-1-1.html

說在前面的話

•         槽點1：  為毛不用typedef
•         槽點2：  為毛不用 stdint 裡面的標準型別？
•         槽點3：  為毛要浪費一個位元組來儲存  MenuCount？
•         槽點4：  函式指標  void (*Subs)()  為毛形參要省略 void ？
•         槽點5：  為什麼每一個選單項（MenuItem）都要包含一個指向父目錄的指標？
•         槽點6：  為什麼缺失了 專門的型別來描述選單？（這裡是直接用 MenuItem 的陣列裸體上陣直接表示一個menu）
•         槽點7：  NULL_MENU是什麼鬼？為什麼要浪費這個空間？
•         槽點8：  選單項處理函式的原型，為什麼返回值是void？難道不應該是一個狀態機麼？（返回 fsm_rt_t）
•         ...
•         槽點n： 沒有用匈牙利算不算……
  

•     槽點1： 為什麼不用typedef的型別？（好吧也許不算個槽點）
•     槽點2： 為什麼不用靜態賦值的方法初始化？（這裡用的是一個函式）
•     槽點3： 為什麼陣列的大小要直接用數字給定？（應該通過靜態初始化由編譯器來確定陣列的大小）
•     槽點4： 請大家無視“&Null”，這是我人生的汙點……
  

• 當fnHandle不為NULL、指向對應的處理函式而ptChild為NULL時表示這是一個普通的選單項，當使用者選擇了
  這一選項時，對應的處理程式就會被執行。值得注意的是，這裡的fnHandler指向的是一個狀態機，這意味著
  選單引擎即有能力實現一個非阻塞的選單結構，也可以無視狀態機的返回，實現一個“一次性”的阻塞式選單
  處理程式。
  
• 當ptChild不為NULL、指向下一級選單而fnHandler為NULL時表示這是一個多級選單的入口。
• ptChild和fnHandler同時不為空的情況較為少見，一般為了滿足某些特殊的需求，需要定製特定的選單引擎
  來配合。
  

• 非常直接的，menu_t結構體的前兩個成員就是體現其容器作用的ptItems和chCount。前者指向具體的選單
  項陣列，後者用以描述陣列中有效的選單項個數。
• ptParent用以指向當前選單的父選單。單一的指標限定了當前選單的扇入為1——也就是隻有唯一的一個父
  目錄——這對大部分應用來說不是什麼問題。如果要支援更為靈活的結構，解決方案並不是在這裡追加父目錄
  指標的數量，而是在這一資料結構外額外增加一個動態的單連結串列，用以記錄使用者開啟目錄的路徑，用以實現與
  手機瀏覽時常見的“返回之前頁面”類似的效果——在這種情況下，ptParent理論上也可以從結構體中刪除。
• 一般來說，簡單的應用傾向於給每一個選單都使用同樣的導航方式（根據按鍵處理選單選擇的方式）——
  也就是說唯一的一個選單引擎就夠了，然而在一些複雜的情況下，不同的選單可能有自己獨特的按鍵佈局和
  選單跳轉需要——比如前一個目錄是簡單的線性排列結構而後面一個目錄是平面的二維目錄結構，他們對按鍵
  的響應方式是不同的——在這種情況下，為每一個選單增加一個指向對應選單引擎的函式指標就非常有必要了。
  

• 這是一個狀態機，意味著選單的處理可以是非阻塞的，這對喜歡酷炫特效以及需要在選單後面做小動作的應用來說非常
  關鍵。狀態機的模板參考我專門的帖子。在106樓的例子非常有參考價值，這裡就不具體展開了。
• 狀態機的傳入引數 ptThis 指向的是一個選單引擎的runtime控制塊，裡面存放的是關於選單當前狀態的各種資訊，容易
  想到：
  
  1. 
     
  2. typedef struct __menu_engine_cb menu_engine_cb_t;
     
  3. typedef fsm_rt_t menu_engine_t(menu_engine_cb_t *);
     
  4. 
     
  5. struct __menut {
     
  6.     menu_item_t        *ptItems;                        //!< menu item list
     
  7.     uint_fast8_t        chCount;                        //!< menu item count
     
  8.     menu_t             *ptParent;                       //!< parent menu;
     
  9.     menu_engine_t      *fnEngine;                       //!< engine for process current menu
     
  10. }; 
      
  11. 
      
  12. struct __menu_engine_cb {
      
  13.     const menu_t    *ptCurrentMenu;
      
  14.     uint_fast8_t    chCurrentItemIndex;
      
  15. };
      

  複製程式碼
  
  這裡，ptCurrentMenu是一個指向當前選單的指標，而chCurrentItemIndex儲存的就是當前使用者選中的選單項的陣列下標。
  僅靠這兩個變數，理論上再配合按鍵輸入，已經能夠實現一個簡單的選單引擎。實際上，考慮到目錄選單引擎是一個狀態
  機，因而將狀態機變數也放在menu_engine_cb_t中也是可行的，比如：
  
  1. 
     
  2. struct __menu_engine_cb {
     
  3.     uint_fast8_t tState;
     
  4.     const menu_t    *ptCurrentMenu;
     
  5.     uint_fast8_t    chCurrentItemIndex;
     
  6. };
     

  複製程式碼
  
  
  這裡給出一個簡化的引擎範例（虛擬碼）：
  
  1. 
     
  2. 
     
  3. #ifndef this
     
  4. #   define this        (*ptThis)
     
  5. #endif
     
  6. 
     
  7. typedef enum {
     
  8.     KEY_NULL = 0,
     
  9.     KEY_DOWN,
     
  10.     KEY_UP,
      
  11.     KEY_ENTER,
      
  12.     KEY_ESC,
      
  13. } key_t;
      
  14. 
      
  15. extern key_t get_key(void);
      
  16. 
      
  17. fsm_rt_t default_menu_engine(menu_engine_cb_t *ptThis)
      
  18. {
      
  19. #define DEFAULT_MENU_ENGINE_RESET_FSM() \
      
  20.     do { this.tState = START; } while(0)
      
  21. 
      
  22.     enum {
      
  23.         START = 0,
      
  24.         READ_KEY_EVENT, 
      
  25.         KEY_PROCESS, 
      
  26.         RUN_ITEM_HANDLER
      
  27.     };
      
  28.     key_t tKey;
      
  29.     menu_item_t *ptItem;
      
  30.     
      
  31.     switch(this.tState) {
      
  32.         case START:
      
  33.             this.tState++;
      
  34.         case READ_KEY_EVENT: 
      
  35.             tKey = get_key();
      
  36.             if (KEY_NULL == tKey) {
      
  37.                 break;
      
  38.             }
      
  39.             //this.tState = KEY_PROCESS;
      
  40.             
      
  41.         case KEY_PROCESS:
      
  42.             switch (tKey) {
      
  43.                 case KEY_DOWN:
      
  44.                     this.chCurrentItemIndex++;
      
  45.                     if (this.chCurrentItemIndex >= this.ptCurrentMenu->chCount) {
      
  46.                         this.chCurrentItemIndex = 0;
      
  47.                     }
      
  48.                     break;
      
  49.                 case KEY_UP:
      
  50.                     if (0 == this.chCurrentItemIndex) {
      
  51.                         this.chCurrentItemIndex = this.ptCurrentMenu->chCount - 1;
      
  52.                     }
      
  53.                     break;
      
  54.                 case KEY_ENTER: {
      
  55.                         ptItem = &(this.ptCurrentMenu->ptItems[this.chCurrentItemIndex]);
      
  56.                         if (NULL != ptItem->fnHandle) {
      
  57.                             this.tState = RUN_ITEM_HANDLER;
      
  58.                         } else if (NULL != ptItem->ptChild) {
      
  59.                             this.ptCurrentMenu = ptItem->ptChild;
      
  60.                             this.chCurrentItemIndex = 0;
      
  61.                             
      
  62.                             DEFAULT_MENU_ENGINE_RESET_FSM();
      
  63.                             return fsm_rt_cpl;
      
  64.                         }
      
  65.                     }
      
  66.                     break;
      
  67.                 case KEY_ESC:
      
  68.                 
      
  69.                     //! return to upper menu
      
  70.                     if (NULL != this.ptCurrentMenu->ptParent) {
      
  71.                         this.ptCurrentMenu = this.ptCurrentMenu->ptParent;
      
  72.                         this.chCurrentItemIndex = 0;
      
  73.                             
      
  74.                         DEFAULT_MENU_ENGINE_RESET_FSM();
      
  75.                         return fsm_rt_cpl;
      
  76.                     }
      
  77.                     break;
      
  78.                 default:
      
  79.                     break;
      
  80.             }
      
  81.             break;
      
  82.             
      
  83.         case RUN_ITEM_HANDLER:
      
  84.             ptItem = &(this.ptCurrentMenu->ptItems[this.chCurrentItemIndex]);
      
  85.             fsm_rt_t tFSM = ptItem->fnHandle(ptItem);
      
  86.             if (IS_FSM_ERR(tFSM)) {
      
  87.                 //! report error
      
  88.                 DEFAULT_MENU_ENGINE_RESET_FSM();
      
  89.                 return tFSM;
      
  90.             } else if (fsm_rt_cpl == tFSM) {
      
  91.                 DEFAULT_MENU_ENGINE_RESET_FSM();
      
  92.                 return fsm_rt_cpl;
      
  93.             }
      
  94.             break;
      
  95.     }
      
  96. 
      
  97.     return fsm_rt_on_going;
      
  98. }
      

  複製程式碼
  
  
  

<-----------------------------------------分割線----------------------------------------->

說說我的理解，不一定對，但是會給提供一個參考，希望大家踴躍留言。

選單就是一系列的介面的有機結合，你可以簡單認為是個樹形結構。至於這個樹形結構是怎麼

實現，陣列也好、連結串列也行。然後就是實現的問題，我們可以把內容和現實耦合在一起，就是

每屏都有自己的畫刷；也可以把畫刷剝離出來，但是寫成一個選單顯示引擎。再有就是選單的

索引驅動，怎麼設計。基於上面這篇論文，我們可以把選單的引擎獨立出來，它包括顯示驅動

（也可以是一個fnHandler，由每屏傳入，本論文沒有這麼做）+搜尋驅動（也可以是一個

fnHandler，由每屏傳入，本論文就是這麼設計的），在這裡我感覺可以這麼設計，就是使用者如果

傳入的是NULL指標，就呼叫系統的標準處理函式，如果傳入的不是NULL，就呼叫使用者的函式。

好了，到目前為止，我們提取了選單引擎。那麼選單如何設計內？我們知道一屏內容可能包含幾種

控制元件，每種控制元件都有自己的內容和屬性。於是就有了選單項和選單容器的概念，一個選單項就是一

個控制元件，容器可以認為是一屏，可以類比MFC。這裡需要為每個選單項新增一個type，這樣選單引

擎才能載入合適的驅動。