1 files changed, 253 insertions, 152 deletions

diff --git a/scripts/kconfig/qconf.cc b/scripts/kconfig/qconf.cc
index bed541d..52419ad 100644
--- a/scripts/kconfig/qconf.cc
+++ b/scripts/kconfig/qconf.cc
@@ -33,83 +33,73 @@ static QApplication *configApp;
 #if QT_VERSION >= 300
 static QSettings *configSettings;
 #endif
 
 /*
  * update all the children of a menu entry
  *   removes/adds the entries from the parent widget as necessary
  *
  * parent: either the menu list widget or a menu entry widget
  * menu: entry to be updated
  */
 template <class P>
-static void updateMenuList(P* parent, struct menu* menu)
+void ConfigList::updateMenuList(P* parent, struct menu* menu)
 {
         struct menu* child;
-        ConfigList* list = parent->listView();
         ConfigItem* item;
         ConfigItem* last;
         bool visible;
-        bool showAll = list->showAll;
-        enum listMode mode = list->mode;
         enum prop_type type;
 
         if (!menu) {
                 while ((item = parent->firstChild()))
                         delete item;
                 return;
         }
 
-        last = 0;
+        last = parent->firstChild();
+        if (last && !last->goParent)
+                last = 0;
         for (child = menu->list; child; child = child->next) {
                 item = last ? last->nextSibling() : parent->firstChild();
                 type = child->prompt ? child->prompt->type : P_UNKNOWN;
 
                 switch (mode) {
                 case menuMode:
-                        if (type != P_ROOTMENU)
+                        if (!(child->flags & MENU_ROOT))
                                 goto hide;
                         break;
                 case symbolMode:
-                        if (type == P_ROOTMENU)
+                        if (child->flags & MENU_ROOT)
                                 goto hide;
                         break;
                 default:
                         break;
                 }
 
                 visible = menu_is_visible(child);
                 if (showAll || visible) {
                         if (!item || item->menu != child)
                                 item = new ConfigItem(parent, last, child, visible);
-                        else {
-                                item->visible = visible;
-                                if (item->updateNeeded()) {
-                                        ConfigItem* i = (ConfigItem*)child->data;
-                                        for (; i; i = i->nextItem) {
-                                                i->updateMenu();
-                                        }
-                                } else if (list->updateAll)
-                                        item->updateMenu();
-                        }
+                        else
+                                item->testUpdateMenu(visible);
 
-                        if (mode == fullMode || mode == menuMode ||
-                            (type != P_MENU && type != P_ROOTMENU))
+                        if (mode == fullMode || mode == menuMode || type != P_MENU)
                                 updateMenuList(item, child);
                         else
                                 updateMenuList(item, 0);
                         last = item;
                         continue;
                 }
-                hide:
+        hide:
                 if (item && item->menu == child) {
                         last = parent->firstChild();
                         if (last == item)
                                 last = 0;
                         else while (last->nextSibling() != item)
                                 last = last->nextSibling();
                         delete item;
                 }
         }
 }
 
 #if QT_VERSION >= 300
@@ -122,53 +112,74 @@ void ConfigItem::okRename(int col)
         Parent::okRename(col);
         sym_set_string_value(menu->sym, text(dataColIdx).latin1());
 }
 #endif
 
 /*
  * update the displayed of a menu entry
  */
 void ConfigItem::updateMenu(void)
 {
         ConfigList* list;
         struct symbol* sym;
+        struct property *prop;
         QString prompt;
         int type;
-        enum prop_type ptype;
         tristate expr;
 
         list = listView();
+        if (goParent) {
+                setPixmap(promptColIdx, list->menuBackPix);
+                prompt = "..";
+                goto set_prompt;
+        }
 
         sym = menu->sym;
-        if (!sym) {
-                setText(promptColIdx, menu_get_prompt(menu));
-                ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-                if ((ptype == P_ROOTMENU || ptype == P_MENU) &&
-                    (list->mode == singleMode || list->mode == symbolMode))
+        prop = menu->prompt;
+        prompt = menu_get_prompt(menu);
+
+        if (prop) switch (prop->type) {
+        case P_MENU:
+                if (list->mode == singleMode || list->mode == symbolMode) {
+                        /* a menuconfig entry is displayed differently
+                         * depending whether it's at the view root or a child.
+                         */
+                        if (sym && list->rootEntry == menu)
+                                break;
                         setPixmap(promptColIdx, list->menuPix);
-                else
+                } else {
+                        if (sym)
+                                break;
                         setPixmap(promptColIdx, 0);
-                return;
+                }
+                goto set_prompt;
+        case P_COMMENT:
+                setPixmap(promptColIdx, 0);
+                goto set_prompt;
+        default:
+                ;
         }
+        if (!sym)
+                goto set_prompt;
 
         setText(nameColIdx, sym->name);
 
         type = sym_get_type(sym);
         switch (type) {
         case S_BOOLEAN:
         case S_TRISTATE:
                 char ch;
 
-                prompt = menu_get_prompt(menu);
                 if (!sym_is_changable(sym) && !list->showAll) {
+                        setPixmap(promptColIdx, 0);
                         setText(noColIdx, 0);
                         setText(modColIdx, 0);
                         setText(yesColIdx, 0);
                         break;
                 }
                 expr = sym_get_tristate_value(sym);
                 switch (expr) {
                 case yes:
                         if (sym_is_choice_value(sym) && type == S_BOOLEAN)
                                 setPixmap(promptColIdx, list->choiceYesPix);
                         else
                                 setPixmap(promptColIdx, list->symbolYesPix);
@@ -202,85 +213,95 @@ void ConfigItem::updateMenu(void)
         case S_HEX:
         case S_STRING:
                 const char* data;
 
                 data = sym_get_string_value(sym);
 #if QT_VERSION >= 300
                 int i = list->mapIdx(dataColIdx);
                 if (i >= 0)
                         setRenameEnabled(i, TRUE);
 #endif
                 setText(dataColIdx, data);
                 if (type == S_STRING)
-                        prompt.sprintf("%s: %s", menu_get_prompt(menu), data);
+                        prompt.sprintf("%s: %s", prompt.latin1(), data);
                 else
-                        prompt.sprintf("(%s) %s", data, menu_get_prompt(menu));
+                        prompt.sprintf("(%s) %s", data, prompt.latin1());
                 break;
         }
         if (!sym_has_value(sym) && visible)
                 prompt += " (NEW)";
+set_prompt:
         setText(promptColIdx, prompt);
 }
 
-bool ConfigItem::updateNeeded(void)
+void ConfigItem::testUpdateMenu(bool v)
 {
-        struct symbol* sym = menu->sym;
-        if (sym)
-                sym_calc_value(sym);
+        ConfigItem* i;
+
+        visible = v;
+        if (!menu)
+                return;
+
+        sym_calc_value(menu->sym);
         if (menu->flags & MENU_CHANGED) {
+                /* the menu entry changed, so update all list items */
                 menu->flags &= ~MENU_CHANGED;
-                return true;
-        }
-        return false;
+                for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
+                        i->updateMenu();
+        } else if (listView()->updateAll)
+                updateMenu();
 }
 
 void ConfigItem::paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align)
 {
         ConfigList* list = listView();
 
         if (visible) {
                 if (isSelected() && !list->hasFocus() && list->mode == menuMode)
                         Parent::paintCell(p, list->inactivedColorGroup, column, width, align);
                 else
                         Parent::paintCell(p, cg, column, width, align);
         } else
                 Parent::paintCell(p, list->disabledColorGroup, column, width, align);
 }
 
 /*
  * construct a menu entry
  */
 void ConfigItem::init(void)
 {
-        ConfigList* list = listView();
-        nextItem = (ConfigItem*)menu->data;
-        menu->data = this;
+        if (menu) {
+                ConfigList* list = listView();
+                nextItem = (ConfigItem*)menu->data;
+                menu->data = this;
 
-        if (list->mode != fullMode)
-                setOpen(TRUE);
-        if (menu->sym)
+                if (list->mode != fullMode)
+                        setOpen(TRUE);
                 sym_calc_value(menu->sym);
+        }
         updateMenu();
 }
 
 /*
  * destruct a menu entry
  */
 ConfigItem::~ConfigItem(void)
 {
-        ConfigItem** ip = &(ConfigItem*)menu->data;
-        for (; *ip; ip = &(*ip)->nextItem) {
-                if (*ip == this) {
-                        *ip = nextItem;
-                        break;
+        if (menu) {
+                ConfigItem** ip = (ConfigItem**)&menu->data;
+                for (; *ip; ip = &(*ip)->nextItem) {
+                        if (*ip == this) {
+                                *ip = nextItem;
+                                break;
+                        }
                 }
         }
 }
 
 void ConfigLineEdit::show(ConfigItem* i)
 {
         item = i;
         if (sym_get_string_value(item->menu->sym))
                 setText(sym_get_string_value(item->menu->sym));
         else
                 setText(0);
         Parent::show();
@@ -301,25 +322,26 @@ void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
                 Parent::keyPressEvent(e);
                 return;
         }
         e->accept();
         parent()->list->setFocus();
         hide();
 }
 
 ConfigList::ConfigList(ConfigView* p, ConfigMainWindow* cv)
         : Parent(p), cview(cv),
           updateAll(false),
           symbolYesPix(xpm_symbol_yes), symbolModPix(xpm_symbol_mod), symbolNoPix(xpm_symbol_no),
-          choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no), menuPix(xpm_menu), menuInvPix(xpm_menu_inv),
+          choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no),
+          menuPix(xpm_menu), menuInvPix(xpm_menu_inv), menuBackPix(xpm_menuback), voidPix(xpm_void),
           showAll(false), showName(false), showRange(false), showData(false),
           rootEntry(0)
 {
         int i;
 
         setSorting(-1);
         setRootIsDecorated(TRUE);
         disabledColorGroup = palette().active();
         disabledColorGroup.setColor(QColorGroup::Text, palette().disabled().text());
         inactivedColorGroup = palette().active();
         inactivedColorGroup.setColor(QColorGroup::Highlight, palette().disabled().highlight());
 
@@ -357,51 +379,74 @@ void ConfigList::reinit(void)
 void ConfigList::updateSelection(void)
 {
         struct menu *menu;
         enum prop_type type;
 
         ConfigItem* item = (ConfigItem*)selectedItem();
         if (!item)
                 return;
 
         cview->setHelp(item);
 
         menu = item->menu;
+        if (!menu)
+                return;
         type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-        if (mode == menuMode && (type == P_MENU || type == P_ROOTMENU))
+        if (mode == menuMode && type == P_MENU)
                 emit menuSelected(menu);
 }
 
 void ConfigList::updateList(ConfigItem* item)
 {
-                (void)item;// unused so far
+        ConfigItem* last = 0;
+
+        if (!rootEntry)
+                goto update;
+
+        if (rootEntry != &rootmenu && (mode == singleMode ||
+            (mode == symbolMode && rootEntry->parent != &rootmenu))) {
+                item = firstChild();
+                if (!item)
+                        item = new ConfigItem(this, 0, true);
+                last = item;
+        }
+        if (mode == singleMode && rootEntry->sym && rootEntry->prompt) {
+                item = last ? last->nextSibling() : firstChild();
+                if (!item)
+                        item = new ConfigItem(this, last, rootEntry, true);
+
+                updateMenuList(item, rootEntry);
+                triggerUpdate();
+                return;
+        }
+update:
         updateMenuList(this, rootEntry);
         triggerUpdate();
 }
 
 void ConfigList::setAllOpen(bool open)
 {
         QListViewItemIterator it(this);
 
         for (; it.current(); it++)
                 it.current()->setOpen(open);
 }
 
 void ConfigList::setValue(ConfigItem* item, tristate val)
 {
         struct symbol* sym;
         int type;
         tristate oldval;
 
-        sym = item->menu->sym;
+        sym = item->menu ? item->menu->sym : 0;
         if (!sym)
                 return;
 
         type = sym_get_type(sym);
         switch (type) {
         case S_BOOLEAN:
         case S_TRISTATE:
                 oldval = sym_get_tristate_value(sym);
 
                 if (!sym_set_tristate_value(sym, val))
                         return;
                 if (oldval == no && item->menu->list)
@@ -409,24 +454,26 @@ void ConfigList::setValue(ConfigItem* item, tristate val)
                 parent()->updateList(item);
                 break;
         }
 }
 
 void ConfigList::changeValue(ConfigItem* item)
 {
         struct symbol* sym;
         struct menu* menu;
         int type, oldexpr, newexpr;
 
         menu = item->menu;
+        if (!menu)
+                return;
         sym = menu->sym;
         if (!sym) {
                 if (item->menu->list)
                         item->setOpen(!item->isOpen());
                 return;
         }
 
         type = sym_get_type(sym);
         switch (type) {
         case S_BOOLEAN:
         case S_TRISTATE:
                 oldexpr = sym_get_tristate_value(sym);
@@ -451,42 +498,41 @@ void ConfigList::changeValue(ConfigItem* item)
                         parent()->lineEdit->show(item);
                 break;
         }
 }
 
 void ConfigList::setRootMenu(struct menu *menu)
 {
         enum prop_type type;
 
         if (rootEntry == menu)
                 return;
         type = menu && menu->prompt ? menu->prompt->type : P_UNKNOWN;
-        if (type != P_MENU && type != P_ROOTMENU)
+        if (type != P_MENU)
                 return;
         updateMenuList(this, 0);
         rootEntry = menu;
         updateListAll();
         setSelected(currentItem(), hasFocus());
 }
 
 void ConfigList::setParentMenu(void)
 {
         ConfigItem* item;
-        struct menu *oldroot, *newroot;
+        struct menu *oldroot;
 
         oldroot = rootEntry;
-        newroot = menu_get_parent_menu(oldroot);
-        if (newroot == oldroot)
+        if (rootEntry == &rootmenu)
                 return;
-        setRootMenu(newroot);
+        setRootMenu(menu_get_parent_menu(rootEntry->parent));
 
         QListViewItemIterator it(this);
         for (; (item = (ConfigItem*)it.current()); it++) {
                 if (item->menu == oldroot) {
                         setCurrentItem(item);
                         ensureItemVisible(item);
                         break;
                 }
         }
 }
 
 void ConfigList::keyPressEvent(QKeyEvent* ev)
@@ -502,27 +548,34 @@ void ConfigList::keyPressEvent(QKeyEvent* ev)
                 return;
         }
 
         if (!i) {
                 Parent::keyPressEvent(ev);
                 return;
         }
         item = (ConfigItem*)i;
 
         switch (ev->key()) {
         case Key_Return:
         case Key_Enter:
+                if (item->goParent) {
+                        emit parentSelected();
+                        break;
+                }
                 menu = item->menu;
+                if (!menu)
+                        break;
                 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-                if ((type == P_MENU || type == P_ROOTMENU) && mode != fullMode) {
+                if (type == P_MENU && rootEntry != menu &&
+                    mode != fullMode && mode != menuMode) {
                         emit menuSelected(menu);
                         break;
                 }
         case Key_Space:
                 changeValue(item);
                 break;
         case Key_N:
                 setValue(item, no);
                 break;
         case Key_M:
                 setValue(item, mod);
                 break;
@@ -539,44 +592,52 @@ void ConfigList::keyPressEvent(QKeyEvent* ev)
 void ConfigList::contentsMousePressEvent(QMouseEvent* e)
 {
         //QPoint p(contentsToViewport(e->pos()));
         //printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
         Parent::contentsMousePressEvent(e);
 }
 
 void ConfigList::contentsMouseReleaseEvent(QMouseEvent* e)
 {
         QPoint p(contentsToViewport(e->pos()));
         ConfigItem* item = (ConfigItem*)itemAt(p);
         struct menu *menu;
+        enum prop_type ptype;
         const QPixmap* pm;
         int idx, x;
 
         if (!item)
                 goto skip;
 
         menu = item->menu;
         x = header()->offset() + p.x();
         idx = colRevMap[header()->sectionAt(x)];
         switch (idx) {
         case promptColIdx:
                 pm = item->pixmap(promptColIdx);
                 if (pm) {
                         int off = header()->sectionPos(0) + itemMargin() +
                                 treeStepSize() * (item->depth() + (rootIsDecorated() ? 1 : 0));
                         if (x >= off && x < off + pm->width()) {
-                                if (menu->sym)
-                                        changeValue(item);
-                                else
+                                if (item->goParent) {
+                                        emit parentSelected();
+                                        break;
+                                } else if (!menu)
+                                        break;
+                                ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
+                                if (ptype == P_MENU && rootEntry != menu &&
+                                    mode != fullMode && mode != menuMode)
                                         emit menuSelected(menu);
+                                else
+                                        changeValue(item);
                         }
                 }
                 break;
         case noColIdx:
                 setValue(item, no);
                 break;
         case modColIdx:
                 setValue(item, mod);
                 break;
         case yesColIdx:
                 setValue(item, yes);
                 break;
@@ -597,28 +658,33 @@ void ConfigList::contentsMouseMoveEvent(QMouseEvent* e)
         Parent::contentsMouseMoveEvent(e);
 }
 
 void ConfigList::contentsMouseDoubleClickEvent(QMouseEvent* e)
 {
         QPoint p(contentsToViewport(e->pos()));
         ConfigItem* item = (ConfigItem*)itemAt(p);
         struct menu *menu;
         enum prop_type ptype;
 
         if (!item)
                 goto skip;
+        if (item->goParent) {
+                emit parentSelected();
+                goto skip;
+        }
         menu = item->menu;
+        if (!menu)
+                goto skip;
         ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-        if ((ptype == P_ROOTMENU || ptype == P_MENU) &&
-            (mode == singleMode || mode == symbolMode))
+        if (ptype == P_MENU && (mode == singleMode || mode == symbolMode))
                 emit menuSelected(menu);
         else if (menu->sym)
                 changeValue(item);
 
 skip:
         //printf("contentsMouseDoubleClickEvent: %d,%d\n", p.x(), p.y());
         Parent::contentsMouseDoubleClickEvent(e);
 }
 
 void ConfigList::focusInEvent(QFocusEvent *e)
 {
         Parent::focusInEvent(e);
@@ -668,25 +734,24 @@ void ConfigView::updateListAll(void)
 {
         ConfigView* v;
 
         for (v = viewList; v; v = v->nextView)
                 v->list->updateListAll();
 }
 
 /*
  * Construct the complete config widget
  */
 ConfigMainWindow::ConfigMainWindow(void)
 {
-        ConfigView* view;
         QMenuBar* menu;
         QSplitter* split1;
         QSplitter* split2;
         bool ok;
         int x, y, width, height;
 
         QWidget *d = configApp->desktop();
 
 #if QT_VERSION >= 300
         width = configSettings->readNumEntry("/kconfig/qconf/window width", d->width() - 64);
         height = configSettings->readNumEntry("/kconfig/qconf/window height", d->height() - 64);
         resize(width, height);
@@ -698,33 +763,33 @@ ConfigMainWindow::ConfigMainWindow(void)
 #else
         width = d->width() - 64;
         height = d->height() - 64;
         resize(width, height);
 #endif
 
         showDebug = false;
 
         split1 = new QSplitter(this);
         split1->setOrientation(QSplitter::Horizontal);
         setCentralWidget(split1);
 
-        view = new ConfigView(split1, this);
-        menuList = view->list;
+        menuView = new ConfigView(split1, this);
+        menuList = menuView->list;
 
         split2 = new QSplitter(split1);
         split2->setOrientation(QSplitter::Vertical);
 
         // create config tree
-        view = new ConfigView(split2, this);
-        configList = view->list;
+        configView = new ConfigView(split2, this);
+        configList = configView->list;
 
         helpText = new QTextView(split2);
         helpText->setTextFormat(Qt::RichText);
 
         setTabOrder(configList, helpText);
         configList->setFocus();
 
         menu = menuBar();
         toolBar = new QToolBar("Tools", this);
 
         backAction = new QAction("Back", QPixmap(xpm_back), "Back", 0, this);
           connect(backAction, SIGNAL(activated()), SLOT(goBack()));
@@ -809,25 +874,24 @@ ConfigMainWindow::ConfigMainWindow(void)
         connect(configList, SIGNAL(menuSelected(struct menu *)),
                 SLOT(changeMenu(struct menu *)));
         connect(configList, SIGNAL(parentSelected()),
                 SLOT(goBack()));
         connect(menuList, SIGNAL(menuSelected(struct menu *)),
                 SLOT(changeMenu(struct menu *)));
 
         connect(configList, SIGNAL(gotFocus(void)),
                 SLOT(listFocusChanged(void)));
         connect(menuList, SIGNAL(gotFocus(void)),
                 SLOT(listFocusChanged(void)));
 
-        //showFullView();
         showSplitView();
 }
 
 static QString print_filter(const char *str)
 {
         QRegExp re("[<>&\"\\n]");
         QString res = str;
         for (int i = 0; (i = res.find(re, i)) >= 0;) {
                 switch (res[i].latin1()) {
                 case '<':
                         res.replace(i, 1, "&lt;");
                         i += 4;
@@ -855,107 +919,125 @@ static QString print_filter(const char *str)
 
 static void expr_print_help(void *data, const char *str)
 {
         ((QString*)data)->append(print_filter(str));
 }
 
 /*
  * display a new help entry as soon as a new menu entry is selected
  */
 void ConfigMainWindow::setHelp(QListViewItem* item)
 {
         struct symbol* sym;
-        struct menu* menu;
+        struct menu* menu = 0;
 
         configList->parent()->lineEdit->hide();
-        if (item) {
-                QString head, debug, help;
+        if (item)
                 menu = ((ConfigItem*)item)->menu;
-                sym = menu->sym;
-                if (sym) {
-                        if (menu->prompt) {
-                                head += "<big><b>";
-                                head += print_filter(menu->prompt->text);
-                                head += "</b></big>";
-                                if (sym->name) {
-                                        head += " (";
-                                        head += print_filter(sym->name);
-                                        head += ")";
-                                }
-                        } else if (sym->name) {
-                                head += "<big><b>";
+        if (!menu) {
+                helpText->setText(NULL);
+                return;
+        }
+
+        QString head, debug, help;
+        menu = ((ConfigItem*)item)->menu;
+        sym = menu->sym;
+        if (sym) {
+                if (menu->prompt) {
+                        head += "<big><b>";
+                        head += print_filter(menu->prompt->text);
+                        head += "</b></big>";
+                        if (sym->name) {
+                                head += " (";
                                 head += print_filter(sym->name);
-                                head += "</b></big>";
+                                head += ")";
                         }
-                        head += "<br><br>";
-
-                        if (showDebug) {
-                                debug += "type: ";
-                                debug += print_filter(sym_type_name(sym->type));
+                } else if (sym->name) {
+                        head += "<big><b>";
+                        head += print_filter(sym->name);
+                        head += "</b></big>";
+                }
+                head += "<br><br>";
+
+                if (showDebug) {
+                        debug += "type: ";
+                        debug += print_filter(sym_type_name(sym->type));
+                        if (sym_is_choice(sym))
+                                debug += " (choice)";
+                        debug += "<br>";
+                        if (sym->rev_dep.expr) {
+                                debug += "reverse dep: ";
+                                expr_print(sym->rev_dep.expr, expr_print_help, &debug, E_NONE);
                                 debug += "<br>";
-                                for (struct property *prop = sym->prop; prop; prop = prop->next) {
-                                        switch (prop->type) {
-                                        case P_PROMPT:
-                                                debug += "prompt: ";
-                                                debug += print_filter(prop->text);
-                                                debug += "<br>";
-                                                if (prop->visible.expr) {
-                                                        debug += "&nbsp;&nbsp;dep: ";
-                                                        expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
-                                                        debug += "<br>";
-                                                }
-                                                break;
-                                        case P_DEFAULT:
-                                                debug += "default: ";
-                                                if (sym_is_choice(sym))
-                                                        debug += print_filter(prop->def->name);
-                                                else {
-                                                        sym_calc_value(prop->def);
-                                                        debug += print_filter(sym_get_string_value(prop->def));
-                                                }
-                                                debug += "<br>";
-                                                if (prop->visible.expr) {
-                                                        debug += "&nbsp;&nbsp;dep: ";
-                                                        expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
-                                                        debug += "<br>";
-                                                }
-                                                break;
-                                        case P_CHOICE:
-                                                break;
-                                        default:
-                                                debug += "unknown property: ";
-                                                debug += prop_get_type_name(prop->type);
+                        }
+                        for (struct property *prop = sym->prop; prop; prop = prop->next) {
+                                switch (prop->type) {
+                                case P_PROMPT:
+                                case P_MENU:
+                                        debug += "prompt: ";
+                                        debug += print_filter(prop->text);
+                                        debug += "<br>";
+                                        break;
+                                case P_DEFAULT:
+                                        debug += "default: ";
+                                        expr_print(prop->expr, expr_print_help, &debug, E_NONE);
+                                        debug += "<br>";
+                                        break;
+                                case P_CHOICE:
+                                        if (sym_is_choice(sym)) {
+                                                debug += "choice: ";
+                                                expr_print(prop->expr, expr_print_help, &debug, E_NONE);
                                                 debug += "<br>";
                                         }
+                                        break;
+                                case P_SELECT:
+                                        debug += "select: ";
+                                        expr_print(prop->expr, expr_print_help, &debug, E_NONE);
+                                        debug += "<br>";
+                                        break;
+                                case P_RANGE:
+                                        debug += "range: ";
+                                        expr_print(prop->expr, expr_print_help, &debug, E_NONE);
+                                        debug += "<br>";
+                                        break;
+                                default:
+                                        debug += "unknown property: ";
+                                        debug += prop_get_type_name(prop->type);
+                                        debug += "<br>";
                                 }
-                                debug += "<br>";
-                        }
-
-                        help = print_filter(sym->help);
-                } else if (menu->prompt) {
-                        head += "<big><b>";
-                        head += print_filter(menu->prompt->text);
-                        head += "</b></big><br><br>";
-                        if (showDebug) {
-                                if (menu->prompt->visible.expr) {
-                                        debug += "&nbsp;&nbsp;dep: ";
-                                        expr_print(menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
+                                if (prop->visible.expr) {
+                                        debug += "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
+                                        expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
                                         debug += "<br>";
                                 }
                         }
+                        debug += "<br>";
+                }
+
+                help = print_filter(sym->help);
+        } else if (menu->prompt) {
+                head += "<big><b>";
+                head += print_filter(menu->prompt->text);
+                head += "</b></big><br><br>";
+                if (showDebug) {
+                        if (menu->prompt->visible.expr) {
+                                debug += "&nbsp;&nbsp;dep: ";
+                                expr_print(menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
+                                debug += "<br><br>";
+                        }
                 }
-                helpText->setText(head + debug + help);
-                return;
         }
-        helpText->setText(NULL);
+        if (showDebug)
+                debug += QString().sprintf("defined at %s:%d<br><br>", menu->file->name, menu->lineno);
+        helpText->setText(head + debug + help);
 }
 
 void ConfigMainWindow::loadConfig(void)
 {
         QString s = QFileDialog::getOpenFileName(".config", NULL, this);
         if (s.isNull())
                 return;
         if (conf_read(s.latin1()))
                 QMessageBox::information(this, "qconf", "Unable to load configuration!");
         ConfigView::updateListAll();
 }
 
@@ -1001,54 +1083,54 @@ void ConfigMainWindow::goBack(void)
         item = (ConfigItem*)menuList->selectedItem();
         while (item) {
                 if (item->menu == configList->rootEntry) {
                         menuList->setSelected(item, TRUE);
                         break;
                 }
                 item = (ConfigItem*)item->parent();
         }
 }
 
 void ConfigMainWindow::showSingleView(void)
 {
-        menuList->hide();
+        menuView->hide();
         menuList->setRootMenu(0);
         configList->mode = singleMode;
         if (configList->rootEntry == &rootmenu)
                 configList->updateListAll();
         else
                 configList->setRootMenu(&rootmenu);
         configList->setAllOpen(TRUE);
         configList->setFocus();
 }
 
 void ConfigMainWindow::showSplitView(void)
 {
         configList->mode = symbolMode;
         if (configList->rootEntry == &rootmenu)
                 configList->updateListAll();
         else
                 configList->setRootMenu(&rootmenu);
         configList->setAllOpen(TRUE);
         configApp->processEvents();
         menuList->mode = menuMode;
         menuList->setRootMenu(&rootmenu);
-        menuList->show();
         menuList->setAllOpen(TRUE);
+        menuView->show();
         menuList->setFocus();
 }
 
 void ConfigMainWindow::showFullView(void)
 {
-        menuList->hide();
+        menuView->hide();
         menuList->setRootMenu(0);
         configList->mode = fullMode;
         if (configList->rootEntry == &rootmenu)
                 configList->updateListAll();
         else
                 configList->setRootMenu(&rootmenu);
         configList->setAllOpen(FALSE);
         configList->setFocus();
 }
 
 void ConfigMainWindow::setShowAll(bool b)
 {
@@ -1064,40 +1146,46 @@ void ConfigMainWindow::setShowDebug(bool b)
 {
         if (showDebug == b)
                 return;
         showDebug = b;
 }
 
 void ConfigMainWindow::setShowName(bool b)
 {
         if (configList->showName == b)
                 return;
         configList->showName = b;
         configList->reinit();
+        menuList->showName = b;
+        menuList->reinit();
 }
 
 void ConfigMainWindow::setShowRange(bool b)
 {
         if (configList->showRange == b)
                 return;
         configList->showRange = b;
         configList->reinit();
+        menuList->showRange = b;
+        menuList->reinit();
 }
 
 void ConfigMainWindow::setShowData(bool b)
 {
         if (configList->showData == b)
                 return;
         configList->showData = b;
         configList->reinit();
+        menuList->showData = b;
+        menuList->reinit();
 }
 
 /*
  * ask for saving configuration before quitting
  * TODO ask only when something changed
  */
 void ConfigMainWindow::closeEvent(QCloseEvent* e)
 {
         if (!sym_change_count) {
                 e->accept();
                 return;
         }
@@ -1137,58 +1225,71 @@ void ConfigMainWindow::showIntro(void)
 
 void ConfigMainWindow::showAbout(void)
 {
         static char str[] = "qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n\n"
                 "Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n";
 
         QMessageBox::information(this, "qconf", str);
 }
 
 void fixup_rootmenu(struct menu *menu)
 {
         struct menu *child;
+        static int menu_cnt = 0;
 
-        if (!menu->prompt || menu->prompt->type != P_MENU)
-                return;
-        menu->prompt->type = P_ROOTMENU;
-        for (child = menu->list; child; child = child->next)
-                fixup_rootmenu(child);
+        menu->flags |= MENU_ROOT;
+        for (child = menu->list; child; child = child->next) {
+                if (child->prompt && child->prompt->type == P_MENU) {
+                        menu_cnt++;
+                        fixup_rootmenu(child);
+                        menu_cnt--;
+                } else if (!menu_cnt)
+                        fixup_rootmenu(child);
+        }
+}
+
+static const char *progname;
+
+static void usage(void)
+{
+        printf("%s <config>\n", progname);
+        exit(0);
 }
 
 int main(int ac, char** av)
 {
         ConfigMainWindow* v;
         const char *name;
 
 #ifndef LKC_DIRECT_LINK
         kconfig_load();
 #endif
 
+        progname = av[0];
         configApp = new QApplication(ac, av);
 #if QT_VERSION >= 300
         configSettings = new QSettings;
 #endif
         if (ac > 1 && av[1][0] == '-') {
                 switch (av[1][1]) {
-                case 'a':
-                        //showAll = 1;
-                        break;
                 case 'h':
                 case '?':
-                        printf("%s <config>\n", av[0]);
-                        exit(0);
+                        usage();
                 }
                 name = av[2];
         } else
                 name = av[1];
+        if (!name)
+                usage();
+
         conf_parse(name);
         fixup_rootmenu(&rootmenu);
         conf_read(NULL);
         //zconfdump(stdout);
 
         v = new ConfigMainWindow();
 
         //zconfdump(stdout);
         v->show();
         configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
         configApp->exec();