diff --git a/bochs/bochs.h b/bochs/bochs.h
index 5af8243cc..4cdc492f7 100644
--- a/bochs/bochs.h
+++ b/bochs/bochs.h
@@ -629,7 +629,7 @@ typedef struct {
   } bx_sb16_options;
 
 #define BX_BOOT_FLOPPYA 0
-#define BX_BOOT_DISKC 0x80
+#define BX_BOOT_DISKC   1
 
 typedef struct {
   bx_floppy_options floppya;
diff --git a/bochs/gui/control.cc b/bochs/gui/control.cc
index 1155548cf..f74975f2b 100644
--- a/bochs/gui/control.cc
+++ b/bochs/gui/control.cc
@@ -1,6 +1,6 @@
 /*
  * gui/control.cc
- * $Id: control.cc,v 1.24 2001-06-20 14:01:39 bdenney Exp $
+ * $Id: control.cc,v 1.25 2001-06-21 14:37:55 bdenney Exp $
  *
  * This is code for a text-mode control panel.  Note that this file
  * does NOT include bochs.h.  Instead, it does all of its contact with
@@ -73,19 +73,9 @@ extern "C" {
 
 /* functions for changing particular options */
 void bx_control_panel_init ();
-void bx_edit_floppy (int drive);
-void bx_edit_hard_disk (int drive);
-void bx_edit_cdrom ();
-void bx_newhd_support ();
-void bx_private_colormap ();
-void bx_boot_from ();
-void bx_ips_change ();
 int bx_read_rc (char *rc);
 int bx_write_rc (char *rc);
-void bx_log_file ();
 void bx_log_options (int individual);
-void bx_vga_update_interval ();
-void bx_mouse_enable ();
 
 /******************************************************************/
 /* lots of code stolen from bximage.c */
@@ -286,45 +276,6 @@ static char *startup_options_prompt =
 "\n"
 "Please choose one: [0] ";
 
-static char *startup_mem_options_prompt =
-"--------------------\n"
-"Bochs Memory Options\n"
-"--------------------\n"
-"0. Return to previous menu\n"
-"1. Memory in Megabytes: %d\n"
-"2. VGA ROM image: %s\n"
-"3. ROM image: %s\n"
-"4. ROM address: 0x%05x\n"
-"\n"
-"Please choose one: [0] ";
-
-static char *startup_interface_options =
-"------------------\n"
-"Bochs Interface Options\n"
-"------------------\n"
-"0. Return to previous menu\n"
-"1. VGA Update Interval: %d\n"
-"2. Mouse: %s\n"
-"3. Emulated instructions per second (IPS): %u\n"
-"4. Private Colormap: %s\n"
-"\n"
-"Please choose one: [0] ";
-
-static char *startup_disk_options_prompt =
-"------------------\n"
-"Bochs Disk Options\n"
-"------------------\n"
-"0. Return to previous menu\n"
-"1. Floppy disk 0: %s\n"
-"2. Floppy disk 1: %s\n"
-"3. Hard disk 0: %s\n"
-"4. Hard disk 1: %s\n"
-"5. CDROM: %s\n"
-"6. New Hard Drive Support: %s\n"
-"7. Boot from: %s\n"
-"%s\n"
-"Please choose one: [0] ";
-
 static char *startup_sound_options_prompt =
 "------------------\n"
 "Bochs Sound Options\n"
@@ -373,9 +324,9 @@ char *menu_prompt_list[BX_CPANEL_N_MENUS] = {
   ask_about_control_panel,
   startup_menu_prompt,
   startup_options_prompt,
-  startup_mem_options_prompt,
-  startup_interface_options,
-  startup_disk_options_prompt,
+  NULL,
+  NULL,
+  NULL,
   startup_sound_options_prompt,
   startup_misc_options_prompt,
   runtime_menu_prompt
@@ -388,41 +339,6 @@ char *menu_prompt_list[BX_CPANEL_N_MENUS] = {
   do {fprintf (stderr, "ERROR: control panel menu %d has no choice %d\n", menu, choice); \
       assert (0); } while (0)
 
-char *fdsize_choices[] = { "0.72","1.2","1.44","2.88" };
-int fdsize_n_choices = 4;
-
-void build_disk_options_prompt (char *format, char *buf, int size)
-{
-  bx_floppy_options floppyop;
-  bx_disk_options diskop;
-  bx_cdrom_options cdromop;
-  char buffer[7][128];
-  for (int i=0; i<2; i++) {
-    SIM->get_floppy_options (i, &floppyop);
-    sprintf (buffer[i], "%s, size=%s, %s", floppyop.Opath->getptr (),
-	  SIM->get_floppy_type_name (floppyop.Otype->get ()),
-	  floppyop.Oinitial_status->get () ? "inserted" : "ejected");
-    if (!floppyop.Opath->getptr()[0]) strcpy (buffer[i], "none");
-    SIM->get_disk_options (i, &diskop);
-    sprintf (buffer[2+i], "%s, %d cylinders, %d heads, %d sectors/track", 
-	diskop.Opath->getptr (), diskop.Ocylinders->get (), 
-	diskop.Oheads->get (), diskop.Ospt->get ());
-    if (!diskop.Opresent->get ()) strcpy (buffer[2+i], "none");
-  }
-  SIM->get_cdrom_options (0, &cdromop);
-  sprintf (buffer[4], "%s, %spresent, %s",
-     cdromop.Opath->getptr (), cdromop.Opresent->get ()?"":"not ",
-     cdromop.Oinserted?"inserted":"ejected");
-  if (!cdromop.Opath->getptr()[0]) strcpy (buffer[4], "none");
-  sprintf (buffer[5], "%s", SIM->get_newhd_support () ? "yes":"no");
-  sprintf (buffer[6], "%s", SIM->get_boot_hard_disk () ? "hard drive":"floppy drive");
-  // check if diskd and cdromd are on at once
-  SIM->get_disk_options (1, &diskop);
-  int conflict = (diskop.Opresent->get () && cdromop.Opresent->get ());
-  char *diskd_cdromd_conflict_msg = "\nERROR:\nThis configuration has both a cdrom and a hard disk enabled.\nYou cannot have both!";
-  snprintf (buf, size, format, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], conflict? diskd_cdromd_conflict_msg : "");
-}
-
 void build_runtime_options_prompt (char *format, char *buf, int size)
 {
   bx_floppy_options floppyop;
@@ -446,8 +362,8 @@ void build_runtime_options_prompt (char *format, char *buf, int size)
       SIM->get_param_num (BXP_MOUSE_ENABLED)->get () ? "enabled" : "disabled");
 }
 
-int do_mem_options_menu () {
-  bx_list_c *menu = (bx_list_c *)SIM->get_param (BXP_MEMORY_OPTIONS_MENU);
+int do_menu (bx_id id) {
+  bx_list_c *menu = (bx_list_c *)SIM->get_param (id);
   while (1) {
     menu->get_choice()->set (0);
     int status = menu->text_ask (stdin, stderr);
@@ -464,6 +380,12 @@ int do_mem_options_menu () {
   }
 }
 
+void askparam (bx_id id)
+{
+  bx_param_c *param = SIM->get_param (id);
+  param->text_ask (stdin, stderr);
+}
+
 // return value of bx_control_panel:
 //   -1: error while reading, like if stdin closed
 //    0: no error
@@ -508,11 +430,11 @@ int bx_control_panel (int menu)
        if (ask_uint (prompt, 0, 8, 0, &choice, 10) < 0) return -1;
        switch (choice) {
 	 case 0: return 0;
-	 case 1: bx_log_file (); break;
+	 case 1: askparam (BXP_LOG_FILENAME); break;
 	 case 2: bx_log_options (0); break;
 	 case 3: bx_log_options (1); break;
-	 case 4: bx_control_panel (BX_CPANEL_START_OPTS_MEM); break;
-	 case 5: bx_control_panel (BX_CPANEL_START_OPTS_INTERFACE); break;
+	 case 4: bx_control_panel (BXP_MENU_MEMORY); break;
+	 case 5: bx_control_panel (BXP_MENU_INTERFACE); break;
 	 case 6: bx_control_panel (BX_CPANEL_START_OPTS_DISK); break;
 	 case 7: bx_control_panel (BX_CPANEL_START_OPTS_SOUND); break;
 	 case 8: bx_control_panel (BX_CPANEL_START_OPTS_MISC); break;
@@ -520,60 +442,25 @@ int bx_control_panel (int menu)
        }
      }
      break;
-   case BX_CPANEL_START_OPTS_MEM:
-     return do_mem_options_menu ();
-   case BX_CPANEL_START_OPTS_INTERFACE:
-     {
-       char prompt[1024];
-       int interval = SIM->get_param_num (BXP_VGA_UPDATE_INTERVAL)->get ();
-       bx_param_num_c *ips = SIM->get_param_num (BXP_IPS);
-       sprintf (prompt, startup_interface_options, 
-	 interval, 
-	 SIM->get_param_num (BXP_MOUSE_ENABLED)->get () ? "enabled" : "disabled",
-	 ips->get (),
-	 SIM->get_private_colormap () ? "enabled" : "disabled");
-       if (ask_uint (prompt, 0, 4, 0, &choice, 10) < 0) return -1;
-       switch (choice) {
-	 case 0: return 0;
-	 case 1: bx_vga_update_interval (); break;
-	 case 2: bx_mouse_enable (); break;
-	 case 3: bx_ips_change (); break;
-	 case 4: bx_private_colormap (); break;
-	 default: BAD_OPTION(menu, choice);
-       }
-     }
-     break;
+   case BXP_MENU_MEMORY:
+     return do_menu (BXP_MENU_MEMORY);
+   case BXP_MENU_INTERFACE:
+     return do_menu (BXP_MENU_INTERFACE);
    case BX_CPANEL_START_OPTS_DISK:
-     {
-       char prompt[1024];
-       build_disk_options_prompt (startup_disk_options_prompt, prompt, 1024);
-       if (ask_uint (prompt, 0, 7, 0, &choice, 10) < 0) return -1;
-       switch (choice) {
-	 case 0: return 0;
-	 case 1: bx_edit_floppy (0); break;
-	 case 2: bx_edit_floppy (1); break;
-	 case 3: bx_edit_hard_disk (0); break;
-	 case 4: bx_edit_hard_disk (1); break;
-	 case 5: bx_edit_cdrom (); break;
-	 case 6: bx_newhd_support (); break;
-	 case 7: bx_boot_from (); break;
-	 default: BAD_OPTION(menu, choice);
-       }
-     }
-   break;
+     return do_menu (BXP_MENU_DISK);
    case BX_CPANEL_RUNTIME:
      char prompt[1024];
      build_runtime_options_prompt (runtime_menu_prompt, prompt, 1024);
      if (ask_uint (prompt, 1, 11, 10, &choice, 10) < 0) return -1;
      switch (choice) {
-       case 1: bx_edit_floppy (0); break;
-       case 2: bx_edit_floppy (1); break;
-       case 3: bx_edit_cdrom (); break;
-       case 4: bx_ips_change (); break;
+       case 1: do_menu (BXP_FLOPPYA); break;
+       case 2: do_menu (BXP_FLOPPYB); break;
+       case 3: do_menu (BXP_CDROMD); break;
+       case 4: askparam (BXP_IPS); break;
        case 5: bx_log_options (0); break;
        case 6: bx_log_options (1); break;
-       case 7: bx_vga_update_interval (); break;
-       case 8: bx_mouse_enable (); break;
+       case 7: askparam (BXP_VGA_UPDATE_INTERVAL); break;
+       case 8: askparam (BXP_MOUSE_ENABLED); break;
        case 9: NOT_IMPLEMENTED (choice); break;
        case 10: fprintf (stderr, "Continuing simulation\n"); return 0;
        case 11:
@@ -593,122 +480,6 @@ int bx_control_panel (int menu)
  }
 }
 
-void bx_edit_floppy (int drive)
-{
-  bx_floppy_options opt, newopt;
-  assert (SIM->get_floppy_options (drive, &opt) >= 0);
-  newopt = opt;
-  fprintf (stderr, "Changing options for floppy drive %d\n", drive);
-  char the_default[512];
-  opt.Opath->get (the_default, sizeof(the_default));
-  if (ask_string ("Enter new pathname: [%s] ", the_default, newopt.Opath->getptr ()) < 0)
-    return;
-  int newtype, oldtype = opt.Otype->get () - BX_FLOPPY_NONE;
-  if (ask_menu ("What is the floppy disk size?\nChoices are 720K, 1.2M, 1.44M, 2.88M.  [%s] ", n_floppy_type_names, floppy_type_names, oldtype, &newtype) < 0) return;
-  newopt.Otype->set (newtype + BX_FLOPPY_NONE);
-  if (SIM->set_floppy_options (drive, &newopt) < 0) {
-    fprintf (stderr, "The disk image %s could not be opened.\n", newopt.Opath->getptr ());
-  }
-}
-
-void bx_edit_hard_disk (int drive)
-{
-  bx_disk_options opt, newopt;
-  assert (SIM->get_disk_options (drive, &opt) >= 0);
-  newopt = opt;
-  fprintf (stderr, "Changing options for hard drive %d\n", drive);
-  char buf[512];
-  opt.Opath->get (buf, sizeof (buf));
-  if (ask_string ("Enter new pathname, or type 'none' for no disk: [%s] ", buf, newopt.Opath->getptr ()) < 0)
-    return;
-  newopt.Opresent->set (strcmp (newopt.Opath->getptr (), "none") != 0);
-  if (newopt.Opresent->get ()) {  // skip if "none" is the path.
-    // ask cyl, head, sec.
-    Bit32u n;
-    if (ask_uint ("How many cylinders? [%d] ", 1, 65535, opt.Ocylinders->get (), &n, 10) < 0)
-      return;
-    newopt.Ocylinders->set (n);
-    if (ask_uint ("How many heads? [%d] ", 1, 256, opt.Oheads->get (), &n, 10) < 0)
-      return;
-    newopt.Oheads->set (n);
-    if (ask_uint ("How many sectors per track? [%d] ", 1, 255, opt.Ospt->get (), &n, 10) < 0)
-      return;
-    newopt.Ospt->set (n);
-  }
-  if (SIM->set_disk_options (drive, &newopt) < 0) {
-    fprintf (stderr, "The disk image %s could not be opened.\n", newopt.Opath->getptr ());
-  }
-}
-
-void bx_edit_cdrom ()
-{
-  bx_cdrom_options opt, newopt;
-  assert (SIM->get_cdrom_options (0, &opt) >= 0);
-  newopt = opt;
-  newopt.Opresent->set (1);
-  char buf[512];
-  opt.Opath->get (buf, sizeof (buf));
-  if (ask_string ("Enter pathname of the cdrom device, or 'none' for no cdrom: [%s] ", buf, newopt.Opath->getptr ()) < 0)
-    return;
-  if (!strcmp (newopt.Opath->getptr (), "none")) {
-    newopt.Opath->getptr ()[0] = 0;
-    newopt.Opresent->set (0);
-  }
-  if (SIM->set_cdrom_options (0, &newopt) < 0) {
-    fprintf (stderr, "The device at %s could not be opened.\n", newopt.Opath->getptr ());
-  }
-}
-
-void bx_newhd_support ()
-{
-  Bit32u newval, oldval = SIM->get_newhd_support ();
-  if (ask_yn ("Use new hard disk support (recommended)? [%s] ", oldval, &newval) < 0) return;
-  if (newval == oldval) return;
-  SIM->set_newhd_support (newval);
-}
-
-void bx_private_colormap ()
-{
-  Bit32u newval, oldval = SIM->get_private_colormap ();
-  if (ask_yn ("Use private colormap? [%s] ", oldval, &newval) < 0) return;
-  if (newval == oldval) return;
-  SIM->set_private_colormap (newval);
-}
-
-
-void bx_boot_from ()
-{
-  int newval, oldval = SIM->get_boot_hard_disk ();
-  char *choices[] = {"fd","hd"};
-  if (ask_menu ("Boot floppy disk or hard disk?  Type hd or fd. [%s] ",
-	 2, choices, oldval, &newval) < 0) return;
-  SIM->set_boot_hard_disk (newval);
-}
-
-void bx_ips_change ()
-{
-  char prompt[1024];
-  bx_param_num_c *ips = SIM->get_param_num (BXP_IPS);
-  Bit32u oldips = ips->get ();
-  sprintf (prompt, "Type a new value for ips: [%d] ", oldips);
-  Bit32u newips;
-  if (ask_uint (prompt, 1, 1<<30, oldips, &newips, 10) < 0)
-    return;
-  ips->set (newips);
-}
-
-void bx_vga_update_interval ()
-{
-  char prompt[1024];
-  bx_param_num_c *pinterval = SIM->get_param_num (BXP_VGA_UPDATE_INTERVAL);
-  Bit32u old = pinterval->get ();
-  sprintf (prompt, "Type a new value for VGA update interval: [%d] ", old);
-  Bit32u newinterval;
-  if (ask_uint (prompt, 1, 1<<30, old, &newinterval, 10) < 0)
-    return;
-  pinterval->set (newinterval);
-}
-
 static void bx_print_log_action_table ()
 {
   // just try to print all the prefixes first.
@@ -770,15 +541,6 @@ void bx_log_options (int individual)
   }
 }
 
-void bx_mouse_enable ()
-{
-  bx_param_num_c *mouse_en = SIM->get_param_num (BXP_MOUSE_ENABLED);
-  Bit32u newval, oldval = mouse_en->get ();
-  if (ask_yn ("Enable the mouse? [%s] ", oldval, &newval) < 0) return;
-  if (newval == oldval) return;
-  mouse_en->set (newval);
-}
-
 int bx_read_rc (char *rc)
 {
   if (rc && SIM->read_rc (rc) >= 0) return 0;
@@ -830,14 +592,6 @@ int bx_write_rc (char *rc)
   }
 }
 
-void bx_log_file ()
-{
-  char oldpath[CPANEL_PATH_LEN], newpath[CPANEL_PATH_LEN];
-  assert (SIM->get_log_file (oldpath, CPANEL_PATH_LEN) >= 0);
-  if (ask_string ("Enter log file name: [%s] ", oldpath, newpath) < 0) return;
-  SIM->set_log_file (newpath);
-}
-
 /*
 A panic has occurred.  Do you want to:
   cont       - continue execution
@@ -896,9 +650,8 @@ bx_param_num_c::text_print (FILE *fp)
   //fprintf (fp, "value=%u\n", get ());
   if (get_format ()) {
     fprintf (fp, get_format (), get ());
-    fprintf (fp, "\n");
   } else {
-    char *format = "%s: %d\n"; 
+    char *format = "%s: %d"; 
     assert (base==10 || base==16);
     if (base==16) format = "%s: 0x%x\n";
     fprintf (fp, format, get_name (), get ());
@@ -909,10 +662,23 @@ void
 bx_param_bool_c::text_print (FILE *fp)
 {
   if (get_format ()) {
-    fprintf (fp, get_format (), get ());
-    fprintf (fp, "\n");
+    fprintf (fp, get_format (), get () ? "yes" : "no");
   } else {
-    char *format = "%s: %s\n"; 
+    char *format = "%s: %s"; 
+    fprintf (fp, format, get_name (), get () ? "yes" : "no");
+  }
+}
+
+void
+bx_param_enum_c::text_print (FILE *fp)
+{
+  int n = get ();
+  assert (n >= min && n <= max);
+  char *choice = choices[n - min];
+  if (get_format ()) {
+    fprintf (fp, get_format (), choice);
+  } else {
+    char *format = "%s: %s"; 
     fprintf (fp, format, get_name (), get () ? "yes" : "no");
   }
 }
@@ -924,25 +690,31 @@ bx_param_string_c::text_print (FILE *fp)
   //fprintf (fp, "value=%s\n", getptr ());
   if (get_format ()) {
     fprintf (fp, get_format (), getptr ());
-    fprintf (fp, "\n");
   } else {
-    fprintf (fp, "%s: %s\n", get_name (), getptr ());
+    fprintf (fp, "%s: %s", get_name (), getptr ());
   }
 }
 
 void
 bx_list_c::text_print (FILE *fp)
 {
-  fprintf (fp, "This is a list.\n");
-  fprintf (fp, "title=%s\n", title->getptr ());
+  //fprintf (fp, "This is a list.\n");
+  //fprintf (fp, "title=%s\n", title->getptr ());
+  fprintf (fp, "%s: ", get_name ());
+  /*
   fprintf (fp, "options=%s%s%s\n", 
       (options->get () == 0) ? "none" : "",
       (options->get () & BX_SHOW_PARENT) ? "SHOW_PARENT " : "",
       (options->get () & BX_SERIES_ASK) ? "SERIES_ASK " : "");
+      */
   for (int i=0; i<size; i++) {
-    fprintf (fp, "param[%d] = %p\n", i, list[i]);
-    if (list[i])
+    //fprintf (fp, "param[%d] = %p\n", i, list[i]);
+    assert (list[i] != NULL);
+    if (list[i]->get_enabled ()) {
       list[i]->text_print (fp);
+      if (!options->get () & BX_SERIES_ASK)
+        fprintf (fp, "\n");
+    }
   }
 }
 
@@ -955,6 +727,7 @@ bx_param_num_c::text_ask (FILE *fpin, FILE *fpout)
   if (prompt == NULL) {
     // default prompt, if they didn't set an ask format string
     text_print (fpout);
+    fprintf (fpout, "\n");
     prompt = "Enter new value: [%d] ";
     if (base==16)
       prompt = "Enter new value in hex: [%x] ";
@@ -974,7 +747,9 @@ bx_param_bool_c::text_ask (FILE *fpin, FILE *fpout)
   char *prompt = get_ask_format ();
   if (prompt == NULL) {
     // default prompt, if they didn't set an ask format string
-    prompt = "Set %s to: [%s] ";
+    char buffer[512];
+    sprintf (buffer, "%s? [%%s] ", get_name ());
+    prompt = buffer;
   }
   Bit32u n = get ();
   status = ask_yn (prompt, n, &n);
@@ -983,6 +758,26 @@ bx_param_bool_c::text_ask (FILE *fpin, FILE *fpout)
   return 0;
 }
 
+int 
+bx_param_enum_c::text_ask (FILE *fpin, FILE *fpout)
+{
+  fprintf (fpout, "\n");
+  char *prompt = get_ask_format ();
+  if (prompt == NULL) {
+    // default prompt, if they didn't set an ask format string
+    char buffer[512];
+    fprintf (fpout, "%s = ", get_name ());
+    text_print (fpout);
+    fprintf (fpout, "\n");
+    prompt = "Enter new value: [%s] ";
+  }
+  Bit32s n = get () - min;
+  int status = ask_menu (prompt, (max-min+1), choices, n, &n);
+  if (status < 0) return status;
+  n += min;
+  set (n);
+  return 0;
+}
 
 int 
 bx_param_string_c::text_ask (FILE *fpin, FILE *fpout)
@@ -993,6 +788,7 @@ bx_param_string_c::text_ask (FILE *fpin, FILE *fpout)
   if (prompt == NULL) {
     // default prompt, if they didn't set an ask format string
     text_print (fpout);
+    fprintf (fpout, "\n");
     prompt = "Enter a new value, or press return for no change.\n";
   }
   //FIXME
@@ -1006,27 +802,38 @@ bx_param_string_c::text_ask (FILE *fpin, FILE *fpout)
 int
 bx_list_c::text_ask (FILE *fpin, FILE *fpout)
 {
+  char *my_title = title->getptr ();
   fprintf (fpout, "\n");
-  int i, imax = strlen (title->getptr ());
+  int i, imax = strlen (my_title);
   for (i=0; i<imax; i++) fprintf (fpout, "-");
-  fprintf (fpout, "\n%s\n", title->getptr ());
+  fprintf (fpout, "\n%s\n", my_title);
   for (i=0; i<imax; i++) fprintf (fpout, "-");
-  fprintf (fpout, "\n");
-  //fprintf (fp, "options=%s\n", options->get ());
-  if (options->get () & BX_SHOW_PARENT)
-    fprintf (fpout, "0. Return to previous menu\n");
-  for (int i=0; i<size; i++) {
-    assert (list[i] != NULL);
-    fprintf (fpout, "%d. ", i+1);
-    list[i]->text_print (fpout);
-  }
+  fprintf (fpout, "\n"); //fprintf (fp, "options=%s\n", options->get ());
+  if (options->get () & BX_SERIES_ASK) {
+    for (int i=0; i<size; i++) {
+      if (list[i]->get_enabled ())
+        list[i]->text_ask (fpin, fpout);
+    }
+  } else {
+    if (options->get () & BX_SHOW_PARENT)
+      fprintf (fpout, "0. Return to previous menu\n");
+    for (int i=0; i<size; i++) {
+      assert (list[i] != NULL);
+      fprintf (fpout, "%d. ", i+1);
+      if (list[i]->get_enabled ()) {
+        list[i]->text_print (fpout);
+	fprintf (fpout, "\n");
+      } else
+	fprintf (fpout, "(disabled)\n");
+    }
     fprintf (fpout, "\n");
-  Bit32u n = choice->get ();
-  int min = (options->get () & BX_SHOW_PARENT) ? 0 : 1;
-  int max = size;
-  int status = ask_uint ("Please choose one: [%d] ", min, max, n, &n, 10);
-  if (status < 0) return status;
-  choice->set (n);
+    Bit32u n = choice->get ();
+    int min = (options->get () & BX_SHOW_PARENT) ? 0 : 1;
+    int max = size;
+    int status = ask_uint ("Please choose one: [%d] ", min, max, n, &n, 10);
+    if (status < 0) return status;
+    choice->set (n);
+  }
   return 0;
 }
 
diff --git a/bochs/gui/siminterface.cc b/bochs/gui/siminterface.cc
index d185fbd76..42bf69f2e 100644
--- a/bochs/gui/siminterface.cc
+++ b/bochs/gui/siminterface.cc
@@ -1,6 +1,6 @@
 /*
  * gui/siminterface.cc
- * $Id: siminterface.cc,v 1.24 2001-06-20 14:01:39 bdenney Exp $
+ * $Id: siminterface.cc,v 1.25 2001-06-21 14:37:55 bdenney Exp $
  *
  * Defines the actual link between bx_simulator_interface_c methods
  * and the simulator.  This file includes bochs.h because it needs
@@ -87,7 +87,7 @@ bx_real_sim_c::get_param_num (bx_id id) {
     return NULL;
   }
   int type = generic->get_type ();
-  if (type == BXT_PARAM_NUM || type == BXT_PARAM_BOOL)
+  if (type == BXT_PARAM_NUM || type == BXT_PARAM_BOOL || type == BXT_PARAM_ENUM)
     return (bx_param_num_c *)generic;
   BX_PANIC (("get_param_num %u could not find an integer parameter with that id", id));
   return NULL;
@@ -308,6 +308,8 @@ char *floppy_type_names[] = { "none", "1.2M", "1.44M", "2.88M", "720K", NULL };
 int n_floppy_type_names = 5;
 char *floppy_status_names[] = { "ejected", "inserted", NULL };
 int n_floppy_status_names = 2;
+char *floppy_bootdisk_names[] = { "floppy", "hard", NULL };
+int n_floppy_bootdisk_names = 2;
 
 char *
 bx_real_sim_c::get_floppy_type_name (int type)
@@ -437,6 +439,7 @@ bx_param_c::bx_param_c (bx_id id, char *name, char *description)
   this->text_format = NULL;
   this->ask_format = NULL;
   this->runtime_param = 0;
+  this->enabled = 1;
   SIM->register_param (id, this);
 }
 
@@ -453,6 +456,7 @@ bx_param_num_c::bx_param_num_c (bx_id id,
   this->val = initial_val;
   this->handler = NULL;
   this->base = 10;
+  set (initial_val);
 }
 
 void 
@@ -461,6 +465,14 @@ bx_param_num_c::reset ()
   this->val = initial_val;
 }
 
+void 
+bx_param_num_c::set_handler (param_event_handler handler)
+{ 
+  this->handler = handler; 
+  // now that there's a handler, call set once to run the handler immediately
+  //set (get ());
+}
+
 Bit32s 
 bx_param_num_c::get ()
 {
@@ -483,6 +495,8 @@ bx_param_num_c::set (Bit32s newval)
     // just set the value.  This code does not check max/min.
     val = newval;
   }
+  if (val < min || val > max) 
+    BX_PANIC (("numerical parameter %s was set to %d, which is out of range %d to %d", get_name (), val, min, max));
 }
 
 bx_param_bool_c::bx_param_bool_c (bx_id id,
@@ -492,6 +506,7 @@ bx_param_bool_c::bx_param_bool_c (bx_id id,
   : bx_param_num_c (id, name, description, 0, 1, initial_val)
 {
   set_type (BXT_PARAM_BOOL);
+  set (initial_val);
 }
 
 bx_param_enum_c::bx_param_enum_c (bx_id id, 
@@ -502,12 +517,16 @@ bx_param_enum_c::bx_param_enum_c (bx_id id,
       Bit32s value_base)
   : bx_param_num_c (id, name, description, value_base, BX_MAX_INT, initial_val)
 {
+  set_type (BXT_PARAM_ENUM);
   this->choices = choices;
-  this->value_base = value_base;
   // count number of choices, set max
   char **p = choices;
   while (*p != NULL) p++;
+  this->min = value_base;
+  // now that the max is known, replace the BX_MAX_INT sent to the parent
+  // class constructor with the real max.
   this->max = value_base + (p - choices - 1);
+  set (initial_val);
 }
 
 bx_param_string_c::bx_param_string_c (bx_id id,
@@ -526,6 +545,7 @@ bx_param_string_c::bx_param_string_c (bx_id id,
   this->maxsize = maxsize;
   strncpy (this->val, initial_val, maxsize);
   strncpy (this->initial_val, initial_val, maxsize);
+  set (initial_val);
 }
 
 void 
@@ -533,25 +553,37 @@ bx_param_string_c::reset () {
   strncpy (this->val, this->initial_val, maxsize);
 }
 
+void 
+bx_param_string_c::set_handler (param_string_event_handler handler)
+{
+  this->handler = handler; 
+  // now that there's a handler, call set once to run the handler immediately
+  //set (getptr ());
+}
+
 Bit32s
 bx_param_string_c::get (char *buf, int len)
 {
-  if (handler)
+  strncpy (buf, val, len);
+  if (handler) {
+    // the handler can choose to replace the value in val/len.  Also its
+    // return value is passed back as the return value of get.
     (*handler)(this, 0, buf, len);
-  else
-    strncpy (buf, val, len);
+  }
   return 0;
 }
 
 void 
 bx_param_string_c::set (char *buf)
 {
-  if (handler)
-    (*handler)(this, 1, buf, -1);
-  else
-    strncpy (val, buf, maxsize);
+  if (handler) {
+    // the handler can return a different char* to be copied into the value
+    buf = (*handler)(this, 1, buf, -1);
+  }
+  strncpy (val, buf, maxsize);
 }
 
+#if 0
 bx_list_c::bx_list_c (bx_id id, int maxsize)
   : bx_param_c (id, "list", "")
 {
@@ -561,9 +593,10 @@ bx_list_c::bx_list_c (bx_id id, int maxsize)
   this->list = new bx_param_c*  [maxsize];
   init ();
 }
+#endif
 
-bx_list_c::bx_list_c (bx_id id, bx_param_c **init_list)
-  : bx_param_c (id, "list", "")
+bx_list_c::bx_list_c (bx_id id, char *name, char *description, bx_param_c **init_list)
+  : bx_param_c (id, name, description)
 {
   set_type (BXT_LIST);
   this->size = 0;
@@ -579,15 +612,16 @@ bx_list_c::bx_list_c (bx_id id, bx_param_c **init_list)
 void
 bx_list_c::init ()
 {
-  this->title = new bx_param_string_c (BXP_LIST_TITLE,
-      "list_title",
-      "title of the bx_list",
-      "list", 80);
-  this->options = new bx_param_num_c (BXP_LIST_OPTIONS,
-      "list_option", "", 0, 1<<31,
+  // the title defaults to the name
+  this->title = new bx_param_string_c (BXP_NULL,
+      "title of list",
+      "",
+      get_name (), 80);
+  this->options = new bx_param_num_c (BXP_NULL,
+      "list_option", "", 0, BX_MAX_INT,
       0);
-  this->choice = new bx_param_num_c (BXP_LIST_CHOICE,
-      "list_choice", "", 0, 1<<31,
+  this->choice = new bx_param_num_c (BXP_NULL,
+      "list_choice", "", 0, BX_MAX_INT,
       1);
   this->parent = NULL;
 }
diff --git a/bochs/gui/siminterface.h b/bochs/gui/siminterface.h
index 237b6fc63..67df4667c 100644
--- a/bochs/gui/siminterface.h
+++ b/bochs/gui/siminterface.h
@@ -1,6 +1,6 @@
 /*
  * gui/siminterface.h
- * $Id: siminterface.h,v 1.14 2001-06-20 14:01:39 bdenney Exp $
+ * $Id: siminterface.h,v 1.15 2001-06-21 14:37:55 bdenney Exp $
  *
  * Interface to the simulator, currently only used by control.cc.
  * The base class bx_simulator_interface_c, contains only virtual functions
@@ -27,31 +27,32 @@ typedef enum {
   BXP_ROM_PATH,
   BXP_ROM_ADDRESS,
   BXP_VGA_ROM_PATH,
-  BXP_LIST_TITLE,      //title field in any bx_list
-  BXP_LIST_OPTIONS,    //options field in any bx_list
-  BXP_LIST_CHOICE,     //choice field in any bx_list
-  BXP_MEMORY_OPTIONS_MENU,
   BXP_KBD_SERIAL_DELAY,
   BXP_FLOPPY_CMD_DELAY,
   BXP_FLOPPYA_PATH,
   BXP_FLOPPYA_TYPE,
   BXP_FLOPPYA_STATUS,
+  BXP_FLOPPYA,
   BXP_FLOPPYB_PATH,
   BXP_FLOPPYB_TYPE,
   BXP_FLOPPYB_STATUS,
+  BXP_FLOPPYB,
   BXP_DISKC_PRESENT,
   BXP_DISKC_PATH,
   BXP_DISKC_CYLINDERS,
   BXP_DISKC_HEADS,
   BXP_DISKC_SPT,
+  BXP_DISKC,
   BXP_DISKD_PRESENT,
   BXP_DISKD_PATH,
   BXP_DISKD_CYLINDERS,
   BXP_DISKD_HEADS,
   BXP_DISKD_SPT,
+  BXP_DISKD,
   BXP_CDROM_PRESENT,
   BXP_CDROM_PATH,
   BXP_CDROM_INSERTED,
+  BXP_CDROMD,
   BXP_PRIVATE_COLORMAP,
   BXP_I440FX_SUPPORT,
   BXP_NEWHARDDRIVESUPPORT,
@@ -64,6 +65,13 @@ typedef enum {
   BXP_LOAD32BITOS_IOLOG,
   BXP_LOAD32BITOS_INITRD,
   BXP_BOOTDRIVE,
+  BXP_MENU_MAIN,
+  BXP_MENU_MEMORY,
+  BXP_MENU_INTERFACE,
+  BXP_MENU_DISK,
+  BXP_MENU_SOUND,
+  BXP_MENU_MISC,
+  BXP_MENU_RUNTIME,
   BXP_THIS_IS_THE_LAST    // used to determine length of list
 } bx_id;
 
@@ -78,26 +86,6 @@ typedef enum {
   BXT_LIST
 } bx_objtype;
 
-////////////////////////////////////////////////////////////////////
-
-// Abstract type. I haven't actually found a great use for this bx_any.
-
-struct bx_any {
-  Bit32u type;
-  union s {
-    int integer;
-    int boolean;
-    struct string {
-      char *val;
-      int alloc_len;
-    };
-    struct list {
-      Bit32u size;
-      bx_any *array;
-    };
-  };
-};
-
 ////////////////////////////////////////////////////////////////////
 class bx_object_c {
 private:
@@ -112,12 +100,13 @@ public:
 };
 
 class bx_param_c : public bx_object_c {
-private:
+protected:
   char *name;
   char *description;
   char *text_format;  // printf format string. %d for ints, %s for strings, etc.
   char *ask_format;  // format string for asking for a new value
   int runtime_param;
+  int enabled;
 public:
   bx_param_c (bx_id id,
       char *name,
@@ -129,6 +118,8 @@ public:
   void set_runtime_param (int val) { runtime_param = val; }
   char *get_name () { return name; }
   char *get_description () { return description; }
+  int get_enabled () { return enabled; }
+  void set_enabled (int enabled) { this->enabled = enabled; }
   void reset () {}
   int getint () {return -1;}
 #if BX_UI_TEXT
@@ -137,26 +128,6 @@ public:
 #endif
 };
 
-typedef Bit32s (*param_any_event_handler)(class bx_param_any_c *, int set, bx_any val);
-
-class bx_param_any_c : public bx_param_c {
-  bx_any min, max, val, initial_val;
-  param_any_event_handler handler;
-public:
-  bx_param_any_c (bx_id id,
-      char *name,
-      char *description,
-      bx_any min, bx_any max, bx_any initial_val);
-  bx_param_any_c (bx_id id,
-      char *name,
-      char *description,
-      bx_any initial_val);
-  void reset ();
-  void set_handler (param_any_event_handler handler) { this->handler = handler; }
-  bx_any get ();
-  void set (bx_any val);
-};
-
 typedef Bit32s (*param_event_handler)(class bx_param_c *, int set, Bit32s val);
 
 class bx_param_num_c : public bx_param_c {
@@ -170,7 +141,7 @@ public:
       char *description,
       Bit32s min, Bit32s max, Bit32s initial_val);
   void reset ();
-  void set_handler (param_event_handler handler) { this->handler = handler; }
+  void set_handler (param_event_handler handler);
   Bit32s get ();
   void set (Bit32s val);
   void set_base (int base) { this->base = base; }
@@ -193,7 +164,6 @@ public:
 };
 
 class bx_param_enum_c : public bx_param_num_c {
-  Bit32s value_base;
   char **choices;
 public:
   bx_param_enum_c (bx_id id, 
@@ -203,12 +173,12 @@ public:
       Bit32s initial_val,
       Bit32s value_base = 0);
 #if BX_UI_TEXT
-  //virtual void text_print (FILE *fp);
-  //virtual int text_ask (FILE *fpin, FILE *fpout);
+  virtual void text_print (FILE *fp);
+  virtual int text_ask (FILE *fpin, FILE *fpout);
 #endif
 };
 
-typedef Bit32s (*param_string_event_handler)(class bx_param_string_c *, int set, char *val, int maxlen);
+typedef char* (*param_string_event_handler)(class bx_param_string_c *, int set, char *val, int maxlen);
 
 class bx_param_string_c : public bx_param_c {
   int maxsize;
@@ -221,7 +191,7 @@ public:
       char *initial_val,
       int maxsize=-1);
   void reset ();
-  void set_handler (param_string_event_handler handler) { this->handler = handler; }
+  void set_handler (param_string_event_handler handler);
   Bit32s get (char *buf, int len);
   char *getptr () {return val; }
   void set (char *buf);
@@ -231,17 +201,6 @@ public:
 #endif
 };
 
-// the BX_LISTOPT_* values define the bits in bx_list_c, that controls
-// the behavior of the bx_list_c.
-// When a bx_list_c is displayed as a menu, SHOW_PARENT controls whether 
-// or not the menu shows "0. Return to previous menu" or not.
-#define BX_LISTOPT_SHOW_PARENT   (1<<0)
-// Some lists are best displayed shown as menus, others as a series of related
-// questions.  Options is a bx_param so that if necessary the bx_list could
-// install a handler to cause get/set of options to have side effects.
-#define BX_LISTOPT_SERIES_ASK    (1<<1)
-
-
 class bx_list_c : public bx_param_c {
 private:
   // just a list of bx_param_c objects.  size tells current number of
@@ -272,8 +231,8 @@ public:
     // related questions.  
     BX_SERIES_ASK = (1<<1)
   } bx_listopt_bits;
-  bx_list_c (bx_id id, int maxsize);
-  bx_list_c (bx_id id, bx_param_c **init_list);
+  //bx_list_c (bx_id id, int maxsize);
+  bx_list_c (bx_id id, char *name, char *description, bx_param_c **init_list);
   void add (bx_param_c *param);
   bx_param_c *get (int index);
   bx_param_num_c *get_options () { return options; }
@@ -301,6 +260,8 @@ extern char *floppy_type_names[];
 extern int n_floppy_type_names;
 extern char *floppy_status_names[];
 extern int n_floppy_status_names;
+extern char *floppy_bootdisk_names[];
+extern int n_floppy_bootdisk_names;
 
 typedef struct {
   bx_param_string_c *Opath;
@@ -320,7 +281,7 @@ struct bx_cdrom_options
 {
   bx_param_bool_c *Opresent;
   bx_param_string_c *Opath;
-  bx_param_bool_c *Oinserted;
+  bx_param_enum_c *Oinserted;
 };
 
 
diff --git a/bochs/main.cc b/bochs/main.cc
index ecf7ea755..47c5335a5 100644
--- a/bochs/main.cc
+++ b/bochs/main.cc
@@ -113,40 +113,124 @@ bx_param_handler (bx_param_c *param, int set, Bit32s val)
   return val;
 }
 
+char *bx_param_string_handler (bx_param_string_c *param, int set, char *val, int maxlen)
+{
+  int empty = 0;
+  if ((strlen(val) < 1) || !strcmp ("none", val)) {
+    empty = 1;
+    val = "none";
+  }
+  switch (param->get_id ()) {
+    case BXP_FLOPPYA_PATH:
+      if (set==1) {
+	SIM->get_param_num(BXP_FLOPPYA_TYPE)->set_enabled (!empty);
+	SIM->get_param_num(BXP_FLOPPYA_STATUS)->set_enabled (!empty);
+      }
+      break;
+    case BXP_FLOPPYB_PATH:
+      if (set==1) {
+	SIM->get_param_num(BXP_FLOPPYB_TYPE)->set_enabled (!empty);
+	SIM->get_param_num(BXP_FLOPPYB_STATUS)->set_enabled (!empty);
+      }
+      break;
+    case BXP_DISKC_PATH:
+      if (set==1) {
+	SIM->get_param_num(BXP_DISKC_PRESENT)->set (!empty);
+	SIM->get_param_num(BXP_DISKC_CYLINDERS)->set_enabled (!empty);
+	SIM->get_param_num(BXP_DISKC_HEADS)->set_enabled (!empty);
+	SIM->get_param_num(BXP_DISKC_SPT)->set_enabled (!empty);
+      }
+      break;
+    case BXP_DISKD_PATH:
+      if (set==1) {
+	SIM->get_param_num(BXP_DISKD_PRESENT)->set (!empty);
+	SIM->get_param_num(BXP_DISKD_CYLINDERS)->set_enabled (!empty);
+	SIM->get_param_num(BXP_DISKD_HEADS)->set_enabled (!empty);
+	SIM->get_param_num(BXP_DISKD_SPT)->set_enabled (!empty);
+      }
+      break;
+    case BXP_CDROM_PATH:
+      if (set==1) {
+	SIM->get_param_num(BXP_CDROM_PRESENT)->set (!empty);
+	SIM->get_param_num(BXP_CDROM_INSERTED)->set_enabled (!empty);
+      }
+      break;
+  }
+  return val;
+}
+
+
 void bx_init_options ()
 {
+  bx_list_c *menu;
+
+  // floppya
   bx_options.floppya.Opath = new bx_param_string_c (BXP_FLOPPYA_PATH,
-      "floppya:path",
+      "Floppy A image",
       "Pathname of first floppy image file or device.  If you're booting from floppy, this should be a bootable floppy.",
       "", BX_PATHNAME_LEN);
+  bx_options.floppya.Opath->set_ask_format ("Enter new filename, or 'none' for no disk: [%s] ");
   bx_options.floppya.Otype = new bx_param_enum_c (BXP_FLOPPYA_TYPE,
       "floppya:type",
       "Type of floppy disk",
-      floppy_status_names,
+      floppy_type_names,
       BX_FLOPPY_NONE,
       BX_FLOPPY_NONE);
+  bx_options.floppya.Otype->set_ask_format ("What type of floppy disk? [%s] ");
   bx_options.floppya.Oinitial_status = new bx_param_enum_c (BXP_FLOPPYA_STATUS,
-      "floppya:status",
+      "Is floppya inserted",
       "Inserted or ejected",
-      floppy_type_names,
-      BX_EJECTED,
+      floppy_status_names,
+      BX_INSERTED,
       BX_EJECTED);
+  bx_options.floppya.Oinitial_status->set_ask_format ("Is the floppy inserted or ejected? [%s] ");
+  bx_options.floppya.Opath->set_format ("%s");
+  bx_options.floppya.Otype->set_format (", size=%s, ");
+  bx_options.floppya.Oinitial_status->set_format ("%s");
+  bx_param_c *floppya_init_list[] = {
+    bx_options.floppya.Opath,
+    bx_options.floppya.Otype,
+    bx_options.floppya.Oinitial_status,
+    NULL
+  };
+  menu = new bx_list_c (BXP_FLOPPYA, "Floppy Disk 0", "All options for first floppy disk", floppya_init_list);
+  menu->get_options ()->set (menu->BX_SERIES_ASK);
+  bx_options.floppya.Opath->set_handler (bx_param_string_handler);
+  bx_options.floppya.Opath->set ("none");
+
   bx_options.floppyb.Opath = new bx_param_string_c (BXP_FLOPPYB_PATH,
       "floppyb:path",
       "Pathname of second floppy image file or device.",
       "", BX_PATHNAME_LEN);
+  bx_options.floppyb.Opath->set_ask_format ("Enter new filename, or 'none' for no disk: [%s] ");
   bx_options.floppyb.Otype = new bx_param_enum_c (BXP_FLOPPYB_TYPE,
       "floppyb:type",
       "Type of floppy disk",
       floppy_type_names,
       BX_FLOPPY_NONE,
       BX_FLOPPY_NONE);
-  bx_options.floppyb.Oinitial_status = new bx_param_enum_c (BXP_FLOPPYA_STATUS,
-      "floppyb:status",
+  bx_options.floppyb.Otype->set_ask_format ("What type of floppy disk? [%s] ");
+  bx_options.floppyb.Oinitial_status = new bx_param_enum_c (BXP_FLOPPYB_STATUS,
+      "Is floppyb inserted",
       "Inserted or ejected",
-      floppy_type_names,
-      BX_EJECTED,
+      floppy_status_names,
+      BX_INSERTED,
       BX_EJECTED);
+  bx_options.floppyb.Oinitial_status->set_ask_format ("Is the floppy inserted or ejected? [%s] ");
+  bx_options.floppyb.Oinitial_status->set_format ("%s");
+  bx_options.floppyb.Opath->set_format ("%s");
+  bx_options.floppyb.Otype->set_format (", size=%s, ");
+  bx_options.floppyb.Oinitial_status->set_format ("%s");
+  bx_param_c *floppyb_init_list[] = {
+    bx_options.floppyb.Opath,
+    bx_options.floppyb.Otype,
+    bx_options.floppyb.Oinitial_status,
+    NULL
+  };
+  menu = new bx_list_c (BXP_FLOPPYB, "Floppy Disk 1", "All options for second floppy disk", floppyb_init_list);
+  menu->get_options ()->set (menu->BX_SERIES_ASK);
+  bx_options.floppyb.Opath->set_handler (bx_param_string_handler);
+  bx_options.floppyb.Opath->set ("none");
 
   // diskc options
   bx_options.diskc.Opresent = new bx_param_bool_c (BXP_DISKC_PRESENT,
@@ -154,24 +238,45 @@ void bx_init_options ()
       "Controls whether diskc is installed or not",
       0);
   bx_options.diskc.Opath = new bx_param_string_c (BXP_DISKC_PATH,
-      "diskc:path",
+      "",
       "Pathname of the hard drive image",
       "", BX_PATHNAME_LEN);
   bx_options.diskc.Ocylinders = new bx_param_num_c (BXP_DISKC_CYLINDERS,
       "diskc:cylinders",
       "Number of cylinders",
       1, 65535,
-      0);
+      1);
   bx_options.diskc.Oheads = new bx_param_num_c (BXP_DISKC_HEADS,
       "diskc:heads",
       "Number of heads",
       1, 65535,
-      0);
+      1);
   bx_options.diskc.Ospt = new bx_param_num_c (BXP_DISKC_SPT,
       "diskc:spt",
       "Number of sectors per track",
       1, 65535,
-      0);
+      1);
+  bx_options.diskc.Opath->set_ask_format ("Enter new filename, or 'none' for no disk: [%s] ");
+  bx_options.diskc.Ocylinders->set_ask_format ("Enter number of cylinders: [%d] ");
+  bx_options.diskc.Oheads->set_ask_format ("Enter number of heads: [%d] ");
+  bx_options.diskc.Ospt->set_ask_format ("Enter number of sectors per track: [%d] ");
+  bx_options.diskc.Opath->set_format ("%s");
+  bx_options.diskc.Ocylinders->set_format (", %d cylinders, ");
+  bx_options.diskc.Oheads->set_format ("%d heads, ");
+  bx_options.diskc.Ospt->set_format ("%d sectors/track");
+  bx_param_c *diskc_init_list[] = {
+    bx_options.diskc.Opath,
+    bx_options.diskc.Ocylinders,
+    bx_options.diskc.Oheads,
+    bx_options.diskc.Ospt,
+    NULL
+  };
+  menu = new bx_list_c (BXP_DISKC, "Hard disk 0", "All options for hard disk 0", diskc_init_list);
+  menu->get_options ()->set (menu->BX_SERIES_ASK);
+  // if path is the word "none", then do not ask the other options and
+  // set present=0.
+  bx_options.diskc.Opath->set_handler (bx_param_string_handler);
+  bx_options.diskc.Opath->set ("none");
 
   // diskd options
   bx_options.diskd.Opresent = new bx_param_bool_c (BXP_DISKD_PRESENT,
@@ -186,31 +291,92 @@ void bx_init_options ()
       "diskd:cylinders",
       "Number of cylinders",
       1, 65535,
-      0);
+      1);
   bx_options.diskd.Oheads = new bx_param_num_c (BXP_DISKD_HEADS,
       "diskd:heads",
       "Number of heads",
       1, 65535,
-      0);
+      1);
   bx_options.diskd.Ospt = new bx_param_num_c (BXP_DISKD_SPT,
       "diskd:spt",
       "Number of sectors per track",
       1, 65535,
-      0);
+      1);
+  bx_options.diskd.Opath->set_ask_format ("Enter new filename, or none for no disk: [%s] ");
+  bx_options.diskd.Ocylinders->set_ask_format ("Enter number of cylinders: [%d] ");
+  bx_options.diskd.Oheads->set_ask_format ("Enter number of heads: [%d] ");
+  bx_options.diskd.Ospt->set_ask_format ("Enter number of sectors per track: [%d] ");
+  bx_options.diskd.Opath->set_format ("%s");
+  bx_options.diskd.Ocylinders->set_format (", %d cylinders, ");
+  bx_options.diskd.Oheads->set_format ("%d heads, ");
+  bx_options.diskd.Ospt->set_format ("%d sectors/track");
+  bx_param_c *diskd_init_list[] = {
+    bx_options.diskd.Opath,
+    bx_options.diskd.Ocylinders,
+    bx_options.diskd.Oheads,
+    bx_options.diskd.Ospt,
+    NULL
+  };
+  menu = new bx_list_c (BXP_DISKD, "Hard disk 1", "All options for hard disk 1", diskd_init_list);
+  menu->get_options ()->set (menu->BX_SERIES_ASK);
+  bx_options.diskd.Opath->set_handler (bx_param_string_handler);
+  bx_options.diskd.Opath->set ("none");
 
   // cdrom options
   bx_options.cdromd.Opresent = new bx_param_bool_c (BXP_CDROM_PRESENT,
-      "cdrom:present",
+      "CDROM is present",
       "Controls whether cdromd is installed or not",
       0);
   bx_options.cdromd.Opath = new bx_param_string_c (BXP_CDROM_PATH,
-      "cdrom:path",
+      "CDROM image filename",
       "Pathname of the cdrom device or image",
       "", BX_PATHNAME_LEN);
-  bx_options.cdromd.Oinserted = new bx_param_bool_c (BXP_CDROM_PRESENT,
-      "cdrom:present",
-      "Controls whether cdromd is installed or not",
-      0);
+  bx_options.cdromd.Opath->set_format ("%s");
+  bx_options.cdromd.Opath->set_ask_format ("Enter new filename, or 'none' for no CDROM: [%s] ");
+  bx_options.cdromd.Oinserted = new bx_param_enum_c (BXP_CDROM_INSERTED,
+      "Is the CDROM inserted or ejected",
+      "Inserted or ejected",
+      floppy_status_names,
+      BX_INSERTED,
+      BX_EJECTED);
+  bx_options.cdromd.Oinserted->set_format (", %s");
+  bx_options.cdromd.Oinserted->set_ask_format ("Is the CDROM inserted or ejected? [%s] ");
+  bx_param_c *cdromd_init_list[] = {
+    bx_options.cdromd.Opath,
+    bx_options.cdromd.Oinserted,
+    NULL
+  };
+  menu = new bx_list_c (BXP_CDROMD, "CDROM", "Options for the CDROM", cdromd_init_list);
+  menu->get_options ()->set (menu->BX_SERIES_ASK);
+  bx_options.cdromd.Opath->set_handler (bx_param_string_handler);
+  bx_options.cdromd.Opath->set ("none");
+
+  bx_options.OnewHardDriveSupport = new bx_param_bool_c (BXP_NEWHARDDRIVESUPPORT,
+      "New Hard Drive Support",
+      "Enables new features found on newer hard drives.",
+      1);
+
+  bx_options.Obootdrive = new bx_param_enum_c (BXP_BOOTDRIVE,
+      "bootdrive",
+      "Boot A or C",
+      floppy_bootdisk_names,
+      BX_BOOT_FLOPPYA,
+      BX_BOOT_FLOPPYA);
+  bx_options.Obootdrive->set_format ("Boot from: %s drive");
+  bx_options.Obootdrive->set_ask_format ("Boot from floppy drive or hard drive? [%s] ");
+  // disk menu
+  bx_param_c *disk_menu_init_list[] = {
+    SIM->get_param (BXP_FLOPPYA),
+    SIM->get_param (BXP_FLOPPYB),
+    SIM->get_param (BXP_DISKC),
+    SIM->get_param (BXP_DISKD),
+    SIM->get_param (BXP_CDROMD),
+    SIM->get_param (BXP_NEWHARDDRIVESUPPORT),
+    SIM->get_param (BXP_BOOTDRIVE),
+    NULL
+  };
+  menu = new bx_list_c (BXP_MENU_DISK, "Bochs Disk Options", "diskmenu", disk_menu_init_list);
+  menu->get_options ()->set (menu->BX_SHOW_PARENT);
 
   // memory options menu
   bx_options.memory.Osize = new bx_param_num_c (BXP_MEM_SIZE,
@@ -237,30 +403,47 @@ void bx_init_options ()
       "Pathname of VGA ROM image to load",
       "", BX_PATHNAME_LEN);
   bx_options.vgarom.Opath->set_format ("Name of VGA BIOS image: %s");
-  bx_param_c *init_list[] = {
+  bx_param_c *memory_init_list[] = {
     bx_options.memory.Osize,
     bx_options.vgarom.Opath,
     bx_options.rom.Opath,
     bx_options.rom.Oaddress,
     NULL
   };
-  bx_list_c *menu = new bx_list_c (BXP_MEMORY_OPTIONS_MENU, init_list);
-  menu->get_title ()->set ("Bochs Memory Options");
+  menu = new bx_list_c (BXP_MENU_MEMORY, "Bochs Memory Options", "memmenu", memory_init_list);
   menu->get_options ()->set (menu->BX_SHOW_PARENT);
 
-
-
-  bx_options.Oips = new bx_param_num_c (BXP_IPS, 
-      "ips",
-      "Emulated instructions per second, used to calibrate bochs emulated\ntime with wall clock time.",
-      1, BX_MAX_INT,
-      500000);
   bx_options.Ovga_update_interval = new bx_param_num_c (BXP_VGA_UPDATE_INTERVAL,
-      "vga_update_interval",
+      "VGA Update Interval",
       "Number of microseconds between VGA updates",
       1, BX_MAX_INT,
       30000);
   bx_options.Ovga_update_interval->set_handler (bx_param_handler);
+  bx_options.Ovga_update_interval->set_ask_format ("Type a new value for VGA update interval: [%d] ");
+  bx_options.Omouse_enabled = new bx_param_bool_c (BXP_MOUSE_ENABLED,
+      "Enable the mouse",
+      "Controls whether the mouse sends events to bochs",
+      0);
+  bx_options.Omouse_enabled->set_handler (bx_param_handler);
+  bx_options.Oips = new bx_param_num_c (BXP_IPS, 
+      "Emulated instructions per second (IPS)",
+      "Emulated instructions per second, used to calibrate bochs emulated\ntime with wall clock time.",
+      1, BX_MAX_INT,
+      500000);
+  bx_options.Oprivate_colormap = new bx_param_bool_c (BXP_PRIVATE_COLORMAP,
+      "Use a private colormap",
+      "Request that the GUI create and use it's own non-shared colormap.  This colormap will be used when in the bochs window.  If not enabled, a shared colormap scheme may be used.  Not implemented on all GUI's.",
+      0);
+  bx_param_c *interface_init_list[] = {
+    bx_options.Ovga_update_interval,
+    bx_options.Omouse_enabled,
+    bx_options.Oips,
+    bx_options.Oprivate_colormap,
+    NULL
+  };
+  menu = new bx_list_c (BXP_MENU_INTERFACE, "Bochs Interface Menu", "intfmenu", interface_init_list);
+  menu->get_options ()->set (menu->BX_SHOW_PARENT);
+
   bx_options.Okeyboard_serial_delay = new bx_param_num_c (BXP_KBD_SERIAL_DELAY,
       "keyboard_serial_delay",
       "Approximate time in microseconds that it takes one character to be transfered from the keyboard to controller over the serial path.",
@@ -271,27 +454,15 @@ void bx_init_options ()
       "Time in microseconds to wait before completing some floppy commands such as read/write/seek/etc, which normally have a delay associated.  This used to be hardwired to 50,000 before.",
       1, BX_MAX_INT,
       50000);
-  bx_options.Omouse_enabled = new bx_param_bool_c (BXP_MOUSE_ENABLED,
-      "mouse_enabled",
-      "Controls whether the mouse sends events to bochs",
-      0);
-  bx_options.Omouse_enabled->set_handler (bx_param_handler);
-  bx_options.Oprivate_colormap = new bx_param_bool_c (BXP_PRIVATE_COLORMAP,
-      "private_colormap",
-      "Request that the GUI create and use it's own non-shared colormap.  This colormap will be used when in the bochs window.  If not enabled, a shared colormap scheme may be used.  Not implemented on all GUI's.",
-      0);
   bx_options.Oi440FXSupport = new bx_param_bool_c (BXP_I440FX_SUPPORT,
       "i440FXSupport",
       "Controls whether to emulate PCI I440FX",
       0);
-  bx_options.OnewHardDriveSupport = new bx_param_bool_c (BXP_NEWHARDDRIVESUPPORT,
-      "newharddrivesupport",
-      "Enables new features found on newer hard drives.",
-      1);
   bx_options.log.Ofilename = new bx_param_string_c (BXP_LOG_FILENAME,
       "log:filename",
       "Pathname of bochs log file",
       "-", BX_PATHNAME_LEN);
+  bx_options.log.Ofilename->set_ask_format ("Enter log filename: [%s] ");
   bx_options.cmos.Opath = new bx_param_string_c (BXP_CMOS_PATH,
       "cmos:path",
       "Pathname of CMOS image",
@@ -303,7 +474,7 @@ void bx_init_options ()
   bx_options.cmos.Otime0 = new bx_param_num_c (BXP_CMOS_TIME0,
       "cmos:time0",
       "Start time for Bochs CMOS clock, used if you really want two runs to be identical (cosimulation)",
-      1, BX_MAX_INT,
+      0, BX_MAX_INT,
       0);
   bx_options.load32bitOSImage.OwhichOS = new bx_param_num_c (BXP_LOAD32BITOS_WHICH,
       "load32bitOS:which",
@@ -322,11 +493,6 @@ void bx_init_options ()
       "load32bitOS:initrd",
       "Initrd",
       "", BX_PATHNAME_LEN);
-  bx_options.Obootdrive = new bx_param_num_c (BXP_BOOTDRIVE,
-      "bootdrive",
-      "Boot A or C",
-      BX_BOOT_FLOPPYA, BX_BOOT_DISKC,
-      BX_BOOT_FLOPPYA);
 }
 
 void bx_print_header(void);