Port xconfig to Qt5 - Put back some of the old implementation(part 2).

Signed-off-by: Boris Barbulovski <bbarbulovski@gmail.com>
Signed-off-by: Thiago Macieira <thiago.macieira@intel.com>
Signed-off-by: Michal Marek <mmarek@suse.com>

1 files changed, 780 insertions, 8 deletions

diff --git a/scripts/kconfig/qconf.cc b/scripts/kconfig/qconf.cc
index 0987a751d740..e0518cab500e 100644
--- a/scripts/kconfig/qconf.cc
+++ b/scripts/kconfig/qconf.cc
@@ -102,10 +102,135 @@ void ConfigItem::okRename(int col)
  */
 void ConfigItem::updateMenu(void)
 {
+        ConfigList* list;
+        struct symbol* sym;
+        struct property *prop;
+        QString prompt;
+        int type;
+        tristate expr;
+
+        list = listView();
+        if (goParent) {
+                setPixmap(promptColIdx, list->menuBackPix);
+                prompt = "..";
+                goto set_prompt;
+        }
+
+        sym = menu->sym;
+        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 {
+                        if (sym)
+                                break;
+                        setPixmap(promptColIdx, QIcon());
+                }
+                goto set_prompt;
+        case P_COMMENT:
+                setPixmap(promptColIdx, QIcon());
+                goto set_prompt;
+        default:
+                ;
+        }
+        if (!sym)
+                goto set_prompt;
+
+        setText(nameColIdx, QString::fromLocal8Bit(sym->name));
+
+        type = sym_get_type(sym);
+        switch (type) {
+        case S_BOOLEAN:
+        case S_TRISTATE:
+                char ch;
+
+                if (!sym_is_changable(sym) && list->optMode == normalOpt) {
+                        setPixmap(promptColIdx, QIcon());
+                        setText(noColIdx, QString::null);
+                        setText(modColIdx, QString::null);
+                        setText(yesColIdx, QString::null);
+                        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);
+                        setText(yesColIdx, "Y");
+                        ch = 'Y';
+                        break;
+                case mod:
+                        setPixmap(promptColIdx, list->symbolModPix);
+                        setText(modColIdx, "M");
+                        ch = 'M';
+                        break;
+                default:
+                        if (sym_is_choice_value(sym) && type == S_BOOLEAN)
+                                setPixmap(promptColIdx, list->choiceNoPix);
+                        else
+                                setPixmap(promptColIdx, list->symbolNoPix);
+                        setText(noColIdx, "N");
+                        ch = 'N';
+                        break;
+                }
+                if (expr != no)
+                        setText(noColIdx, sym_tristate_within_range(sym, no) ? "_" : 0);
+                if (expr != mod)
+                        setText(modColIdx, sym_tristate_within_range(sym, mod) ? "_" : 0);
+                if (expr != yes)
+                        setText(yesColIdx, sym_tristate_within_range(sym, yes) ? "_" : 0);
+
+                setText(dataColIdx, QChar(ch));
+                break;
+        case S_INT:
+        case S_HEX:
+        case S_STRING:
+                const char* data;
+
+                data = sym_get_string_value(sym);
+
+                //int i = list->mapIdx(dataColIdx);
+                //if (i >= 0)
+                //      setRenameEnabled(i, true);
+                setText(dataColIdx, data);
+                if (type == S_STRING)
+                        prompt = QString("%1: %2").arg(prompt).arg(data);
+                else
+                        prompt = QString("(%2) %1").arg(prompt).arg(data);
+                break;
+        }
+        if (!sym_has_value(sym) && visible)
+                prompt += _(" (NEW)");
+set_prompt:
+        setText(promptColIdx, prompt);
 }
 
 void ConfigItem::testUpdateMenu(bool v)
 {
+        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;
+                for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
+                        i->updateMenu();
+        } else if (listView()->updateAll)
+                updateMenu();
 }
 
 
@@ -114,6 +239,16 @@ void ConfigItem::testUpdateMenu(bool v)
  */
 void ConfigItem::init(void)
 {
+        if (menu) {
+                ConfigList* list = listView();
+                nextItem = (ConfigItem*)menu->data;
+                menu->data = this;
+
+                if (list->mode != fullMode)
+                        setExpanded(true);
+                sym_calc_value(menu->sym);
+        }
+        updateMenu();
 }
 
 /*
@@ -121,17 +256,30 @@ void ConfigItem::init(void)
  */
 ConfigItem::~ConfigItem(void)
 {
+        if (menu) {
+                ConfigItem** ip = (ConfigItem**)&menu->data;
+                for (; *ip; ip = &(*ip)->nextItem) {
+                        if (*ip == this) {
+                                *ip = nextItem;
+                                break;
+                        }
+                }
+        }
 }
 
 ConfigLineEdit::ConfigLineEdit(ConfigView* parent)
         : Parent(parent)
 {
-        connect(this, SIGNAL(editingFinished()), SLOT(hide()));
+        connect(this, SIGNAL(lostFocus()), SLOT(hide()));
 }
 
 void ConfigLineEdit::show(ConfigItem* i)
 {
         item = i;
+        if (sym_get_string_value(item->menu->sym))
+                setText(QString::fromLocal8Bit(sym_get_string_value(item->menu->sym)));
+        else
+                setText(QString::null);
         Parent::show();
         setFocus();
 }
@@ -143,6 +291,7 @@ void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
                 break;
         case Qt::Key_Return:
         case Qt::Key_Enter:
+                sym_set_string_value(item->menu->sym, text().toLatin1());
                 parent()->updateList(item);
                 break;
         default:
@@ -163,42 +312,251 @@ ConfigList::ConfigList(ConfigView* p, const char *name)
           showName(false), showRange(false), showData(false), optMode(normalOpt),
           rootEntry(0), headerPopup(0)
 {
+        int i;
+
+        setObjectName(name);
+        setSortingEnabled(-1);
+        setRootIsDecorated(true);
+
+        connect(this, SIGNAL(selectionChanged(void)),
+                SLOT(updateSelection(void)));
+
+        if (name) {
+                configSettings->beginGroup(name);
+                showName = configSettings->value("/showName", false).toBool();
+                showRange = configSettings->value("/showRange", false).toBool();
+                showData = configSettings->value("/showData", false).toBool();
+                optMode = (enum optionMode)configSettings->value("/optionMode", 0).toInt();
+                configSettings->endGroup();
+                connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
+        }
+
+        addColumn(promptColIdx);
+
+        reinit();
+}
+
+bool ConfigList::menuSkip(struct menu *menu)
+{
+        if (optMode == normalOpt && menu_is_visible(menu))
+                return false;
+        if (optMode == promptOpt && menu_has_prompt(menu))
+                return false;
+        if (optMode == allOpt)
+                return false;
+        return true;
 }
 
 void ConfigList::reinit(void)
 {
+        removeColumn(dataColIdx);
+        removeColumn(yesColIdx);
+        removeColumn(modColIdx);
+        removeColumn(noColIdx);
+        removeColumn(nameColIdx);
+
+        if (showName)
+                addColumn(nameColIdx);
+        if (showRange) {
+                addColumn(noColIdx);
+                addColumn(modColIdx);
+                addColumn(yesColIdx);
+        }
+        if (showData)
+                addColumn(dataColIdx);
+
+        updateListAll();
 }
 
 void ConfigList::saveSettings(void)
 {
+        if (!objectName().isEmpty()) {
+                configSettings->beginGroup(objectName());
+                configSettings->setValue("/showName", showName);
+                configSettings->setValue("/showRange", showRange);
+                configSettings->setValue("/showData", showData);
+                configSettings->setValue("/optionMode", (int)optMode);
+                configSettings->endGroup();
+        }
 }
 
 ConfigItem* ConfigList::findConfigItem(struct menu *menu)
 {
+        ConfigItem* item = (ConfigItem*)menu->data;
+
+        for (; item; item = item->nextItem) {
+                if (this == item->listView())
+                        break;
+        }
+
+        return item;
 }
 
 void ConfigList::updateSelection(void)
 {
+        struct menu *menu;
+        enum prop_type type;
+
+        ConfigItem* item = (ConfigItem*)selectedItems().first();
+        if (!item)
+                return;
+
+        menu = item->menu;
+        emit menuChanged(menu);
+        if (!menu)
+                return;
+        type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
+        if (mode == menuMode && type == P_MENU)
+                emit menuSelected(menu);
 }
 
 void ConfigList::updateList(ConfigItem* item)
 {
+        ConfigItem* last = 0;
+
+        if (!rootEntry) {
+                if (mode != listMode)
+                        goto update;
+                QTreeWidgetItemIterator it(this);
+                ConfigItem* item;
+
+                while (*it) {
+                        item = (ConfigItem*)(*it);
+                        if (!item->menu)
+                                continue;
+                        item->testUpdateMenu(menu_is_visible(item->menu));
+
+                        ++it;
+                }
+                return;
+        }
+
+        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 || (mode == symbolMode && !(rootEntry->flags & MENU_ROOT))) &&
+            rootEntry->sym && rootEntry->prompt) {
+                item = last ? last->nextSibling() : firstChild();
+                if (!item)
+                        item = new ConfigItem(this, last, rootEntry, true);
+                else
+                        item->testUpdateMenu(true);
+
+                updateMenuList(item, rootEntry);
+                update();
+                return;
+        }
+update:
+        updateMenuList(this, rootEntry);
+        update();
 }
 
 void ConfigList::setValue(ConfigItem* item, tristate val)
 {
+        struct symbol* sym;
+        int type;
+        tristate oldval;
+
+        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)
+                        item->setExpanded(true);
+                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->setExpanded(!item->isExpanded());
+                return;
+        }
+
+        type = sym_get_type(sym);
+        switch (type) {
+        case S_BOOLEAN:
+        case S_TRISTATE:
+                oldexpr = sym_get_tristate_value(sym);
+                newexpr = sym_toggle_tristate_value(sym);
+                if (item->menu->list) {
+                        if (oldexpr == newexpr)
+                                item->setExpanded(!item->isExpanded());
+                        else if (oldexpr == no)
+                                item->setExpanded(true);
+                }
+                if (oldexpr != newexpr)
+                        parent()->updateList(item);
+                break;
+        case S_INT:
+        case S_HEX:
+        case S_STRING:
+                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)
+                return;
+        updateMenuList(this, 0);
+        rootEntry = menu;
+        updateListAll();
+        if (currentItem()) {
+                currentItem()->setSelected(hasFocus());
+                scrollToItem(currentItem());
+        }
 }
 
 void ConfigList::setParentMenu(void)
 {
+        ConfigItem* item;
+        struct menu *oldroot;
+
+        oldroot = rootEntry;
+        if (rootEntry == &rootmenu)
+                return;
+        setRootMenu(menu_get_parent_menu(rootEntry->parent));
+
+        QTreeWidgetItemIterator it(this);
+        while (*it) {
+                item = (ConfigItem *)(*it);
+                if (item->menu == oldroot) {
+                        setCurrentItem(item);
+                        scrollToItem(item);
+                        break;
+                }
+
+                ++it;
+        }
 }
 
 /*
@@ -211,34 +569,250 @@ void ConfigList::setParentMenu(void)
 template <class P>
 void ConfigList::updateMenuList(P* parent, struct menu* menu)
 {
+        struct menu* child;
+        ConfigItem* item;
+        ConfigItem* last;
+        bool visible;
+        enum prop_type type;
+
+        if (!menu) {
+                while ((item = parent->firstChild()))
+                        item->parent()->removeChild(item);
+                        delete item;
+                return;
+        }
+
+        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 (!(child->flags & MENU_ROOT))
+                                goto hide;
+                        break;
+                case symbolMode:
+                        if (child->flags & MENU_ROOT)
+                                goto hide;
+                        break;
+                default:
+                        break;
+                }
+
+                visible = menu_is_visible(child);
+                if (!menuSkip(child)) {
+                        if (!child->sym && !child->list && !child->prompt)
+                                continue;
+                        if (!item || item->menu != child)
+                                item = new ConfigItem(parent, last, child, visible);
+                        else
+                                item->testUpdateMenu(visible);
+
+                        if (mode == fullMode || mode == menuMode || type != P_MENU)
+                                updateMenuList(item, child);
+                        else
+                                updateMenuList(item, 0);
+                        last = item;
+                        continue;
+                }
+        hide:
+                if (item && item->menu == child) {
+                        last = parent->firstChild();
+                        if (last == item)
+                                last = 0;
+                        else while (last->nextSibling() != item)
+                                last = last->nextSibling();
+                        delete item;
+                }
+        }
 }
 
 void ConfigList::keyPressEvent(QKeyEvent* ev)
 {
+        QTreeWidgetItem* i = currentItem();
+        ConfigItem* item;
+        struct menu *menu;
+        enum prop_type type;
+
+        if (ev->key() == Qt::Key_Escape && mode != fullMode && mode != listMode) {
+                emit parentSelected();
+                ev->accept();
+                return;
+        }
+
+        if (!i) {
+                Parent::keyPressEvent(ev);
+                return;
+        }
+        item = (ConfigItem*)i;
+
+        switch (ev->key()) {
+        case Qt::Key_Return:
+        case Qt::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 && rootEntry != menu &&
+                    mode != fullMode && mode != menuMode) {
+                        emit menuSelected(menu);
+                        break;
+                }
+        case Qt::Key_Space:
+                changeValue(item);
+                break;
+        case Qt::Key_N:
+                setValue(item, no);
+                break;
+        case Qt::Key_M:
+                setValue(item, mod);
+                break;
+        case Qt::Key_Y:
+                setValue(item, yes);
+                break;
+        default:
+                Parent::keyPressEvent(ev);
+                return;
+        }
+        ev->accept();
 }
 
-void ConfigList::contentsMousePressEvent(QMouseEvent* e)
+void ConfigList::mousePressEvent(QMouseEvent* e)
 {
+        //QPoint p(contentsToViewport(e->pos()));
+        //printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
+        Parent::mousePressEvent(e);
 }
 
-void ConfigList::contentsMouseReleaseEvent(QMouseEvent* e)
+void ConfigList::mouseReleaseEvent(QMouseEvent* e)
 {
+        QPoint p = e->pos();
+        ConfigItem* item = (ConfigItem*)itemAt(p);
+        struct menu *menu;
+        enum prop_type ptype;
+        QIcon icon;
+        int idx, x;
+
+        if (!item)
+                goto skip;
+
+        menu = item->menu;
+        x = header()->offset() + p.x();
+        idx = header()->sectionPosition(x);
+        switch (idx) {
+        case promptColIdx:
+                icon = item->pixmap(promptColIdx);
+                break;
+        case noColIdx:
+                setValue(item, no);
+                break;
+        case modColIdx:
+                setValue(item, mod);
+                break;
+        case yesColIdx:
+                setValue(item, yes);
+                break;
+        case dataColIdx:
+                changeValue(item);
+                break;
+        }
+
+skip:
+        //printf("contentsMouseReleaseEvent: %d,%d\n", p.x(), p.y());
+        Parent::mouseReleaseEvent(e);
 }
 
-void ConfigList::contentsMouseMoveEvent(QMouseEvent* e)
+void ConfigList::mouseMoveEvent(QMouseEvent* e)
 {
+        //QPoint p(contentsToViewport(e->pos()));
+        //printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
+        Parent::mouseMoveEvent(e);
 }
 
-void ConfigList::contentsMouseDoubleClickEvent(QMouseEvent* e)
+void ConfigList::mouseDoubleClickEvent(QMouseEvent* e)
 {
+        QPoint p = e->pos(); // TODO: Check if this works(was contentsToViewport).
+        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_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::mouseDoubleClickEvent(e);
 }
 
 void ConfigList::focusInEvent(QFocusEvent *e)
 {
+        struct menu *menu = NULL;
+
+        Parent::focusInEvent(e);
+
+        ConfigItem* item = (ConfigItem *)currentItem();
+        if (item) {
+                item->setSelected(true);
+                menu = item->menu;
+        }
+        emit gotFocus(menu);
 }
 
 void ConfigList::contextMenuEvent(QContextMenuEvent *e)
 {
+        if (e->y() <= header()->geometry().bottom()) {
+                if (!headerPopup) {
+                        QAction *action;
+
+                        headerPopup = new QMenu(this);
+                        action = new QAction(_("Show Name"), this);
+                          action->setCheckable(true);
+                          connect(action, SIGNAL(toggled(bool)),
+                                  parent(), SLOT(setShowName(bool)));
+                          connect(parent(), SIGNAL(showNameChanged(bool)),
+                                  action, SLOT(setOn(bool)));
+                          action->setChecked(showName);
+                          headerPopup->addAction(action);
+                        action = new QAction(_("Show Range"), this);
+                          action->setCheckable(true);
+                          connect(action, SIGNAL(toggled(bool)),
+                                  parent(), SLOT(setShowRange(bool)));
+                          connect(parent(), SIGNAL(showRangeChanged(bool)),
+                                  action, SLOT(setOn(bool)));
+                          action->setChecked(showRange);
+                          headerPopup->addAction(action);
+                        action = new QAction(_("Show Data"), this);
+                          action->setCheckable(true);
+                          connect(action, SIGNAL(toggled(bool)),
+                                  parent(), SLOT(setShowData(bool)));
+                          connect(parent(), SIGNAL(showDataChanged(bool)),
+                                  action, SLOT(setOn(bool)));
+                          action->setChecked(showData);
+                          headerPopup->addAction(action);
+                }
+                headerPopup->exec(e->globalPos());
+                e->accept();
+        } else
+                e->ignore();
 }
 
 ConfigView*ConfigView::viewList;
@@ -276,33 +850,78 @@ ConfigView::~ConfigView(void)
 
 void ConfigView::setOptionMode(QAction *act)
 {
+        if (act == showNormalAction)
+                list->optMode = normalOpt;
+        else if (act == showAllAction)
+                list->optMode = allOpt;
+        else
+                list->optMode = promptOpt;
+
+        list->updateListAll();
 }
 
 void ConfigView::setShowName(bool b)
 {
+        if (list->showName != b) {
+                list->showName = b;
+                list->reinit();
+                emit showNameChanged(b);
+        }
 }
 
 void ConfigView::setShowRange(bool b)
 {
+        if (list->showRange != b) {
+                list->showRange = b;
+                list->reinit();
+                emit showRangeChanged(b);
+        }
 }
 
 void ConfigView::setShowData(bool b)
 {
+        if (list->showData != b) {
+                list->showData = b;
+                list->reinit();
+                emit showDataChanged(b);
+        }
+}
+
+void ConfigList::setAllOpen(bool open)
+{
+        QTreeWidgetItemIterator it(this);
+
+        while (*it) {
+                (*it)->setExpanded(open);
+
+                ++it;
+        }
 }
 
 void ConfigView::updateList(ConfigItem* item)
 {
+        ConfigView* v;
+
+        for (v = viewList; v; v = v->nextView)
+                v->list->updateList(item);
 }
 
 void ConfigView::updateListAll(void)
 {
+        ConfigView* v;
+
+        for (v = viewList; v; v = v->nextView)
+                v->list->updateListAll();
 }
 
 ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
         : Parent(parent), sym(0), _menu(0)
 {
-        if (name) {
-                configSettings->beginGroup(name);
+        setObjectName(name);
+
+
+        if (!objectName().isEmpty()) {
+                configSettings->beginGroup(objectName());
                 _showDebug = configSettings->value("/showDebug", false).toBool();
                 configSettings->endGroup();
                 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
@@ -311,6 +930,11 @@ ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
 
 void ConfigInfoView::saveSettings(void)
 {
+        if (!objectName().isEmpty()) {
+                configSettings->beginGroup(objectName());
+                configSettings->setValue("/showDebug", showDebug());
+                configSettings->endGroup();
+        }
 }
 
 void ConfigInfoView::setShowDebug(bool b)
@@ -528,6 +1152,7 @@ void ConfigInfoView::contextMenuEvent(QContextMenuEvent *e)
 ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *name)
         : Parent(parent), result(NULL)
 {
+        setObjectName(name);
         setWindowTitle("Search Config");
 
         QVBoxLayout* layout1 = new QVBoxLayout(this);
@@ -549,6 +1174,7 @@ ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *nam
         split = new QSplitter(this);
         split->setOrientation(Qt::Vertical);
         list = new ConfigView(split, name);
+        list->list->mode = listMode;
         info = new ConfigInfoView(split, name);
         connect(list->list, SIGNAL(menuChanged(struct menu *)),
                 info, SLOT(setInfo(struct menu *)));
@@ -580,10 +1206,35 @@ ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *nam
 
 void ConfigSearchWindow::saveSettings(void)
 {
+        if (!objectName().isEmpty()) {
+                configSettings->beginGroup(objectName());
+                configSettings->setValue("/window x", pos().x());
+                configSettings->setValue("/window y", pos().y());
+                configSettings->setValue("/window width", size().width());
+                configSettings->setValue("/window height", size().height());
+                configSettings->writeSizes("/split", split->sizes());
+                configSettings->endGroup();
+        }
 }
 
 void ConfigSearchWindow::search(void)
 {
+        struct symbol **p;
+        struct property *prop;
+        ConfigItem *lastItem = NULL;
+
+        free(result);
+        list->list->clear();
+        info->clear();
+
+        result = sym_re_search(editField->text().toLatin1());
+        if (!result)
+                return;
+        for (p = result; *p; p++) {
+                for_all_prompts((*p), prop)
+                        lastItem = new ConfigItem(list->list, lastItem, prop->menu,
+                                                  menu_is_visible(prop->menu));
+        }
 }
 
 /*
@@ -739,6 +1390,23 @@ ConfigMainWindow::ConfigMainWindow(void)
         helpMenu->addAction(showIntroAction);
         helpMenu->addAction(showAboutAction);
 
+        connect(configList, SIGNAL(menuChanged(struct menu *)),
+                helpText, SLOT(setInfo(struct menu *)));
+        connect(configList, SIGNAL(menuSelected(struct menu *)),
+                SLOT(changeMenu(struct menu *)));
+        connect(configList, SIGNAL(parentSelected()),
+                SLOT(goBack()));
+        connect(menuList, SIGNAL(menuChanged(struct menu *)),
+                helpText, SLOT(setInfo(struct menu *)));
+        connect(menuList, SIGNAL(menuSelected(struct menu *)),
+                SLOT(changeMenu(struct menu *)));
+
+        connect(configList, SIGNAL(gotFocus(struct menu *)),
+                helpText, SLOT(setInfo(struct menu *)));
+        connect(menuList, SIGNAL(gotFocus(struct menu *)),
+                helpText, SLOT(setInfo(struct menu *)));
+        connect(menuList, SIGNAL(gotFocus(struct menu *)),
+                SLOT(listFocusChanged(void)));
         connect(helpText, SIGNAL(menuSelected(struct menu *)),
                 SLOT(setMenuLink(struct menu *)));
 
@@ -796,19 +1464,86 @@ void ConfigMainWindow::searchConfig(void)
 
 void ConfigMainWindow::changeMenu(struct menu *menu)
 {
-
+        configList->setRootMenu(menu);
+        if (configList->rootEntry->parent == &rootmenu)
+                backAction->setEnabled(false);
+        else
+                backAction->setEnabled(true);
 }
 
 void ConfigMainWindow::setMenuLink(struct menu *menu)
 {
+        struct menu *parent;
+        ConfigList* list = NULL;
+        ConfigItem* item;
+
+        if (configList->menuSkip(menu))
+                return;
+
+        switch (configList->mode) {
+        case singleMode:
+                list = configList;
+                parent = menu_get_parent_menu(menu);
+                if (!parent)
+                        return;
+                list->setRootMenu(parent);
+                break;
+        case symbolMode:
+                if (menu->flags & MENU_ROOT) {
+                        configList->setRootMenu(menu);
+                        configList->clearSelection();
+                        list = menuList;
+                } else {
+                        list = configList;
+                        parent = menu_get_parent_menu(menu->parent);
+                        if (!parent)
+                                return;
+                        item = menuList->findConfigItem(parent);
+                        if (item) {
+                                item->setSelected(true);
+                                menuList->scrollToItem(item);
+                        }
+                        list->setRootMenu(parent);
+                }
+                break;
+        case fullMode:
+                list = configList;
+                break;
+        default:
+                break;
+        }
+
+        if (list) {
+                item = list->findConfigItem(menu);
+                if (item) {
+                        item->setSelected(true);
+                        list->scrollToItem(item);
+                        list->setFocus();
+                }
+        }
 }
 
 void ConfigMainWindow::listFocusChanged(void)
 {
+        if (menuList->mode == menuMode)
+                configList->clearSelection();
 }
 
 void ConfigMainWindow::goBack(void)
 {
+        ConfigItem* item;
+
+        configList->setParentMenu();
+        if (configList->rootEntry == &rootmenu)
+                backAction->setEnabled(false);
+        item = (ConfigItem*)menuList->selectedItems().first();
+        while (item) {
+                if (item->menu == configList->rootEntry) {
+                        item->setSelected(true);
+                        break;
+                }
+                item = (ConfigItem*)item->parent();
+        }
 }
 
 void ConfigMainWindow::showSingleView(void)
@@ -821,6 +1556,12 @@ void ConfigMainWindow::showSingleView(void)
         fullViewAction->setChecked(false);
 
         menuView->hide();
+        menuList->setRootMenu(0);
+        configList->mode = singleMode;
+        if (configList->rootEntry == &rootmenu)
+                configList->updateListAll();
+        else
+                configList->setRootMenu(&rootmenu);
         configList->setFocus();
 }
 
@@ -833,6 +1574,16 @@ void ConfigMainWindow::showSplitView(void)
         fullViewAction->setEnabled(true);
         fullViewAction->setChecked(false);
 
+        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->setAllOpen(true);
         menuView->show();
         menuList->setFocus();
 }
@@ -847,6 +1598,12 @@ void ConfigMainWindow::showFullView(void)
         fullViewAction->setChecked(true);
 
         menuView->hide();
+        menuList->setRootMenu(0);
+        configList->mode = fullMode;
+        if (configList->rootEntry == &rootmenu)
+                configList->updateListAll();
+        else
+                configList->setRootMenu(&rootmenu);
         configList->setFocus();
 }
 
@@ -914,7 +1671,22 @@ void ConfigMainWindow::saveSettings(void)
         configSettings->setValue("/window height", size().height());
 
         QString entry;
+        switch(configList->mode) {
+        case singleMode :
+                entry = "single";
+                break;
+
+        case symbolMode :
+                entry = "split";
+                break;
+
+        case fullMode :
+                entry = "full";
+                break;
 
+        default:
+                break;
+        }
         configSettings->setValue("/listMode", entry);
 
         configSettings->writeSizes("/split1", split1->sizes());