xref: /linux/scripts/kconfig/qconf.cc (revision 30e48a75df9c6ead93866bdf1511ca6ecfe17fbe) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
4  * Copyright (C) 2015 Boris Barbulovski <bbarbulovski@gmail.com>
5  */
6 
7 #include <QAction>
8 #include <QActionGroup>
9 #include <QApplication>
10 #include <QCloseEvent>
11 #include <QDebug>
12 #include <QFileDialog>
13 #include <QLabel>
14 #include <QLayout>
15 #include <QList>
16 #include <QMenu>
17 #include <QMenuBar>
18 #include <QMessageBox>
19 #include <QRegularExpression>
20 #include <QScreen>
21 #include <QToolBar>
22 
23 #include <stdlib.h>
24 
25 #include "lkc.h"
26 #include "qconf.h"
27 
28 #include "images.h"
29 
30 
31 static QApplication *configApp;
32 static ConfigSettings *configSettings;
33 
34 QAction *ConfigMainWindow::saveAction;
35 
36 ConfigSettings::ConfigSettings()
37 	: QSettings("kernel.org", "qconf")
38 {
39 }
40 
41 /**
42  * Reads a list of integer values from the application settings.
43  */
44 QList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
45 {
46 	QList<int> result;
47 
48 	if (contains(key))
49 	{
50 		QStringList entryList = value(key).toStringList();
51 		QStringList::Iterator it;
52 
53 		for (it = entryList.begin(); it != entryList.end(); ++it)
54 			result.push_back((*it).toInt());
55 
56 		*ok = true;
57 	}
58 	else
59 		*ok = false;
60 
61 	return result;
62 }
63 
64 /**
65  * Writes a list of integer values to the application settings.
66  */
67 bool ConfigSettings::writeSizes(const QString& key, const QList<int>& value)
68 {
69 	QStringList stringList;
70 	QList<int>::ConstIterator it;
71 
72 	for (it = value.begin(); it != value.end(); ++it)
73 		stringList.push_back(QString::number(*it));
74 	setValue(key, stringList);
75 
76 	return true;
77 }
78 
79 QIcon ConfigItem::symbolYesIcon;
80 QIcon ConfigItem::symbolModIcon;
81 QIcon ConfigItem::symbolNoIcon;
82 QIcon ConfigItem::choiceYesIcon;
83 QIcon ConfigItem::choiceNoIcon;
84 QIcon ConfigItem::menuIcon;
85 QIcon ConfigItem::menubackIcon;
86 
87 /*
88  * update the displayed of a menu entry
89  */
90 void ConfigItem::updateMenu(void)
91 {
92 	ConfigList* list;
93 	struct symbol* sym;
94 	struct property *prop;
95 	QString prompt;
96 	int type;
97 	tristate expr;
98 
99 	list = listView();
100 	if (goParent) {
101 		setIcon(promptColIdx, menubackIcon);
102 		prompt = "..";
103 		goto set_prompt;
104 	}
105 
106 	sym = menu->sym;
107 	prop = menu->prompt;
108 	prompt = menu_get_prompt(menu);
109 
110 	if (prop) switch (prop->type) {
111 	case P_MENU:
112 		if (list->mode == singleMode || list->mode == symbolMode) {
113 			/* a menuconfig entry is displayed differently
114 			 * depending whether it's at the view root or a child.
115 			 */
116 			if (sym && list->rootEntry == menu)
117 				break;
118 			setIcon(promptColIdx, menuIcon);
119 		} else {
120 			if (sym)
121 				break;
122 			setIcon(promptColIdx, QIcon());
123 		}
124 		goto set_prompt;
125 	case P_COMMENT:
126 		setIcon(promptColIdx, QIcon());
127 		prompt = "*** " + prompt + " ***";
128 		goto set_prompt;
129 	default:
130 		;
131 	}
132 	if (!sym)
133 		goto set_prompt;
134 
135 	setText(nameColIdx, sym->name);
136 
137 	type = sym_get_type(sym);
138 	switch (type) {
139 	case S_BOOLEAN:
140 	case S_TRISTATE:
141 		char ch;
142 
143 		if (!sym_is_changeable(sym) && list->optMode == normalOpt) {
144 			setIcon(promptColIdx, QIcon());
145 			break;
146 		}
147 		expr = sym_get_tristate_value(sym);
148 		switch (expr) {
149 		case yes:
150 			if (sym_is_choice_value(sym))
151 				setIcon(promptColIdx, choiceYesIcon);
152 			else
153 				setIcon(promptColIdx, symbolYesIcon);
154 			ch = 'Y';
155 			break;
156 		case mod:
157 			setIcon(promptColIdx, symbolModIcon);
158 			ch = 'M';
159 			break;
160 		default:
161 			if (sym_is_choice_value(sym) && type == S_BOOLEAN)
162 				setIcon(promptColIdx, choiceNoIcon);
163 			else
164 				setIcon(promptColIdx, symbolNoIcon);
165 			ch = 'N';
166 			break;
167 		}
168 
169 		setText(dataColIdx, QChar(ch));
170 		break;
171 	case S_INT:
172 	case S_HEX:
173 	case S_STRING:
174 		setText(dataColIdx, sym_get_string_value(sym));
175 		break;
176 	}
177 	if (!sym_has_value(sym) && visible)
178 		prompt += " (NEW)";
179 set_prompt:
180 	setText(promptColIdx, prompt);
181 }
182 
183 void ConfigItem::testUpdateMenu(bool v)
184 {
185 	ConfigItem* i;
186 
187 	visible = v;
188 	if (!menu)
189 		return;
190 
191 	sym_calc_value(menu->sym);
192 	if (menu->flags & MENU_CHANGED) {
193 		/* the menu entry changed, so update all list items */
194 		menu->flags &= ~MENU_CHANGED;
195 		for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
196 			i->updateMenu();
197 	} else if (listView()->updateAll)
198 		updateMenu();
199 }
200 
201 
202 /*
203  * construct a menu entry
204  */
205 void ConfigItem::init(void)
206 {
207 	if (menu) {
208 		ConfigList* list = listView();
209 		nextItem = (ConfigItem*)menu->data;
210 		menu->data = this;
211 
212 		if (list->mode != fullMode)
213 			setExpanded(true);
214 		sym_calc_value(menu->sym);
215 
216 		if (menu->sym) {
217 			enum symbol_type type = menu->sym->type;
218 
219 			// Allow to edit "int", "hex", and "string" in-place in
220 			// the data column. Unfortunately, you cannot specify
221 			// the flags per column. Set ItemIsEditable for all
222 			// columns here, and check the column in createEditor().
223 			if (type == S_INT || type == S_HEX || type == S_STRING)
224 				setFlags(flags() | Qt::ItemIsEditable);
225 		}
226 	}
227 	updateMenu();
228 }
229 
230 /*
231  * destruct a menu entry
232  */
233 ConfigItem::~ConfigItem(void)
234 {
235 	if (menu) {
236 		ConfigItem** ip = (ConfigItem**)&menu->data;
237 		for (; *ip; ip = &(*ip)->nextItem) {
238 			if (*ip == this) {
239 				*ip = nextItem;
240 				break;
241 			}
242 		}
243 	}
244 }
245 
246 QWidget *ConfigItemDelegate::createEditor(QWidget *parent,
247 					  const QStyleOptionViewItem &option,
248 					  const QModelIndex &index) const
249 {
250 	ConfigItem *item;
251 
252 	// Only the data column is editable
253 	if (index.column() != dataColIdx)
254 		return nullptr;
255 
256 	// You cannot edit invisible menus
257 	item = static_cast<ConfigItem *>(index.internalPointer());
258 	if (!item || !item->menu || !menu_is_visible(item->menu))
259 		return nullptr;
260 
261 	return QStyledItemDelegate::createEditor(parent, option, index);
262 }
263 
264 void ConfigItemDelegate::setModelData(QWidget *editor,
265 				      QAbstractItemModel *model,
266 				      const QModelIndex &index) const
267 {
268 	QLineEdit *lineEdit;
269 	ConfigItem *item;
270 	struct symbol *sym;
271 	bool success;
272 
273 	lineEdit = qobject_cast<QLineEdit *>(editor);
274 	// If this is not a QLineEdit, use the parent's default.
275 	// (does this happen?)
276 	if (!lineEdit)
277 		goto parent;
278 
279 	item = static_cast<ConfigItem *>(index.internalPointer());
280 	if (!item || !item->menu)
281 		goto parent;
282 
283 	sym = item->menu->sym;
284 	if (!sym)
285 		goto parent;
286 
287 	success = sym_set_string_value(sym, lineEdit->text().toUtf8().data());
288 	if (success) {
289 		ConfigList::updateListForAll();
290 	} else {
291 		QMessageBox::information(editor, "qconf",
292 			"Cannot set the data (maybe due to out of range).\n"
293 			"Setting the old value.");
294 		lineEdit->setText(sym_get_string_value(sym));
295 	}
296 
297 parent:
298 	QStyledItemDelegate::setModelData(editor, model, index);
299 }
300 
301 ConfigList::ConfigList(QWidget *parent, const char *name)
302 	: QTreeWidget(parent),
303 	  updateAll(false),
304 	  showName(false), mode(singleMode), optMode(normalOpt),
305 	  rootEntry(0), headerPopup(0)
306 {
307 	setObjectName(name);
308 	setSortingEnabled(false);
309 	setRootIsDecorated(true);
310 
311 	setVerticalScrollMode(ScrollPerPixel);
312 	setHorizontalScrollMode(ScrollPerPixel);
313 
314 	setHeaderLabels(QStringList() << "Option" << "Name" << "Value");
315 
316 	connect(this, &ConfigList::itemSelectionChanged,
317 		this, &ConfigList::updateSelection);
318 
319 	if (name) {
320 		configSettings->beginGroup(name);
321 		showName = configSettings->value("/showName", false).toBool();
322 		optMode = (enum optionMode)configSettings->value("/optionMode", 0).toInt();
323 		configSettings->endGroup();
324 		connect(configApp, &QApplication::aboutToQuit,
325 			this, &ConfigList::saveSettings);
326 	}
327 
328 	showColumn(promptColIdx);
329 
330 	setItemDelegate(new ConfigItemDelegate(this));
331 
332 	allLists.append(this);
333 
334 	reinit();
335 }
336 
337 ConfigList::~ConfigList()
338 {
339 	allLists.removeOne(this);
340 }
341 
342 bool ConfigList::menuSkip(struct menu *menu)
343 {
344 	if (optMode == normalOpt && menu_is_visible(menu))
345 		return false;
346 	if (optMode == promptOpt && menu_has_prompt(menu))
347 		return false;
348 	if (optMode == allOpt)
349 		return false;
350 	return true;
351 }
352 
353 void ConfigList::reinit(void)
354 {
355 	hideColumn(nameColIdx);
356 
357 	if (showName)
358 		showColumn(nameColIdx);
359 
360 	updateListAll();
361 }
362 
363 void ConfigList::setOptionMode(QAction *action)
364 {
365 	if (action == showNormalAction)
366 		optMode = normalOpt;
367 	else if (action == showAllAction)
368 		optMode = allOpt;
369 	else
370 		optMode = promptOpt;
371 
372 	updateListAll();
373 }
374 
375 void ConfigList::saveSettings(void)
376 {
377 	if (!objectName().isEmpty()) {
378 		configSettings->beginGroup(objectName());
379 		configSettings->setValue("/showName", showName);
380 		configSettings->setValue("/optionMode", (int)optMode);
381 		configSettings->endGroup();
382 	}
383 }
384 
385 ConfigItem* ConfigList::findConfigItem(struct menu *menu)
386 {
387 	ConfigItem* item = (ConfigItem*)menu->data;
388 
389 	for (; item; item = item->nextItem) {
390 		if (this == item->listView())
391 			break;
392 	}
393 
394 	return item;
395 }
396 
397 void ConfigList::updateSelection(void)
398 {
399 	struct menu *menu;
400 	enum prop_type type;
401 
402 	if (selectedItems().count() == 0)
403 		return;
404 
405 	ConfigItem* item = (ConfigItem*)selectedItems().first();
406 	if (!item)
407 		return;
408 
409 	menu = item->menu;
410 	emit menuChanged(menu);
411 	if (!menu)
412 		return;
413 	type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
414 	if (mode == menuMode && type == P_MENU)
415 		emit menuSelected(menu);
416 }
417 
418 void ConfigList::updateList()
419 {
420 	ConfigItem* last = 0;
421 	ConfigItem *item;
422 
423 	if (!rootEntry) {
424 		if (mode != listMode)
425 			goto update;
426 		QTreeWidgetItemIterator it(this);
427 
428 		while (*it) {
429 			item = (ConfigItem*)(*it);
430 			if (!item->menu)
431 				continue;
432 			item->testUpdateMenu(menu_is_visible(item->menu));
433 
434 			++it;
435 		}
436 		return;
437 	}
438 
439 	if (rootEntry != &rootmenu && (mode == singleMode ||
440 	    (mode == symbolMode && rootEntry->parent != &rootmenu))) {
441 		item = (ConfigItem *)topLevelItem(0);
442 		if (!item)
443 			item = new ConfigItem(this, 0, true);
444 		last = item;
445 	}
446 	if ((mode == singleMode || (mode == symbolMode && !(rootEntry->flags & MENU_ROOT))) &&
447 	    rootEntry->sym && rootEntry->prompt) {
448 		item = last ? last->nextSibling() : nullptr;
449 		if (!item)
450 			item = new ConfigItem(this, last, rootEntry, true);
451 		else
452 			item->testUpdateMenu(true);
453 
454 		updateMenuList(item, rootEntry);
455 		update();
456 		resizeColumnToContents(0);
457 		return;
458 	}
459 update:
460 	updateMenuList(rootEntry);
461 	update();
462 	resizeColumnToContents(0);
463 }
464 
465 void ConfigList::updateListForAll()
466 {
467 	QListIterator<ConfigList *> it(allLists);
468 
469 	while (it.hasNext()) {
470 		ConfigList *list = it.next();
471 
472 		list->updateList();
473 	}
474 }
475 
476 void ConfigList::updateListAllForAll()
477 {
478 	QListIterator<ConfigList *> it(allLists);
479 
480 	while (it.hasNext()) {
481 		ConfigList *list = it.next();
482 
483 		list->updateList();
484 	}
485 }
486 
487 void ConfigList::setValue(ConfigItem* item, tristate val)
488 {
489 	struct symbol* sym;
490 	int type;
491 	tristate oldval;
492 
493 	sym = item->menu ? item->menu->sym : 0;
494 	if (!sym)
495 		return;
496 
497 	type = sym_get_type(sym);
498 	switch (type) {
499 	case S_BOOLEAN:
500 	case S_TRISTATE:
501 		oldval = sym_get_tristate_value(sym);
502 
503 		if (!sym_set_tristate_value(sym, val))
504 			return;
505 		if (oldval == no && item->menu->list)
506 			item->setExpanded(true);
507 		ConfigList::updateListForAll();
508 		break;
509 	}
510 }
511 
512 void ConfigList::changeValue(ConfigItem* item)
513 {
514 	struct symbol* sym;
515 	struct menu* menu;
516 	int type, oldexpr, newexpr;
517 
518 	menu = item->menu;
519 	if (!menu)
520 		return;
521 	sym = menu->sym;
522 	if (!sym) {
523 		if (item->menu->list)
524 			item->setExpanded(!item->isExpanded());
525 		return;
526 	}
527 
528 	type = sym_get_type(sym);
529 	switch (type) {
530 	case S_BOOLEAN:
531 	case S_TRISTATE:
532 		oldexpr = sym_get_tristate_value(sym);
533 		newexpr = sym_toggle_tristate_value(sym);
534 		if (item->menu->list) {
535 			if (oldexpr == newexpr)
536 				item->setExpanded(!item->isExpanded());
537 			else if (oldexpr == no)
538 				item->setExpanded(true);
539 		}
540 		if (oldexpr != newexpr)
541 			ConfigList::updateListForAll();
542 		break;
543 	default:
544 		break;
545 	}
546 }
547 
548 void ConfigList::setRootMenu(struct menu *menu)
549 {
550 	enum prop_type type;
551 
552 	if (rootEntry == menu)
553 		return;
554 	type = menu && menu->prompt ? menu->prompt->type : P_UNKNOWN;
555 	if (type != P_MENU)
556 		return;
557 	updateMenuList(0);
558 	rootEntry = menu;
559 	updateListAll();
560 	if (currentItem()) {
561 		setSelected(currentItem(), hasFocus());
562 		scrollToItem(currentItem());
563 	}
564 }
565 
566 void ConfigList::setParentMenu(void)
567 {
568 	ConfigItem* item;
569 	struct menu *oldroot;
570 
571 	oldroot = rootEntry;
572 	if (rootEntry == &rootmenu)
573 		return;
574 	setRootMenu(menu_get_parent_menu(rootEntry->parent));
575 
576 	QTreeWidgetItemIterator it(this);
577 	while (*it) {
578 		item = (ConfigItem *)(*it);
579 		if (item->menu == oldroot) {
580 			setCurrentItem(item);
581 			scrollToItem(item);
582 			break;
583 		}
584 
585 		++it;
586 	}
587 }
588 
589 /*
590  * update all the children of a menu entry
591  *   removes/adds the entries from the parent widget as necessary
592  *
593  * parent: either the menu list widget or a menu entry widget
594  * menu: entry to be updated
595  */
596 void ConfigList::updateMenuList(ConfigItem *parent, struct menu* menu)
597 {
598 	struct menu* child;
599 	ConfigItem* item;
600 	ConfigItem* last;
601 	bool visible;
602 	enum prop_type type;
603 
604 	if (!menu) {
605 		while (parent->childCount() > 0)
606 		{
607 			delete parent->takeChild(0);
608 		}
609 
610 		return;
611 	}
612 
613 	last = parent->firstChild();
614 	if (last && !last->goParent)
615 		last = 0;
616 	for (child = menu->list; child; child = child->next) {
617 		item = last ? last->nextSibling() : parent->firstChild();
618 		type = child->prompt ? child->prompt->type : P_UNKNOWN;
619 
620 		switch (mode) {
621 		case menuMode:
622 			if (!(child->flags & MENU_ROOT))
623 				goto hide;
624 			break;
625 		case symbolMode:
626 			if (child->flags & MENU_ROOT)
627 				goto hide;
628 			break;
629 		default:
630 			break;
631 		}
632 
633 		visible = menu_is_visible(child);
634 		if (!menuSkip(child)) {
635 			if (!child->sym && !child->list && !child->prompt)
636 				continue;
637 			if (!item || item->menu != child)
638 				item = new ConfigItem(parent, last, child, visible);
639 			else
640 				item->testUpdateMenu(visible);
641 
642 			if (mode == fullMode || mode == menuMode || type != P_MENU)
643 				updateMenuList(item, child);
644 			else
645 				updateMenuList(item, 0);
646 			last = item;
647 			continue;
648 		}
649 hide:
650 		if (item && item->menu == child) {
651 			last = parent->firstChild();
652 			if (last == item)
653 				last = 0;
654 			else while (last->nextSibling() != item)
655 				last = last->nextSibling();
656 			delete item;
657 		}
658 	}
659 }
660 
661 void ConfigList::updateMenuList(struct menu *menu)
662 {
663 	struct menu* child;
664 	ConfigItem* item;
665 	ConfigItem* last;
666 	bool visible;
667 	enum prop_type type;
668 
669 	if (!menu) {
670 		while (topLevelItemCount() > 0)
671 		{
672 			delete takeTopLevelItem(0);
673 		}
674 
675 		return;
676 	}
677 
678 	last = (ConfigItem *)topLevelItem(0);
679 	if (last && !last->goParent)
680 		last = 0;
681 	for (child = menu->list; child; child = child->next) {
682 		item = last ? last->nextSibling() : (ConfigItem *)topLevelItem(0);
683 		type = child->prompt ? child->prompt->type : P_UNKNOWN;
684 
685 		switch (mode) {
686 		case menuMode:
687 			if (!(child->flags & MENU_ROOT))
688 				goto hide;
689 			break;
690 		case symbolMode:
691 			if (child->flags & MENU_ROOT)
692 				goto hide;
693 			break;
694 		default:
695 			break;
696 		}
697 
698 		visible = menu_is_visible(child);
699 		if (!menuSkip(child)) {
700 			if (!child->sym && !child->list && !child->prompt)
701 				continue;
702 			if (!item || item->menu != child)
703 				item = new ConfigItem(this, last, child, visible);
704 			else
705 				item->testUpdateMenu(visible);
706 
707 			if (mode == fullMode || mode == menuMode || type != P_MENU)
708 				updateMenuList(item, child);
709 			else
710 				updateMenuList(item, 0);
711 			last = item;
712 			continue;
713 		}
714 hide:
715 		if (item && item->menu == child) {
716 			last = (ConfigItem *)topLevelItem(0);
717 			if (last == item)
718 				last = 0;
719 			else while (last->nextSibling() != item)
720 				last = last->nextSibling();
721 			delete item;
722 		}
723 	}
724 }
725 
726 void ConfigList::keyPressEvent(QKeyEvent* ev)
727 {
728 	QTreeWidgetItem* i = currentItem();
729 	ConfigItem* item;
730 	struct menu *menu;
731 	enum prop_type type;
732 
733 	if (ev->key() == Qt::Key_Escape && mode != fullMode && mode != listMode) {
734 		emit parentSelected();
735 		ev->accept();
736 		return;
737 	}
738 
739 	if (!i) {
740 		Parent::keyPressEvent(ev);
741 		return;
742 	}
743 	item = (ConfigItem*)i;
744 
745 	switch (ev->key()) {
746 	case Qt::Key_Return:
747 	case Qt::Key_Enter:
748 		if (item->goParent) {
749 			emit parentSelected();
750 			break;
751 		}
752 		menu = item->menu;
753 		if (!menu)
754 			break;
755 		type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
756 		if (type == P_MENU && rootEntry != menu &&
757 		    mode != fullMode && mode != menuMode) {
758 			if (mode == menuMode)
759 				emit menuSelected(menu);
760 			else
761 				emit itemSelected(menu);
762 			break;
763 		}
764 	case Qt::Key_Space:
765 		changeValue(item);
766 		break;
767 	case Qt::Key_N:
768 		setValue(item, no);
769 		break;
770 	case Qt::Key_M:
771 		setValue(item, mod);
772 		break;
773 	case Qt::Key_Y:
774 		setValue(item, yes);
775 		break;
776 	default:
777 		Parent::keyPressEvent(ev);
778 		return;
779 	}
780 	ev->accept();
781 }
782 
783 void ConfigList::mousePressEvent(QMouseEvent* e)
784 {
785 	//QPoint p(contentsToViewport(e->pos()));
786 	//printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
787 	Parent::mousePressEvent(e);
788 }
789 
790 void ConfigList::mouseReleaseEvent(QMouseEvent* e)
791 {
792 	QPoint p = e->pos();
793 	ConfigItem* item = (ConfigItem*)itemAt(p);
794 	struct menu *menu;
795 	enum prop_type ptype;
796 	QIcon icon;
797 	int idx, x;
798 
799 	if (!item)
800 		goto skip;
801 
802 	menu = item->menu;
803 	x = header()->offset() + p.x();
804 	idx = header()->logicalIndexAt(x);
805 	switch (idx) {
806 	case promptColIdx:
807 		icon = item->icon(promptColIdx);
808 		if (!icon.isNull()) {
809 			int off = header()->sectionPosition(0) + visualRect(indexAt(p)).x() + 4; // 4 is Hardcoded image offset. There might be a way to do it properly.
810 			if (x >= off && x < off + icon.availableSizes().first().width()) {
811 				if (item->goParent) {
812 					emit parentSelected();
813 					break;
814 				} else if (!menu)
815 					break;
816 				ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
817 				if (ptype == P_MENU && rootEntry != menu &&
818 				    mode != fullMode && mode != menuMode &&
819                                     mode != listMode)
820 					emit menuSelected(menu);
821 				else
822 					changeValue(item);
823 			}
824 		}
825 		break;
826 	case dataColIdx:
827 		changeValue(item);
828 		break;
829 	}
830 
831 skip:
832 	//printf("contentsMouseReleaseEvent: %d,%d\n", p.x(), p.y());
833 	Parent::mouseReleaseEvent(e);
834 }
835 
836 void ConfigList::mouseMoveEvent(QMouseEvent* e)
837 {
838 	//QPoint p(contentsToViewport(e->pos()));
839 	//printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
840 	Parent::mouseMoveEvent(e);
841 }
842 
843 void ConfigList::mouseDoubleClickEvent(QMouseEvent* e)
844 {
845 	QPoint p = e->pos();
846 	ConfigItem* item = (ConfigItem*)itemAt(p);
847 	struct menu *menu;
848 	enum prop_type ptype;
849 
850 	if (!item)
851 		goto skip;
852 	if (item->goParent) {
853 		emit parentSelected();
854 		goto skip;
855 	}
856 	menu = item->menu;
857 	if (!menu)
858 		goto skip;
859 	ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
860 	if (ptype == P_MENU && mode != listMode) {
861 		if (mode == singleMode)
862 			emit itemSelected(menu);
863 		else if (mode == symbolMode)
864 			emit menuSelected(menu);
865 	} else if (menu->sym)
866 		changeValue(item);
867 
868 skip:
869 	//printf("contentsMouseDoubleClickEvent: %d,%d\n", p.x(), p.y());
870 	Parent::mouseDoubleClickEvent(e);
871 }
872 
873 void ConfigList::focusInEvent(QFocusEvent *e)
874 {
875 	struct menu *menu = NULL;
876 
877 	Parent::focusInEvent(e);
878 
879 	ConfigItem* item = (ConfigItem *)currentItem();
880 	if (item) {
881 		setSelected(item, true);
882 		menu = item->menu;
883 	}
884 	emit gotFocus(menu);
885 }
886 
887 void ConfigList::contextMenuEvent(QContextMenuEvent *e)
888 {
889 	if (!headerPopup) {
890 		QAction *action;
891 
892 		headerPopup = new QMenu(this);
893 		action = new QAction("Show Name", this);
894 		action->setCheckable(true);
895 		connect(action, &QAction::toggled,
896 			this, &ConfigList::setShowName);
897 		connect(this, &ConfigList::showNameChanged,
898 			action, &QAction::setChecked);
899 		action->setChecked(showName);
900 		headerPopup->addAction(action);
901 	}
902 
903 	headerPopup->exec(e->globalPos());
904 	e->accept();
905 }
906 
907 void ConfigList::setShowName(bool on)
908 {
909 	if (showName == on)
910 		return;
911 
912 	showName = on;
913 	reinit();
914 	emit showNameChanged(on);
915 }
916 
917 QList<ConfigList *> ConfigList::allLists;
918 QAction *ConfigList::showNormalAction;
919 QAction *ConfigList::showAllAction;
920 QAction *ConfigList::showPromptAction;
921 
922 void ConfigList::setAllOpen(bool open)
923 {
924 	QTreeWidgetItemIterator it(this);
925 
926 	while (*it) {
927 		(*it)->setExpanded(open);
928 
929 		++it;
930 	}
931 }
932 
933 ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
934 	: Parent(parent), sym(0), _menu(0)
935 {
936 	setObjectName(name);
937 	setOpenLinks(false);
938 
939 	if (!objectName().isEmpty()) {
940 		configSettings->beginGroup(objectName());
941 		setShowDebug(configSettings->value("/showDebug", false).toBool());
942 		configSettings->endGroup();
943 		connect(configApp, &QApplication::aboutToQuit,
944 			this, &ConfigInfoView::saveSettings);
945 	}
946 
947 	contextMenu = createStandardContextMenu();
948 	QAction *action = new QAction("Show Debug Info", contextMenu);
949 
950 	action->setCheckable(true);
951 	connect(action, &QAction::toggled,
952 		this, &ConfigInfoView::setShowDebug);
953 	connect(this, &ConfigInfoView::showDebugChanged,
954 		action, &QAction::setChecked);
955 	action->setChecked(showDebug());
956 	contextMenu->addSeparator();
957 	contextMenu->addAction(action);
958 }
959 
960 void ConfigInfoView::saveSettings(void)
961 {
962 	if (!objectName().isEmpty()) {
963 		configSettings->beginGroup(objectName());
964 		configSettings->setValue("/showDebug", showDebug());
965 		configSettings->endGroup();
966 	}
967 }
968 
969 void ConfigInfoView::setShowDebug(bool b)
970 {
971 	if (_showDebug != b) {
972 		_showDebug = b;
973 		if (_menu)
974 			menuInfo();
975 		else if (sym)
976 			symbolInfo();
977 		emit showDebugChanged(b);
978 	}
979 }
980 
981 void ConfigInfoView::setInfo(struct menu *m)
982 {
983 	if (_menu == m)
984 		return;
985 	_menu = m;
986 	sym = NULL;
987 	if (!_menu)
988 		clear();
989 	else
990 		menuInfo();
991 }
992 
993 void ConfigInfoView::symbolInfo(void)
994 {
995 	QString str;
996 
997 	str += "<big>Symbol: <b>";
998 	str += print_filter(sym->name);
999 	str += "</b></big><br><br>value: ";
1000 	str += print_filter(sym_get_string_value(sym));
1001 	str += "<br>visibility: ";
1002 	str += sym->visible == yes ? "y" : sym->visible == mod ? "m" : "n";
1003 	str += "<br>";
1004 	str += debug_info(sym);
1005 
1006 	setText(str);
1007 }
1008 
1009 void ConfigInfoView::menuInfo(void)
1010 {
1011 	struct symbol* sym;
1012 	QString info;
1013 	QTextStream stream(&info);
1014 
1015 	sym = _menu->sym;
1016 	if (sym) {
1017 		if (_menu->prompt) {
1018 			stream << "<big><b>";
1019 			stream << print_filter(_menu->prompt->text);
1020 			stream << "</b></big>";
1021 			if (sym->name) {
1022 				stream << " (";
1023 				if (showDebug())
1024 					stream << "<a href=\"s" << sym->name << "\">";
1025 				stream << print_filter(sym->name);
1026 				if (showDebug())
1027 					stream << "</a>";
1028 				stream << ")";
1029 			}
1030 		} else if (sym->name) {
1031 			stream << "<big><b>";
1032 			if (showDebug())
1033 				stream << "<a href=\"s" << sym->name << "\">";
1034 			stream << print_filter(sym->name);
1035 			if (showDebug())
1036 				stream << "</a>";
1037 			stream << "</b></big>";
1038 		}
1039 		stream << "<br><br>";
1040 
1041 		if (showDebug())
1042 			stream << debug_info(sym);
1043 
1044 		struct gstr help_gstr = str_new();
1045 
1046 		menu_get_ext_help(_menu, &help_gstr);
1047 		stream << print_filter(str_get(&help_gstr));
1048 		str_free(&help_gstr);
1049 	} else if (_menu->prompt) {
1050 		stream << "<big><b>";
1051 		stream << print_filter(_menu->prompt->text);
1052 		stream << "</b></big><br><br>";
1053 		if (showDebug()) {
1054 			if (_menu->prompt->visible.expr) {
1055 				stream << "&nbsp;&nbsp;dep: ";
1056 				expr_print(_menu->prompt->visible.expr,
1057 					   expr_print_help, &stream, E_NONE);
1058 				stream << "<br><br>";
1059 			}
1060 
1061 			stream << "defined at " << _menu->filename << ":"
1062 			       << _menu->lineno << "<br><br>";
1063 		}
1064 	}
1065 
1066 	setText(info);
1067 }
1068 
1069 QString ConfigInfoView::debug_info(struct symbol *sym)
1070 {
1071 	QString debug;
1072 	QTextStream stream(&debug);
1073 
1074 	stream << "type: ";
1075 	stream << print_filter(sym_type_name(sym->type));
1076 	if (sym_is_choice(sym))
1077 		stream << " (choice)";
1078 	debug += "<br>";
1079 	if (sym->rev_dep.expr) {
1080 		stream << "reverse dep: ";
1081 		expr_print(sym->rev_dep.expr, expr_print_help, &stream, E_NONE);
1082 		stream << "<br>";
1083 	}
1084 	for (struct property *prop = sym->prop; prop; prop = prop->next) {
1085 		switch (prop->type) {
1086 		case P_PROMPT:
1087 		case P_MENU:
1088 			stream << "prompt: <a href=\"m" << sym->name << "\">";
1089 			stream << print_filter(prop->text);
1090 			stream << "</a><br>";
1091 			break;
1092 		case P_DEFAULT:
1093 		case P_SELECT:
1094 		case P_RANGE:
1095 		case P_COMMENT:
1096 		case P_IMPLY:
1097 		case P_SYMBOL:
1098 			stream << prop_get_type_name(prop->type);
1099 			stream << ": ";
1100 			expr_print(prop->expr, expr_print_help,
1101 				   &stream, E_NONE);
1102 			stream << "<br>";
1103 			break;
1104 		default:
1105 			stream << "unknown property: ";
1106 			stream << prop_get_type_name(prop->type);
1107 			stream << "<br>";
1108 		}
1109 		if (prop->visible.expr) {
1110 			stream << "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
1111 			expr_print(prop->visible.expr, expr_print_help,
1112 				   &stream, E_NONE);
1113 			stream << "<br>";
1114 		}
1115 	}
1116 	stream << "<br>";
1117 
1118 	return debug;
1119 }
1120 
1121 QString ConfigInfoView::print_filter(const QString &str)
1122 {
1123 	QRegularExpression re("[<>&\"\\n]");
1124 	QString res = str;
1125 	for (int i = 0; (i = res.indexOf(re, i)) >= 0;) {
1126 		switch (res[i].toLatin1()) {
1127 		case '<':
1128 			res.replace(i, 1, "&lt;");
1129 			i += 4;
1130 			break;
1131 		case '>':
1132 			res.replace(i, 1, "&gt;");
1133 			i += 4;
1134 			break;
1135 		case '&':
1136 			res.replace(i, 1, "&amp;");
1137 			i += 5;
1138 			break;
1139 		case '"':
1140 			res.replace(i, 1, "&quot;");
1141 			i += 6;
1142 			break;
1143 		case '\n':
1144 			res.replace(i, 1, "<br>");
1145 			i += 4;
1146 			break;
1147 		}
1148 	}
1149 	return res;
1150 }
1151 
1152 void ConfigInfoView::expr_print_help(void *data, struct symbol *sym, const char *str)
1153 {
1154 	QTextStream *stream = reinterpret_cast<QTextStream *>(data);
1155 
1156 	if (sym && sym->name && !(sym->flags & SYMBOL_CONST)) {
1157 		*stream << "<a href=\"s" << sym->name << "\">";
1158 		*stream << print_filter(str);
1159 		*stream << "</a>";
1160 	} else {
1161 		*stream << print_filter(str);
1162 	}
1163 }
1164 
1165 void ConfigInfoView::clicked(const QUrl &url)
1166 {
1167 	QByteArray str = url.toEncoded();
1168 	const std::size_t count = str.size();
1169 	char *data = new char[count + 1];
1170 	struct symbol **result;
1171 	struct menu *m = NULL;
1172 
1173 	if (count < 1) {
1174 		delete[] data;
1175 		return;
1176 	}
1177 
1178 	memcpy(data, str.constData(), count);
1179 	data[count] = '\0';
1180 
1181 	/* Seek for exact match */
1182 	data[0] = '^';
1183 	strcat(data, "$");
1184 	result = sym_re_search(data);
1185 	if (!result) {
1186 		delete[] data;
1187 		return;
1188 	}
1189 
1190 	sym = *result;
1191 
1192 	/* Seek for the menu which holds the symbol */
1193 	for (struct property *prop = sym->prop; prop; prop = prop->next) {
1194 		    if (prop->type != P_PROMPT && prop->type != P_MENU)
1195 			    continue;
1196 		    m = prop->menu;
1197 		    break;
1198 	}
1199 
1200 	if (!m) {
1201 		/* Symbol is not visible as a menu */
1202 		symbolInfo();
1203 		emit showDebugChanged(true);
1204 	} else {
1205 		emit menuSelected(m);
1206 	}
1207 
1208 	free(result);
1209 	delete[] data;
1210 }
1211 
1212 void ConfigInfoView::contextMenuEvent(QContextMenuEvent *event)
1213 {
1214 	contextMenu->popup(event->globalPos());
1215 	event->accept();
1216 }
1217 
1218 ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow *parent)
1219 	: Parent(parent), result(NULL)
1220 {
1221 	setObjectName("search");
1222 	setWindowTitle("Search Config");
1223 
1224 	QVBoxLayout* layout1 = new QVBoxLayout(this);
1225 	layout1->setContentsMargins(11, 11, 11, 11);
1226 	layout1->setSpacing(6);
1227 
1228 	QHBoxLayout* layout2 = new QHBoxLayout();
1229 	layout2->setContentsMargins(0, 0, 0, 0);
1230 	layout2->setSpacing(6);
1231 	layout2->addWidget(new QLabel("Find:", this));
1232 	editField = new QLineEdit(this);
1233 	connect(editField, &QLineEdit::returnPressed,
1234 		this, &ConfigSearchWindow::search);
1235 	layout2->addWidget(editField);
1236 	searchButton = new QPushButton("Search", this);
1237 	searchButton->setAutoDefault(false);
1238 	connect(searchButton, &QPushButton::clicked,
1239 		this, &ConfigSearchWindow::search);
1240 	layout2->addWidget(searchButton);
1241 	layout1->addLayout(layout2);
1242 
1243 	split = new QSplitter(this);
1244 	split->setOrientation(Qt::Vertical);
1245 	list = new ConfigList(split, "search");
1246 	list->mode = listMode;
1247 	info = new ConfigInfoView(split, "search");
1248 	connect(list, &ConfigList::menuChanged,
1249 		info, &ConfigInfoView::setInfo);
1250 	connect(list, &ConfigList::menuChanged,
1251 		parent, &ConfigMainWindow::setMenuLink);
1252 
1253 	layout1->addWidget(split);
1254 
1255 	QVariant x, y;
1256 	int width, height;
1257 	bool ok;
1258 
1259 	configSettings->beginGroup("search");
1260 	width = configSettings->value("/window width", parent->width() / 2).toInt();
1261 	height = configSettings->value("/window height", parent->height() / 2).toInt();
1262 	resize(width, height);
1263 	x = configSettings->value("/window x");
1264 	y = configSettings->value("/window y");
1265 	if (x.isValid() && y.isValid())
1266 		move(x.toInt(), y.toInt());
1267 	QList<int> sizes = configSettings->readSizes("/split", &ok);
1268 	if (ok)
1269 		split->setSizes(sizes);
1270 	configSettings->endGroup();
1271 	connect(configApp, &QApplication::aboutToQuit,
1272 		this, &ConfigSearchWindow::saveSettings);
1273 }
1274 
1275 void ConfigSearchWindow::saveSettings(void)
1276 {
1277 	if (!objectName().isEmpty()) {
1278 		configSettings->beginGroup(objectName());
1279 		configSettings->setValue("/window x", pos().x());
1280 		configSettings->setValue("/window y", pos().y());
1281 		configSettings->setValue("/window width", size().width());
1282 		configSettings->setValue("/window height", size().height());
1283 		configSettings->writeSizes("/split", split->sizes());
1284 		configSettings->endGroup();
1285 	}
1286 }
1287 
1288 void ConfigSearchWindow::search(void)
1289 {
1290 	struct symbol **p;
1291 	struct property *prop;
1292 	ConfigItem *lastItem = NULL;
1293 
1294 	free(result);
1295 	list->clear();
1296 	info->clear();
1297 
1298 	result = sym_re_search(editField->text().toLatin1());
1299 	if (!result)
1300 		return;
1301 	for (p = result; *p; p++) {
1302 		for_all_prompts((*p), prop)
1303 			lastItem = new ConfigItem(list, lastItem, prop->menu,
1304 						  menu_is_visible(prop->menu));
1305 	}
1306 }
1307 
1308 /*
1309  * Construct the complete config widget
1310  */
1311 ConfigMainWindow::ConfigMainWindow(void)
1312 	: searchWindow(0)
1313 {
1314 	bool ok = true;
1315 	QVariant x, y;
1316 	int width, height;
1317 	char title[256];
1318 
1319 	snprintf(title, sizeof(title), "%s%s",
1320 		rootmenu.prompt->text,
1321 		""
1322 		);
1323 	setWindowTitle(title);
1324 
1325 	QRect g = configApp->primaryScreen()->geometry();
1326 	width = configSettings->value("/window width", g.width() - 64).toInt();
1327 	height = configSettings->value("/window height", g.height() - 64).toInt();
1328 	resize(width, height);
1329 	x = configSettings->value("/window x");
1330 	y = configSettings->value("/window y");
1331 	if ((x.isValid())&&(y.isValid()))
1332 		move(x.toInt(), y.toInt());
1333 
1334 	// set up icons
1335 	ConfigItem::symbolYesIcon = QIcon(QPixmap(xpm_symbol_yes));
1336 	ConfigItem::symbolModIcon = QIcon(QPixmap(xpm_symbol_mod));
1337 	ConfigItem::symbolNoIcon = QIcon(QPixmap(xpm_symbol_no));
1338 	ConfigItem::choiceYesIcon = QIcon(QPixmap(xpm_choice_yes));
1339 	ConfigItem::choiceNoIcon = QIcon(QPixmap(xpm_choice_no));
1340 	ConfigItem::menuIcon = QIcon(QPixmap(xpm_menu));
1341 	ConfigItem::menubackIcon = QIcon(QPixmap(xpm_menuback));
1342 
1343 	QWidget *widget = new QWidget(this);
1344 	QVBoxLayout *layout = new QVBoxLayout(widget);
1345 	setCentralWidget(widget);
1346 
1347 	split1 = new QSplitter(widget);
1348 	split1->setOrientation(Qt::Horizontal);
1349 	split1->setChildrenCollapsible(false);
1350 
1351 	menuList = new ConfigList(widget, "menu");
1352 
1353 	split2 = new QSplitter(widget);
1354 	split2->setChildrenCollapsible(false);
1355 	split2->setOrientation(Qt::Vertical);
1356 
1357 	// create config tree
1358 	configList = new ConfigList(widget, "config");
1359 
1360 	helpText = new ConfigInfoView(widget, "help");
1361 
1362 	layout->addWidget(split2);
1363 	split2->addWidget(split1);
1364 	split1->addWidget(configList);
1365 	split1->addWidget(menuList);
1366 	split2->addWidget(helpText);
1367 
1368 	setTabOrder(configList, helpText);
1369 	configList->setFocus();
1370 
1371 	backAction = new QAction(QPixmap(xpm_back), "Back", this);
1372 	connect(backAction, &QAction::triggered,
1373 		this, &ConfigMainWindow::goBack);
1374 
1375 	QAction *quitAction = new QAction("&Quit", this);
1376 	quitAction->setShortcut(Qt::CTRL | Qt::Key_Q);
1377 	connect(quitAction, &QAction::triggered,
1378 		this, &ConfigMainWindow::close);
1379 
1380 	QAction *loadAction = new QAction(QPixmap(xpm_load), "&Load", this);
1381 	loadAction->setShortcut(Qt::CTRL | Qt::Key_L);
1382 	connect(loadAction, &QAction::triggered,
1383 		this, &ConfigMainWindow::loadConfig);
1384 
1385 	saveAction = new QAction(QPixmap(xpm_save), "&Save", this);
1386 	saveAction->setShortcut(Qt::CTRL | Qt::Key_S);
1387 	connect(saveAction, &QAction::triggered,
1388 		this, &ConfigMainWindow::saveConfig);
1389 
1390 	conf_set_changed_callback(conf_changed);
1391 
1392 	configname = xstrdup(conf_get_configname());
1393 
1394 	QAction *saveAsAction = new QAction("Save &As...", this);
1395 	connect(saveAsAction, &QAction::triggered,
1396 		this, &ConfigMainWindow::saveConfigAs);
1397 	QAction *searchAction = new QAction("&Find", this);
1398 	searchAction->setShortcut(Qt::CTRL | Qt::Key_F);
1399 	connect(searchAction, &QAction::triggered,
1400 		this, &ConfigMainWindow::searchConfig);
1401 	singleViewAction = new QAction(QPixmap(xpm_single_view), "Single View", this);
1402 	singleViewAction->setCheckable(true);
1403 	connect(singleViewAction, &QAction::triggered,
1404 		this, &ConfigMainWindow::showSingleView);
1405 	splitViewAction = new QAction(QPixmap(xpm_split_view), "Split View", this);
1406 	splitViewAction->setCheckable(true);
1407 	connect(splitViewAction, &QAction::triggered,
1408 		this, &ConfigMainWindow::showSplitView);
1409 	fullViewAction = new QAction(QPixmap(xpm_tree_view), "Full View", this);
1410 	fullViewAction->setCheckable(true);
1411 	connect(fullViewAction, &QAction::triggered,
1412 		this, &ConfigMainWindow::showFullView);
1413 
1414 	QAction *showNameAction = new QAction("Show Name", this);
1415 	  showNameAction->setCheckable(true);
1416 	connect(showNameAction, &QAction::toggled,
1417 		configList, &ConfigList::setShowName);
1418 	showNameAction->setChecked(configList->showName);
1419 
1420 	QActionGroup *optGroup = new QActionGroup(this);
1421 	optGroup->setExclusive(true);
1422 	connect(optGroup, &QActionGroup::triggered,
1423 		configList, &ConfigList::setOptionMode);
1424 	connect(optGroup, &QActionGroup::triggered,
1425 		menuList, &ConfigList::setOptionMode);
1426 
1427 	ConfigList::showNormalAction = new QAction("Show Normal Options", optGroup);
1428 	ConfigList::showNormalAction->setCheckable(true);
1429 	ConfigList::showAllAction = new QAction("Show All Options", optGroup);
1430 	ConfigList::showAllAction->setCheckable(true);
1431 	ConfigList::showPromptAction = new QAction("Show Prompt Options", optGroup);
1432 	ConfigList::showPromptAction->setCheckable(true);
1433 
1434 	QAction *showDebugAction = new QAction("Show Debug Info", this);
1435 	  showDebugAction->setCheckable(true);
1436 	connect(showDebugAction, &QAction::toggled,
1437 		helpText, &ConfigInfoView::setShowDebug);
1438 	  showDebugAction->setChecked(helpText->showDebug());
1439 
1440 	QAction *showIntroAction = new QAction("Introduction", this);
1441 	connect(showIntroAction, &QAction::triggered,
1442 		this, &ConfigMainWindow::showIntro);
1443 	QAction *showAboutAction = new QAction("About", this);
1444 	connect(showAboutAction, &QAction::triggered,
1445 		this, &ConfigMainWindow::showAbout);
1446 
1447 	// init tool bar
1448 	QToolBar *toolBar = addToolBar("Tools");
1449 	toolBar->addAction(backAction);
1450 	toolBar->addSeparator();
1451 	toolBar->addAction(loadAction);
1452 	toolBar->addAction(saveAction);
1453 	toolBar->addSeparator();
1454 	toolBar->addAction(singleViewAction);
1455 	toolBar->addAction(splitViewAction);
1456 	toolBar->addAction(fullViewAction);
1457 
1458 	// create file menu
1459 	QMenu *menu = menuBar()->addMenu("&File");
1460 	menu->addAction(loadAction);
1461 	menu->addAction(saveAction);
1462 	menu->addAction(saveAsAction);
1463 	menu->addSeparator();
1464 	menu->addAction(quitAction);
1465 
1466 	// create edit menu
1467 	menu = menuBar()->addMenu("&Edit");
1468 	menu->addAction(searchAction);
1469 
1470 	// create options menu
1471 	menu = menuBar()->addMenu("&Option");
1472 	menu->addAction(showNameAction);
1473 	menu->addSeparator();
1474 	menu->addActions(optGroup->actions());
1475 	menu->addSeparator();
1476 	menu->addAction(showDebugAction);
1477 
1478 	// create help menu
1479 	menu = menuBar()->addMenu("&Help");
1480 	menu->addAction(showIntroAction);
1481 	menu->addAction(showAboutAction);
1482 
1483 	connect(helpText, &ConfigInfoView::anchorClicked,
1484 		helpText, &ConfigInfoView::clicked);
1485 
1486 	connect(configList, &ConfigList::menuChanged,
1487 		helpText, &ConfigInfoView::setInfo);
1488 	connect(configList, &ConfigList::menuSelected,
1489 		this, &ConfigMainWindow::changeMenu);
1490 	connect(configList, &ConfigList::itemSelected,
1491 		this, &ConfigMainWindow::changeItens);
1492 	connect(configList, &ConfigList::parentSelected,
1493 		this, &ConfigMainWindow::goBack);
1494 	connect(menuList, &ConfigList::menuChanged,
1495 		helpText, &ConfigInfoView::setInfo);
1496 	connect(menuList, &ConfigList::menuSelected,
1497 		this, &ConfigMainWindow::changeMenu);
1498 
1499 	connect(configList, &ConfigList::gotFocus,
1500 		helpText, &ConfigInfoView::setInfo);
1501 	connect(menuList, &ConfigList::gotFocus,
1502 		helpText, &ConfigInfoView::setInfo);
1503 	connect(menuList, &ConfigList::gotFocus,
1504 		this, &ConfigMainWindow::listFocusChanged);
1505 	connect(helpText, &ConfigInfoView::menuSelected,
1506 		this, &ConfigMainWindow::setMenuLink);
1507 
1508 	QString listMode = configSettings->value("/listMode", "symbol").toString();
1509 	if (listMode == "single")
1510 		showSingleView();
1511 	else if (listMode == "full")
1512 		showFullView();
1513 	else /*if (listMode == "split")*/
1514 		showSplitView();
1515 
1516 	// UI setup done, restore splitter positions
1517 	QList<int> sizes = configSettings->readSizes("/split1", &ok);
1518 	if (ok)
1519 		split1->setSizes(sizes);
1520 
1521 	sizes = configSettings->readSizes("/split2", &ok);
1522 	if (ok)
1523 		split2->setSizes(sizes);
1524 }
1525 
1526 void ConfigMainWindow::loadConfig(void)
1527 {
1528 	QString str;
1529 	QByteArray ba;
1530 	const char *name;
1531 
1532 	str = QFileDialog::getOpenFileName(this, "", configname);
1533 	if (str.isNull())
1534 		return;
1535 
1536 	ba = str.toLocal8Bit();
1537 	name = ba.data();
1538 
1539 	if (conf_read(name))
1540 		QMessageBox::information(this, "qconf", "Unable to load configuration!");
1541 
1542 	free(configname);
1543 	configname = xstrdup(name);
1544 
1545 	ConfigList::updateListAllForAll();
1546 }
1547 
1548 bool ConfigMainWindow::saveConfig(void)
1549 {
1550 	if (conf_write(configname)) {
1551 		QMessageBox::information(this, "qconf", "Unable to save configuration!");
1552 		return false;
1553 	}
1554 	conf_write_autoconf(0);
1555 
1556 	return true;
1557 }
1558 
1559 void ConfigMainWindow::saveConfigAs(void)
1560 {
1561 	QString str;
1562 	QByteArray ba;
1563 	const char *name;
1564 
1565 	str = QFileDialog::getSaveFileName(this, "", configname);
1566 	if (str.isNull())
1567 		return;
1568 
1569 	ba = str.toLocal8Bit();
1570 	name = ba.data();
1571 
1572 	if (conf_write(name)) {
1573 		QMessageBox::information(this, "qconf", "Unable to save configuration!");
1574 	}
1575 	conf_write_autoconf(0);
1576 
1577 	free(configname);
1578 	configname = xstrdup(name);
1579 }
1580 
1581 void ConfigMainWindow::searchConfig(void)
1582 {
1583 	if (!searchWindow)
1584 		searchWindow = new ConfigSearchWindow(this);
1585 	searchWindow->show();
1586 }
1587 
1588 void ConfigMainWindow::changeItens(struct menu *menu)
1589 {
1590 	configList->setRootMenu(menu);
1591 }
1592 
1593 void ConfigMainWindow::changeMenu(struct menu *menu)
1594 {
1595 	menuList->setRootMenu(menu);
1596 }
1597 
1598 void ConfigMainWindow::setMenuLink(struct menu *menu)
1599 {
1600 	struct menu *parent;
1601 	ConfigList* list = NULL;
1602 	ConfigItem* item;
1603 
1604 	if (configList->menuSkip(menu))
1605 		return;
1606 
1607 	switch (configList->mode) {
1608 	case singleMode:
1609 		list = configList;
1610 		parent = menu_get_parent_menu(menu);
1611 		if (!parent)
1612 			return;
1613 		list->setRootMenu(parent);
1614 		break;
1615 	case menuMode:
1616 		if (menu->flags & MENU_ROOT) {
1617 			menuList->setRootMenu(menu);
1618 			configList->clearSelection();
1619 			list = configList;
1620 		} else {
1621 			parent = menu_get_parent_menu(menu->parent);
1622 			if (!parent)
1623 				return;
1624 
1625 			/* Select the config view */
1626 			item = configList->findConfigItem(parent);
1627 			if (item) {
1628 				configList->setSelected(item, true);
1629 				configList->scrollToItem(item);
1630 			}
1631 
1632 			menuList->setRootMenu(parent);
1633 			menuList->clearSelection();
1634 			list = menuList;
1635 		}
1636 		break;
1637 	case fullMode:
1638 		list = configList;
1639 		break;
1640 	default:
1641 		break;
1642 	}
1643 
1644 	if (list) {
1645 		item = list->findConfigItem(menu);
1646 		if (item) {
1647 			list->setSelected(item, true);
1648 			list->scrollToItem(item);
1649 			list->setFocus();
1650 			helpText->setInfo(menu);
1651 		}
1652 	}
1653 }
1654 
1655 void ConfigMainWindow::listFocusChanged(void)
1656 {
1657 	if (menuList->mode == menuMode)
1658 		configList->clearSelection();
1659 }
1660 
1661 void ConfigMainWindow::goBack(void)
1662 {
1663 	if (configList->rootEntry == &rootmenu)
1664 		return;
1665 
1666 	configList->setParentMenu();
1667 }
1668 
1669 void ConfigMainWindow::showSingleView(void)
1670 {
1671 	singleViewAction->setEnabled(false);
1672 	singleViewAction->setChecked(true);
1673 	splitViewAction->setEnabled(true);
1674 	splitViewAction->setChecked(false);
1675 	fullViewAction->setEnabled(true);
1676 	fullViewAction->setChecked(false);
1677 
1678 	backAction->setEnabled(true);
1679 
1680 	menuList->hide();
1681 	menuList->setRootMenu(0);
1682 	configList->mode = singleMode;
1683 	if (configList->rootEntry == &rootmenu)
1684 		configList->updateListAll();
1685 	else
1686 		configList->setRootMenu(&rootmenu);
1687 	configList->setFocus();
1688 }
1689 
1690 void ConfigMainWindow::showSplitView(void)
1691 {
1692 	singleViewAction->setEnabled(true);
1693 	singleViewAction->setChecked(false);
1694 	splitViewAction->setEnabled(false);
1695 	splitViewAction->setChecked(true);
1696 	fullViewAction->setEnabled(true);
1697 	fullViewAction->setChecked(false);
1698 
1699 	backAction->setEnabled(false);
1700 
1701 	configList->mode = menuMode;
1702 	if (configList->rootEntry == &rootmenu)
1703 		configList->updateListAll();
1704 	else
1705 		configList->setRootMenu(&rootmenu);
1706 	configList->setAllOpen(true);
1707 	configApp->processEvents();
1708 	menuList->mode = symbolMode;
1709 	menuList->setRootMenu(&rootmenu);
1710 	menuList->setAllOpen(true);
1711 	menuList->show();
1712 	menuList->setFocus();
1713 }
1714 
1715 void ConfigMainWindow::showFullView(void)
1716 {
1717 	singleViewAction->setEnabled(true);
1718 	singleViewAction->setChecked(false);
1719 	splitViewAction->setEnabled(true);
1720 	splitViewAction->setChecked(false);
1721 	fullViewAction->setEnabled(false);
1722 	fullViewAction->setChecked(true);
1723 
1724 	backAction->setEnabled(false);
1725 
1726 	menuList->hide();
1727 	menuList->setRootMenu(0);
1728 	configList->mode = fullMode;
1729 	if (configList->rootEntry == &rootmenu)
1730 		configList->updateListAll();
1731 	else
1732 		configList->setRootMenu(&rootmenu);
1733 	configList->setFocus();
1734 }
1735 
1736 /*
1737  * ask for saving configuration before quitting
1738  */
1739 void ConfigMainWindow::closeEvent(QCloseEvent* e)
1740 {
1741 	if (!conf_get_changed()) {
1742 		e->accept();
1743 		return;
1744 	}
1745 
1746 	QMessageBox mb(QMessageBox::Icon::Warning, "qconf",
1747 		       "Save configuration?");
1748 
1749 	QPushButton *yb = mb.addButton(QMessageBox::Yes);
1750 	QPushButton *db = mb.addButton(QMessageBox::No);
1751 	QPushButton *cb = mb.addButton(QMessageBox::Cancel);
1752 
1753 	yb->setText("&Save Changes");
1754 	db->setText("&Discard Changes");
1755 	cb->setText("Cancel Exit");
1756 
1757 	mb.setDefaultButton(yb);
1758 	mb.setEscapeButton(cb);
1759 
1760 	switch (mb.exec()) {
1761 	case QMessageBox::Yes:
1762 		if (saveConfig())
1763 			e->accept();
1764 		else
1765 			e->ignore();
1766 		break;
1767 	case QMessageBox::No:
1768 		e->accept();
1769 		break;
1770 	case QMessageBox::Cancel:
1771 		e->ignore();
1772 		break;
1773 	}
1774 }
1775 
1776 void ConfigMainWindow::showIntro(void)
1777 {
1778 	static const QString str =
1779 		"Welcome to the qconf graphical configuration tool.\n"
1780 		"\n"
1781 		"For bool and tristate options, a blank box indicates the "
1782 		"feature is disabled, a check indicates it is enabled, and a "
1783 		"dot indicates that it is to be compiled as a module. Clicking "
1784 		"on the box will cycle through the three states. For int, hex, "
1785 		"and string options, double-clicking or pressing F2 on the "
1786 		"Value cell will allow you to edit the value.\n"
1787 		"\n"
1788 		"If you do not see an option (e.g., a device driver) that you "
1789 		"believe should be present, try turning on Show All Options "
1790 		"under the Options menu. Enabling Show Debug Info will help you"
1791 		"figure out what other options must be enabled to support the "
1792 		"option you are interested in, and hyperlinks will navigate to "
1793 		"them.\n"
1794 		"\n"
1795 		"Toggling Show Debug Info under the Options menu will show the "
1796 		"dependencies, which you can then match by examining other "
1797 		"options.\n";
1798 
1799 	QMessageBox::information(this, "qconf", str);
1800 }
1801 
1802 void ConfigMainWindow::showAbout(void)
1803 {
1804 	static const QString str = "qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n"
1805 		"Copyright (C) 2015 Boris Barbulovski <bbarbulovski@gmail.com>.\n"
1806 		"\n"
1807 		"Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n"
1808 		"\n"
1809 		"Qt Version: ";
1810 
1811 	QMessageBox::information(this, "qconf", str + qVersion());
1812 }
1813 
1814 void ConfigMainWindow::saveSettings(void)
1815 {
1816 	configSettings->setValue("/window x", pos().x());
1817 	configSettings->setValue("/window y", pos().y());
1818 	configSettings->setValue("/window width", size().width());
1819 	configSettings->setValue("/window height", size().height());
1820 
1821 	QString entry;
1822 	switch(configList->mode) {
1823 	case singleMode :
1824 		entry = "single";
1825 		break;
1826 
1827 	case symbolMode :
1828 		entry = "split";
1829 		break;
1830 
1831 	case fullMode :
1832 		entry = "full";
1833 		break;
1834 
1835 	default:
1836 		break;
1837 	}
1838 	configSettings->setValue("/listMode", entry);
1839 
1840 	configSettings->writeSizes("/split1", split1->sizes());
1841 	configSettings->writeSizes("/split2", split2->sizes());
1842 }
1843 
1844 void ConfigMainWindow::conf_changed(bool dirty)
1845 {
1846 	if (saveAction)
1847 		saveAction->setEnabled(dirty);
1848 }
1849 
1850 void fixup_rootmenu(struct menu *menu)
1851 {
1852 	struct menu *child;
1853 	static int menu_cnt = 0;
1854 
1855 	menu->flags |= MENU_ROOT;
1856 	for (child = menu->list; child; child = child->next) {
1857 		if (child->prompt && child->prompt->type == P_MENU) {
1858 			menu_cnt++;
1859 			fixup_rootmenu(child);
1860 			menu_cnt--;
1861 		} else if (!menu_cnt)
1862 			fixup_rootmenu(child);
1863 	}
1864 }
1865 
1866 static const char *progname;
1867 
1868 static void usage(void)
1869 {
1870 	printf("%s [-s] <config>\n", progname);
1871 	exit(0);
1872 }
1873 
1874 int main(int ac, char** av)
1875 {
1876 	ConfigMainWindow* v;
1877 	const char *name;
1878 
1879 	progname = av[0];
1880 	if (ac > 1 && av[1][0] == '-') {
1881 		switch (av[1][1]) {
1882 		case 's':
1883 			conf_set_message_callback(NULL);
1884 			break;
1885 		case 'h':
1886 		case '?':
1887 			usage();
1888 		}
1889 		name = av[2];
1890 	} else
1891 		name = av[1];
1892 	if (!name)
1893 		usage();
1894 
1895 	conf_parse(name);
1896 	fixup_rootmenu(&rootmenu);
1897 	//zconfdump(stdout);
1898 
1899 	configApp = new QApplication(ac, av);
1900 
1901 	configSettings = new ConfigSettings();
1902 	configSettings->beginGroup("/kconfig/qconf");
1903 	v = new ConfigMainWindow();
1904 
1905 	//zconfdump(stdout);
1906 	configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1907 	configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
1908 
1909 	conf_read(NULL);
1910 
1911 	v->show();
1912 	configApp->exec();
1913 
1914 	configSettings->endGroup();
1915 	delete configSettings;
1916 	delete v;
1917 	delete configApp;
1918 
1919 	return 0;
1920 }
1921