From 4683b88d0c7b2507666465292df761c90222275c Mon Sep 17 00:00:00 2001
From: erikkaashoek <erik@kaashoek.com>
Date: Tue, 31 Mar 2020 11:07:43 +0200
Subject: [PATCH] Menu update

---
 main.c  |   4 +-
 ui.c    |  38 ++++--
 ui_sa.c | 408 +++++++++++++++++++++-----------------------------------
 3 files changed, 187 insertions(+), 263 deletions(-)

diff --git a/main.c b/main.c
index 424b80c..460245e 100644
--- a/main.c
+++ b/main.c
@@ -117,7 +117,7 @@ const char *info_about[]={
   0 // sentinel
 };
 
-static THD_WORKING_AREA(waThread1, 750);
+static THD_WORKING_AREA(waThread1, 730);
 static THD_FUNCTION(Thread1, arg)
 {
   (void)arg;
@@ -2140,7 +2140,7 @@ VNA_SHELL_FUNCTION(cmd_threads)
   thread_t *tp;
   (void)argc;
   (void)argv;
-  shell_printf("stklimit|   stack|stk free|    addr|refs|prio|    state|        name"VNA_SHELL_NEWLINE_STR);
+  shell_printf("stklimit|   |stk free|    addr|refs|prio|    state|        name"VNA_SHELL_NEWLINE_STR);
   tp = chRegFirstThread();
   do {
     uint32_t max_stack_use = 0U;
diff --git a/ui.c b/ui.c
index 544d47b..82f58c3 100644
--- a/ui.c
+++ b/ui.c
@@ -434,10 +434,13 @@ enum {
   MT_CALLBACK,
   MT_CANCEL,
   MT_TITLE,
-  MT_CLOSE
+  MT_CLOSE,
+  MT_KEYPAD
 };
-#define MT_FORM 0x80        // Or with menu type to get large button with current value
-#define MT_MASK(x) (0x7F & (x))
+#define MT_FORM     0x80        // Or with menu type to get large button with current value
+#define MT_BACK     0x40
+#define MT_LEAVE    0x20
+#define MT_MASK(x) (0xF & (x))
 
 typedef void (*menuaction_cb_t)(int item, uint8_t data);
 
@@ -767,15 +770,15 @@ menu_marker_op_cb(int item, uint8_t data)
 static void
 menu_marker_search_cb(int item, uint8_t data)
 {
-  (void)data;
+  (void)item;
   int i = -1;
   if (active_marker == -1)
     return;
 
-  switch (item) {
+  switch (data) {
   case 0: /* maximum */
   case 1: /* minimum */
-    set_marker_search(item);
+    set_marker_search(data);
     i = marker_search();
     break;
   case 2: /* search Left */
@@ -1145,10 +1148,11 @@ menu_move_top(void)
 static void
 menu_invoke(int item)
 {
+  int status;
   const menuitem_t *menu = menu_stack[menu_current_level];
   menu = &menu[item];
 
-  switch (menu->type & 0x0f) {
+  switch (MT_MASK(menu->type)) {
   case MT_NONE:
   case MT_BLANK:
   case MT_CLOSE:
@@ -1164,12 +1168,30 @@ menu_invoke(int item)
     if (cb == NULL)
       return;
     (*cb)(item, menu->data);
+    if (!(menu->type & MT_FORM))
+      draw_cal_status();
     break;
   }
 
   case MT_SUBMENU:
     menu_push_submenu((const menuitem_t*)menu->reference);
     break;
+
+  case MT_KEYPAD:
+    status = btn_wait_release();
+    if (status & EVT_BUTTON_DOWN_LONG) {
+      ui_mode_numeric(menu->data);
+      //    ui_process_numeric();
+    } else {
+      if (menu->type & MT_FORM) {
+        area_width = AREA_WIDTH_NORMAL - MENU_BUTTON_WIDTH;
+        redraw_frame();         // Remove form numbers
+      }
+      ui_mode_keypad(menu->data);
+      ui_process_keypad();
+    }
+    draw_cal_status();
+    break;
   }
 }
 
@@ -1482,7 +1504,7 @@ draw_menu_buttons(const menuitem_t *menu)
     if (menu[i].type & MT_FORM) {
       active_button_start = 320 - MENU_FORM_WIDTH;
       active_button_width = MENU_FORM_WIDTH - 30;       // Shorten at the right
-      if (MT_MASK(menu[i].type) == MT_CALLBACK) {       // Only callback can have value
+      if (MT_MASK(menu[i].type) == MT_KEYPAD) {         // Only keypad retrieves value
         keypad_mode = menu[i].data;
         fetch_numeric_target();
       }
diff --git a/ui_sa.c b/ui_sa.c
index d997f30..7d479e8 100644
--- a/ui_sa.c
+++ b/ui_sa.c
@@ -228,7 +228,7 @@ void menu_autosettings_cb(int item, uint8_t data)
   dirty = true;
   //  menu_move_back();   // stay in input menu
   ui_mode_normal();
-  draw_cal_status();
+//  draw_cal_status();
 }
 
 static void menu_calibrate_cb(int item, uint8_t data)
@@ -285,16 +285,18 @@ static void menu_dfu_cb(int item, uint8_t data)
   }
 }
 
-int menu_modulation_value[]={0, MO_NONE,MO_AM, MO_NFM, MO_WFM};
-char *menu_modulation_text[]={"NONE","AM","NARROW FM","WIDE FM"};
+
+const int menu_modulation_value[]={MO_NONE,MO_AM, MO_NFM, MO_WFM};
+const char *menu_modulation_text[]={"NONE","AM","NARROW FM","WIDE FM"};
+
 static void menu_modulation_cb(int item, uint8_t data)
 {
-  (void)data;
+  (void)item;
 //Serial.println(item);
-  SetModulation(menu_modulation_value[item]);
+  SetModulation(menu_modulation_value[data]);
   menu_move_back();
 //  ui_mode_normal();   // Stay in menu mode
-  draw_cal_status();
+//  draw_cal_status();
 }
 
 
@@ -302,24 +304,29 @@ const int menu_reffer_value[]={-1,0,1,2,3,4,5,6};
 const char *menu_reffer_text[]={"OFF","30MHz","15MHz","10MHz","4MHz","3MHz","2MHz","1MHz"};
 static void menu_reffer_cb(int item, uint8_t data)
 {
-  (void)data;
+  (void)item;
 //Serial.println(item);
-  set_refer_output(menu_reffer_value[item]);
+  set_refer_output(menu_reffer_value[data]);
   menu_move_back();
 //  ui_mode_normal();   // Stay in menu mode
-  draw_cal_status();
+//  draw_cal_status();
 }
 
-static void menu_reffer_cb2(int item, uint8_t data)
+const int menu_drive_value[]={5,10,15,20};
+const char *menu_drive_text[]={"5dBm","10dBm","15dBm","20dBm"};
+static void menu_drive_cb(int item, uint8_t data)
 {
-  (void)data;
+  (void)item;
 //Serial.println(item);
-  set_refer_output(menu_reffer_value[item+5]);
+  SetDrive(data);
   menu_move_back();
-  //  ui_mode_normal();   // Stay in menu mode
-  draw_cal_status();
+//  ui_mode_normal();
+//  draw_cal_status();
 }
 
+
+
+
 static void menu_spur_cb(int item, uint8_t data)
 {
   (void)data;
@@ -337,8 +344,8 @@ static void menu_spur_cb(int item, uint8_t data)
 
 static void menu_storage_cb(int item, uint8_t data)
 {
-  (void)data;
-  switch(item) {
+  (void)item;
+  switch(data) {
     case 0:
       SetStorage();
       break;
@@ -354,7 +361,7 @@ static void menu_storage_cb(int item, uint8_t data)
   }
   menu_move_back();
   ui_mode_normal();
-  draw_cal_status();
+//  draw_cal_status();
 }
 
 static void menu_average_cb(int item, uint8_t data)
@@ -368,16 +375,16 @@ static void menu_average_cb(int item, uint8_t data)
 
 static void menu_marker_type_cb(int item, uint8_t data)
 {
-  (void)data;
+  (void)item;
   if (markers[active_marker].enabled)
   {
-    if (item == M_REFERENCE) {
+    if (data == M_REFERENCE) {
       for (int i = 0; i<MARKER_COUNT; i++ ) {
         if (markers[i].mtype ==M_REFERENCE)
           markers[i].mtype = M_NORMAL;
       }
     }
-    markers[active_marker].mtype = item;
+    markers[active_marker].mtype = data;
   }
   markmap_all_markers();
 //  redraw_marker(active_marker, TRUE);
@@ -390,22 +397,22 @@ const int rbwsel[]={0,3,10,30,100,300};
 
 static void menu_rbw_cb(int item, uint8_t data)
 {
-  (void)data;
-  SetRBW(rbwsel[item]); 
+  (void)item;
+  SetRBW(rbwsel[data]);
   menu_move_back();
   ui_mode_normal();
-  draw_cal_status();
+//  draw_cal_status();
 }
 
 int menu_dBper_value[]={1,2,5,10,20};
 
 static void menu_dBper_cb(int item, uint8_t data)
 {
-  (void)data;
-  SetScale(menu_dBper_value[item]);
+  (void)item;
+  SetScale(menu_dBper_value[data]);
   menu_move_back();
   ui_mode_normal();
-  draw_cal_status();
+//  draw_cal_status();
 }
 
 #if 0
@@ -433,87 +440,6 @@ static void choose_active_marker(void)
   active_marker = -1;
 }
 
-static void menu_scale_cb(int item, uint8_t data)
-{
-  (void)item;
-  int status;
-  status = btn_wait_release();
-  if (status & EVT_BUTTON_DOWN_LONG) {
-    ui_mode_numeric(data);
-//    ui_process_numeric();
-  } else {
-    ui_mode_keypad(data);
-    ui_process_keypad();
-  }
-  draw_cal_status();
-}
-
-static void menu_lowoutputmode_cb(int item, uint8_t data)
-{
-  int status;
-  int km = data;
-  (void) item;
-//  if (km == KM_SCALE && trace[uistat.current_trace].type == TRC_DELAY) {
-//    km = KM_SCALEDELAY;
-//  }
-
-  status = btn_wait_release();
-
-  if (item == 3) {
-    menu_push_submenu(menu_modulation);
-  } else
-  {
-    if (status & EVT_BUTTON_DOWN_LONG) {
-      ui_mode_numeric(km);
-      //    ui_process_numeric();
-    } else {
-      area_width = AREA_WIDTH_NORMAL - MENU_BUTTON_WIDTH;
-      redraw_frame();         // Remove form numbers
-      ui_mode_keypad(km);
-      ui_process_keypad();
-    }
-  }
-  draw_cal_status();
-}
-#if 0
-static void menu_highoutputmode_cb(int item, uint8_t data)
-{
-  int status;
-  int km = data;
-  (void) item;
-
-//  if (km == KM_SCALE && trace[uistat.current_trace].type == TRC_DELAY) {
-//    km = KM_SCALEDELAY;
-//  }
-  status = btn_wait_release();
-  if (status & EVT_BUTTON_DOWN_LONG) {
-    ui_mode_numeric(km);
-//    ui_process_numeric();
-  } else {
-    area_width = AREA_WIDTH_NORMAL - MENU_BUTTON_WIDTH;
-    redraw_frame();         // Remove form numbers
-    ui_mode_keypad(km);
-    ui_process_keypad();
-  }
-  draw_cal_status();
-}
-#endif
-
-static void menu_settings_cb(int item, uint8_t data)
-{
-  (void)item;
-  int status;
-  status = btn_wait_release();
-  if (status & EVT_BUTTON_DOWN_LONG) {
-    ui_mode_numeric(data);
-    //    ui_process_numeric();
-  } else {
-    ui_mode_keypad(data);
-    ui_process_keypad();
-  }
-  draw_cal_status();
-}
-
 static void menu_settings2_cb(int item, uint8_t data)
 {
   (void)data;
@@ -528,97 +454,96 @@ static void menu_settings2_cb(int item, uint8_t data)
     toggle_tracking();
     break;
   }
-  draw_cal_status();
   draw_menu();
+//  draw_cal_status();
 }
 
-static void menu_stimulus_cb(int item, uint8_t data)
+static void menu_pause_cb(int item, uint8_t data)
 {
   (void) data;
-  int status;
-  int km = item+KM_START;
-  switch (km) {
-  case KM_START: /* START */
-  case KM_STOP: /* STOP */
-  case KM_CENTER: /* CENTER */
-  case KM_SPAN: /* SPAN */
-  case KM_CW: /* CW */
-    status = btn_wait_release();
-    if (status & EVT_BUTTON_DOWN_LONG) {
-      ui_mode_numeric(km);
-//      ui_process_numeric();
-    } else {
-      ui_mode_keypad(km);
-      ui_process_keypad();
-    }
-    break;
-  case KM_CW+1: /* PAUSE */
-    toggle_sweep();
-    menu_move_back();
-    ui_mode_normal();
-    draw_menu();
-    break;
-  }
-  draw_cal_status();
+  (void) item;
+  toggle_sweep();
+  menu_move_back();
+  ui_mode_normal();
+  draw_menu();
+//  draw_cal_status();
 }
 
 // ===[MENU DEFINITION]=========================================================
 
+static const menuitem_t menu_drive[] = {
+  { MT_CALLBACK, 0, "  5dBm",   menu_drive_cb},
+  { MT_CALLBACK, 1, " 10dBm",   menu_drive_cb},
+  { MT_CALLBACK, 2, " 15dBm",   menu_drive_cb},
+  { MT_CALLBACK, 3, " 20dBm",   menu_drive_cb},
+  { MT_CANCEL,   0, S_LARROW" BACK", NULL },
+  { MT_NONE,     0, NULL, NULL } // sentinel
+};
+
+static const menuitem_t menu_drive_wide[] = {
+  { MT_FORM | MT_CALLBACK, 0, "  5dBm",   menu_drive_cb},
+  { MT_FORM | MT_CALLBACK, 1, " 10dBm",   menu_drive_cb},
+  { MT_FORM | MT_CALLBACK, 2, " 15dBm",   menu_drive_cb},
+  { MT_FORM | MT_CALLBACK, 3, " 20dBm",   menu_drive_cb},
+  { MT_FORM | MT_CANCEL,   0, S_LARROW" BACK", NULL },
+  { MT_NONE,     0, NULL, NULL } // sentinel
+};
+
 const menuitem_t  menu_modulation[] = {
   { MT_FORM | MT_TITLE,    0,  "MODULATION",NULL},
   { MT_FORM | MT_CALLBACK, 0,  "NONE",      menu_modulation_cb},
-  { MT_FORM | MT_CALLBACK, 0,  "AM",        menu_modulation_cb},
-  { MT_FORM | MT_CALLBACK, 0,  "NARROW FM", menu_modulation_cb},
-  { MT_FORM | MT_CALLBACK, 0,  "WIDE FM",   menu_modulation_cb},
+  { MT_FORM | MT_CALLBACK, 1,  "AM",        menu_modulation_cb},
+  { MT_FORM | MT_CALLBACK, 2,  "NARROW FM", menu_modulation_cb},
+  { MT_FORM | MT_CALLBACK, 3,  "WIDE FM",   menu_modulation_cb},
   { MT_FORM | MT_CANCEL,   0,             S_LARROW" BACK",NULL },
   { MT_NONE, 0, NULL, NULL } // sentinel
 };
 
 const menuitem_t  menu_lowoutputmode[] = {
-  { MT_FORM | MT_TITLE,    0,             "LOW OUTPUT",  NULL},
-  { MT_FORM | MT_CALLBACK, KM_CENTER,     "FREQ: %s",    menu_lowoutputmode_cb},
-  { MT_FORM | MT_CALLBACK, KM_LOWOUTLEVEL, "LEVEL: %s",   menu_lowoutputmode_cb},
-  { MT_FORM | MT_SUBMENU,  0,              "MODULATION: %s",   menu_modulation},
-  { MT_FORM | MT_CANCEL,   0,             S_LARROW" BACK",NULL },
+  { MT_FORM | MT_TITLE,    0,               "LOW OUTPUT",       NULL},
+  { MT_FORM | MT_KEYPAD,   KM_CENTER,       "FREQ: %s",         NULL},
+  { MT_FORM | MT_KEYPAD,   KM_LOWOUTLEVEL,  "LEVEL: %s",        NULL},
+  { MT_FORM | MT_SUBMENU,  0,               "MODULATION: %s",   menu_modulation},
+  { MT_FORM | MT_CANCEL,   0,           S_LARROW" BACK",    NULL },
   { MT_NONE, 0, NULL, NULL } // sentinel
 };
 
 const menuitem_t  menu_highoutputmode[] = {
-  { MT_FORM | MT_TITLE,    0,             "HIGH OUTPUT", NULL},
-  { MT_FORM | MT_CALLBACK, KM_CENTER,     "FREQ: %s",    menu_lowoutputmode_cb},    // same menu as low mode
-  { MT_FORM | MT_CALLBACK, KM_HIGHOUTLEVEL,      "LEVEL: %s",   menu_lowoutputmode_cb},
-  { MT_FORM | MT_SUBMENU,  0,              "MODULATION: %s",   menu_modulation},
-  { MT_FORM | MT_CANCEL,   0,             S_LARROW" BACK",NULL },
+  { MT_FORM | MT_TITLE,     0,          "HIGH OUTPUT",      NULL},
+  { MT_FORM | MT_KEYPAD,    KM_CENTER,  "FREQ: %s",         NULL},
+  { MT_FORM | MT_SUBMENU,   0,          "LEVEL: %s",        menu_drive_wide},
+  { MT_FORM | MT_SUBMENU,   0,          "MODULATION: %s",   menu_modulation},
+  { MT_FORM | MT_CANCEL,    0,          S_LARROW" BACK",NULL },
   { MT_NONE, 0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t  menu_average[] = {
-  { MT_CALLBACK, 0, " OFF",   menu_average_cb},
-  { MT_CALLBACK, 0, "\2 MIN\0 HOLD",   menu_average_cb},
-  { MT_CALLBACK, 0, "\2 MAX\0 HOLD",   menu_average_cb},
-  { MT_CALLBACK, 0, "\2 MAX\0 DECAY",   menu_average_cb},
-  { MT_CALLBACK, 0, " 4 ",   menu_average_cb},
-  { MT_CALLBACK, 0, " 16 ",   menu_average_cb},
+  { MT_CALLBACK, 0, " OFF",             menu_average_cb},
+  { MT_CALLBACK, 1, "\2 MIN\0 HOLD",    menu_average_cb},
+  { MT_CALLBACK, 2, "\2 MAX\0 HOLD",    menu_average_cb},
+  { MT_CALLBACK, 3, "\2 MAX\0 DECAY",   menu_average_cb},
+  { MT_CALLBACK, 4, " 4 ",              menu_average_cb},
+  { MT_CALLBACK, 5, " 16 ",             menu_average_cb},
   { MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE, 0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_storage[] = {
   { MT_CALLBACK, 0, "STORE",    menu_storage_cb},
-  { MT_CALLBACK, 0, "CLEAR",    menu_storage_cb},
-  { MT_CALLBACK, 0, "SUBTRACT", menu_storage_cb},
-  { MT_CALLBACK, 0, "WATERFALL",menu_storage_cb},
+  { MT_CALLBACK, 1, "CLEAR",    menu_storage_cb},
+  { MT_CALLBACK, 2, "SUBTRACT", menu_storage_cb},
+  { MT_CALLBACK, 3, "WATERFALL",menu_storage_cb},
   { MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,      0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_rbw[] = {
   { MT_CALLBACK, 0, "  AUTO",   menu_rbw_cb},
-  { MT_CALLBACK, 0, "  3kHz",   menu_rbw_cb},
-  { MT_CALLBACK, 0, " 10kHz",   menu_rbw_cb},
-  { MT_CALLBACK, 0, " 30kHz",   menu_rbw_cb},
-  { MT_CALLBACK, 0, "100kHz",   menu_rbw_cb},
-  { MT_CALLBACK, 0, "300kHz",   menu_rbw_cb},
+  { MT_CALLBACK, 1, "  3kHz",   menu_rbw_cb},
+  { MT_CALLBACK, 2, " 10kHz",   menu_rbw_cb},
+  { MT_CALLBACK, 3, " 30kHz",   menu_rbw_cb},
+  { MT_CALLBACK, 4, "100kHz",   menu_rbw_cb},
+  { MT_CALLBACK, 5, "300kHz",   menu_rbw_cb},
   { MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,      0, NULL, NULL } // sentinel
 };
@@ -626,93 +551,92 @@ static const menuitem_t menu_rbw[] = {
 
 static const menuitem_t menu_dBper[] = {
   { MT_CALLBACK, 0, "  1dB/",   menu_dBper_cb},
-  { MT_CALLBACK, 0, "  2dB/",   menu_dBper_cb},
-  { MT_CALLBACK, 0, "  5dB/",   menu_dBper_cb},
-  { MT_CALLBACK, 0, " 10dB/",   menu_dBper_cb},
-  { MT_CALLBACK, 0, " 20dB/",   menu_dBper_cb},
+  { MT_CALLBACK, 1, "  2dB/",   menu_dBper_cb},
+  { MT_CALLBACK, 2, "  5dB/",   menu_dBper_cb},
+  { MT_CALLBACK, 3, " 10dB/",   menu_dBper_cb},
+  { MT_CALLBACK, 4, " 20dB/",   menu_dBper_cb},
   { MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_reffer2[] = {
-  { MT_FORM | MT_CALLBACK, 0, "3MHz" ,   menu_reffer_cb2},
-  { MT_FORM | MT_CALLBACK, 0, "2MHz" ,   menu_reffer_cb2},
-  { MT_FORM | MT_CALLBACK, 0, "1MHz" ,   menu_reffer_cb2},
+  { MT_FORM | MT_CALLBACK, 5, "3MHz" ,   menu_reffer_cb},
+  { MT_FORM | MT_CALLBACK, 6, "2MHz" ,   menu_reffer_cb},
+  { MT_FORM | MT_CALLBACK, 7, "1MHz" ,   menu_reffer_cb},
   { MT_FORM | MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_reffer[] = {
   { MT_FORM | MT_CALLBACK, 0, "OFF"  ,   menu_reffer_cb},
-  { MT_FORM | MT_CALLBACK, 0, "30MHz",   menu_reffer_cb},
-  { MT_FORM | MT_CALLBACK, 0, "15MHz",   menu_reffer_cb},
-  { MT_FORM | MT_CALLBACK, 0, "10MHz",   menu_reffer_cb},
-  { MT_FORM | MT_CALLBACK, 0, "4MHz" ,   menu_reffer_cb},
+  { MT_FORM | MT_CALLBACK, 1, "30MHz",   menu_reffer_cb},
+  { MT_FORM | MT_CALLBACK, 2, "15MHz",   menu_reffer_cb},
+  { MT_FORM | MT_CALLBACK, 3, "10MHz",   menu_reffer_cb},
+  { MT_FORM | MT_CALLBACK, 4, "4MHz" ,   menu_reffer_cb},
   { MT_FORM | MT_SUBMENU,  0, S_RARROW" MORE", menu_reffer2},
   { MT_FORM | MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_scale[] = {
-  { MT_CALLBACK, KM_REFPOS,         "\2REF\0LEVEL",  menu_scale_cb},
-  { MT_SUBMENU,  0,                 "\2SCALE/\0DIV",     menu_dBper},
-  { MT_CALLBACK, KM_ATTENUATION,    "ATTEN",         menu_scale_cb},
-  { MT_SUBMENU,  0,                 "AVERAGE",       menu_average},
-  { MT_CALLBACK, 0,                 "\2SPUR\0REDUCT.",menu_spur_cb},
-  { MT_SUBMENU,  0,                 "RBW",           menu_rbw},
-  { MT_CANCEL,   0,                 S_LARROW" BACK", NULL },
-  { MT_NONE,     0, NULL, NULL } // sentinel
+  { MT_KEYPAD, KM_REFPOS,       "\2REF\0LEVEL",     NULL},
+  { MT_SUBMENU,0,               "\2SCALE/\0DIV",    menu_dBper},
+  { MT_KEYPAD, KM_ATTENUATION,  "ATTEN",            NULL},
+  { MT_SUBMENU,0,               "AVERAGE",          menu_average},
+  { MT_KEYPAD, 0,               "\2SPUR\0REDUCT.",  menu_spur_cb},
+  { MT_SUBMENU,0,               "RBW",              menu_rbw},
+  { MT_CANCEL, 0,               S_LARROW" BACK", NULL },
+  { MT_NONE,   0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_scalehigh[] = {
-  { MT_CALLBACK, KM_REFPOS, "\2REF\0LEVEL",  menu_scale_cb},
-  { MT_SUBMENU,  0,         "\2SCALE/\0DIV", menu_dBper},
-  { MT_SUBMENU,  0,         "AVERAGE",       menu_average},
-  { MT_SUBMENU,  0,         "RBW",           menu_rbw},
-  { MT_CANCEL,   0, S_LARROW" BACK", NULL },
-  { MT_NONE,     0, NULL, NULL } // sentinel
+  { MT_KEYPAD, KM_REFPOS,   "\2REF\0LEVEL",  NULL},
+  { MT_SUBMENU,0,           "\2SCALE/\0DIV", menu_dBper},
+  { MT_SUBMENU,0,           "AVERAGE",       menu_average},
+  { MT_SUBMENU,0,           "RBW",           menu_rbw},
+  { MT_CANCEL, 0, S_LARROW" BACK", NULL },
+  { MT_NONE,   0, NULL, NULL } // sentinel
 };
 
 
 
-static const menuitem_t menu_stimulus[] = {
-  { MT_CALLBACK, 0, "START",            menu_stimulus_cb},
-  { MT_CALLBACK, 0, "STOP",             menu_stimulus_cb},
-  { MT_CALLBACK, 0, "CENTER",           menu_stimulus_cb},
-  { MT_CALLBACK, 0, "SPAN",             menu_stimulus_cb},
-  { MT_CALLBACK, 0, "CW FREQ",          menu_stimulus_cb},
-//  { MT_SUBMENU,  0, "RBW",              menu_rbw},
-  { MT_CALLBACK, 0, "\2PAUSE\0SWEEP",   menu_stimulus_cb},
-  { MT_CANCEL,   0, S_LARROW" BACK", NULL },
-  { MT_NONE,     0, NULL, NULL } // sentinel
+static const menuitem_t menu_stimulus[8] = {
+  { MT_KEYPAD,  KM_START,   "START",            NULL},
+  { MT_KEYPAD,  KM_STOP,    "STOP",             NULL},
+  { MT_KEYPAD,  KM_CENTER,  "CENTER",           NULL},
+  { MT_KEYPAD,  KM_SPAN,    "SPAN",             NULL},
+  { MT_KEYPAD,  KM_CW,      "CW FREQ",          NULL},
+  { MT_CALLBACK,0,          "\2PAUSE\0SWEEP",   menu_pause_cb},
+  { MT_CANCEL,  0,          S_LARROW" BACK", NULL },
+  { MT_NONE,    0, NULL, NULL } // sentinel
 };
 
 
 static const menuitem_t menu_marker_type[] = {
-  { MT_CALLBACK, 0, "REFERENCE",    menu_marker_type_cb},
-  { MT_CALLBACK, 0, "NORMAL",       menu_marker_type_cb},
-  { MT_CALLBACK, 0, "DELTA",        menu_marker_type_cb},
+  { MT_CALLBACK, M_REFERENCE,   "REFERENCE",    menu_marker_type_cb},
+  { MT_CALLBACK, M_NORMAL,      "NORMAL",       menu_marker_type_cb},
+  { MT_CALLBACK, M_DELTA,       "DELTA",        menu_marker_type_cb},
   { MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
 };
 
 const menuitem_t menu_marker_search[] = {
   //{ MT_CALLBACK, "OFF", menu_marker_search_cb },
-  { MT_CALLBACK, 0, "MAXIMUM", menu_marker_search_cb },
-  { MT_CALLBACK, 0, "MINIMUM", menu_marker_search_cb },
-  { MT_CALLBACK, 0, "\2SEARCH\0" S_LARROW" LEFT", menu_marker_search_cb },
-  { MT_CALLBACK, 0, "\2SEARCH\0" S_RARROW" RIGHT", menu_marker_search_cb },
-  { MT_CALLBACK, 0, "TRACKING", menu_marker_search_cb },
+  { MT_CALLBACK, 0, "MAXIMUM",                      menu_marker_search_cb },
+  { MT_CALLBACK, 1, "MINIMUM",                      menu_marker_search_cb },
+  { MT_CALLBACK, 2, "\2SEARCH\0" S_LARROW" LEFT",   menu_marker_search_cb },
+  { MT_CALLBACK, 3, "\2SEARCH\0" S_RARROW" RIGHT",  menu_marker_search_cb },
+  { MT_CALLBACK, 4, "TRACKING",                     menu_marker_search_cb },
   { MT_CANCEL, 0, S_LARROW" BACK", NULL },
   { MT_NONE, 0, NULL, NULL } // sentinel
 };
 
 static const menuitem_t menu_marker_sel[] = {
-  { MT_CALLBACK, 0, "MARKER 1",     menu_marker_sel_cb},
-  { MT_CALLBACK, 0, "MARKER 2",     menu_marker_sel_cb},
-  { MT_CALLBACK, 0, "MARKER 3",     menu_marker_sel_cb},
-  { MT_CALLBACK, 0, "MARKER 4",     menu_marker_sel_cb},
-  { MT_CALLBACK, 0, "ALL OFF",      menu_marker_sel_cb},
+  { MT_CALLBACK, 0, "MARKER 1",             menu_marker_sel_cb},
+  { MT_CALLBACK, 0, "MARKER 2",             menu_marker_sel_cb},
+  { MT_CALLBACK, 0, "MARKER 3",             menu_marker_sel_cb},
+  { MT_CALLBACK, 0, "MARKER 4",             menu_marker_sel_cb},
+  { MT_CALLBACK, 0, "ALL OFF",              menu_marker_sel_cb},
   { MT_SUBMENU,  0, "\2SEARCH\0MARKER",     menu_marker_search},
   { MT_CANCEL,   0, S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
@@ -730,8 +654,8 @@ static const menuitem_t menu_marker[] = {
 };
 
 static const menuitem_t menu_dfu[] = {
-  { MT_FORM | MT_CALLBACK, 0, "ENTER DFU", menu_dfu_cb},
-  { MT_FORM | MT_CANCEL,   0, S_LARROW" BACK", NULL },
+  { MT_FORM | MT_CALLBACK, 0, "ENTER DFU",      menu_dfu_cb},
+  { MT_FORM | MT_CANCEL,   0, S_LARROW" BACK",  NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
 };
 
@@ -746,10 +670,10 @@ static const menuitem_t menu_settings2[] =
 
 static const menuitem_t menu_settings[] =
 {
-  { MT_CALLBACK, KM_ACTUALPOWER,    "\2ACTUAL\0POWER",  menu_settings_cb},
-  { MT_CALLBACK, KM_IF,             "\2IF\0FREQ",       menu_settings_cb},
-  { MT_CALLBACK, KM_SAMPLETIME,     "\2SAMPLE\0TIME",   menu_settings_cb},
-  { MT_CALLBACK, KM_DRIVE,          "\2LO\0DRIVE",      menu_settings_cb},
+  { MT_KEYPAD, KM_ACTUALPOWER,    "\2ACTUAL\0POWER",  NULL},
+  { MT_KEYPAD, KM_IF,             "\2IF\0FREQ",       NULL},
+  { MT_KEYPAD, KM_SAMPLETIME,     "\2SAMPLE\0TIME",   NULL},
+  { MT_SUBMENU,0,                 "\2LO\0DRIVE",      menu_drive},
   { MT_SUBMENU,  0,                 S_RARROW" MORE",    menu_settings2},
   { MT_CANCEL,   0,                 S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
@@ -766,8 +690,8 @@ static const menuitem_t menu_settingshigh2[] =
 
 static const menuitem_t menu_settingshigh[] =
 {
-  { MT_CALLBACK, KM_ACTUALPOWER,    "\2ACTUAL\0POWER",  menu_settings_cb},
-  { MT_CALLBACK, KM_SAMPLETIME,     "\2SAMPLE\0TIME",   menu_settings_cb},
+  { MT_KEYPAD, KM_ACTUALPOWER,    "\2ACTUAL\0POWER",  NULL},
+  { MT_KEYPAD, KM_SAMPLETIME,     "\2SAMPLE\0TIME",   NULL},
   { MT_SUBMENU,  0,                 S_RARROW" MORE",    menu_settingshigh2},
   { MT_CANCEL,   0,                 S_LARROW" BACK", NULL },
   { MT_NONE,     0, NULL, NULL } // sentinel
@@ -853,13 +777,16 @@ int menu_is_form(const menuitem_t *menu)
 static void menu_item_modify_attribute(
     const menuitem_t *menu, int item, uint16_t *fg, uint16_t *bg)
 {
+  int mark = false;
   if (menu == menu_mode) {
-    if (item == GetMode()+1) {
+    if (item == GetMode()+1)  {
       *bg = DEFAULT_MENU_TEXT_COLOR;
       *fg = config.menu_normal_color;
     } else if (item == 5) {
       plot_printf(uistat.text, sizeof uistat.text, menu_reffer_text[get_refer_output()+1]);
     }
+  } else if (menu == menu_highoutputmode && item == 2) {
+      plot_printf(uistat.text, sizeof uistat.text, menu_drive_text[setting_drive]);
   } else if (menu == menu_lowoutputmode || menu == menu_highoutputmode) {
     if (item == 3) {
       plot_printf(uistat.text, sizeof uistat.text, menu_modulation_text[setting_modulation]);
@@ -902,6 +829,12 @@ static void menu_item_modify_attribute(
       *fg = config.menu_normal_color;
     }
 
+  } else if (menu == menu_drive || menu == menu_drive_wide) {
+    if (item == setting_drive){
+      *bg = DEFAULT_MENU_TEXT_COLOR;
+      *fg = config.menu_normal_color;
+    }
+
   } else if (menu == menu_storage) {
     if (item ==0 && GetStorage()){
       *bg = DEFAULT_MENU_TEXT_COLOR;
@@ -929,46 +862,15 @@ static void menu_item_modify_attribute(
       *fg = config.menu_normal_color;
     }
   }
+  if (mark) {
+    *bg = DEFAULT_MENU_TEXT_COLOR;
+    *fg = config.menu_normal_color;
+  }
   if (ui_mode == UI_MENU && menu_is_form(menu)) {
     //    if (item == 0)
     //      redraw_frame();
     if (item <= 1) {
-
       area_width = 0;
-#if 0
-      //    area_height = HEIGHT - 32;
-      int y = MENU_BUTTON_HEIGHT*item;
-      uint16_t bg = config.menu_normal_color;
-      uint16_t fg = DEFAULT_MENU_TEXT_COLOR;
-      //    ili9341_fill(320-MENU_BUTTON_WIDTH, y, MENU_BUTTON_WIDTH, MENU_BUTTON_HEIGHT-2, bg);
-      ili9341_set_foreground(fg);
-      ili9341_set_background(bg);
-      char buf[15];
-      ili9341_fill(50+25, y, 170, MENU_BUTTON_HEIGHT-2, bg);
-      if (menu == menu_lowoutputmode) {
-        switch (item) {
-        case 0:
-          set_sweep_frequency(ST_SPAN, 0);          // For CW sweep mode
-          plot_printf(buf, sizeof buf, "%3.3fMHz", frequency0 / 1000000.0);
-          break;
-        case 1:
-          plot_printf(buf, sizeof buf, "%ddB", -10 - setting_attenuate);
-          break;
-        }
-      }
-      if (menu == menu_highoutputmode) {
-        switch (item) {
-        case 0:
-          set_sweep_frequency(ST_SPAN, 0);          // For CW sweep mode
-          plot_printf(buf, sizeof buf, "%3.3fMHz", frequency0 / 1000000.0);
-          break;
-        case 1:
-          plot_printf(buf, sizeof buf, "%ddB", -10 - setting_drive);
-          break;
-        }
-      }
-      ili9341_drawstring_size(buf, 130, y+6, 2);
-#endif
     }
   }else{
     area_width = AREA_WIDTH_NORMAL - MENU_BUTTON_WIDTH;