xref: /openbmc/linux/scripts/kconfig/qconf.cc (revision 1c95443e) 
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) && type == S_BOOLEAN)
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->file->name << ":"
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 		case P_CHOICE:
1105 			if (sym_is_choice(sym)) {
1106 				stream << "choice: ";
1107 				expr_print(prop->expr, expr_print_help,
1108 					   &stream, E_NONE);
1109 				stream << "<br>";
1110 			}
1111 			break;
1112 		default:
1113 			stream << "unknown property: ";
1114 			stream << prop_get_type_name(prop->type);
1115 			stream << "<br>";
1116 		}
1117 		if (prop->visible.expr) {
1118 			stream << "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
1119 			expr_print(prop->visible.expr, expr_print_help,
1120 				   &stream, E_NONE);
1121 			stream << "<br>";
1122 		}
1123 	}
1124 	stream << "<br>";
1125 
1126 	return debug;
1127 }
1128 
1129 QString ConfigInfoView::print_filter(const QString &str)
1130 {
1131 	QRegularExpression re("[<>&\"\\n]");
1132 	QString res = str;
1133 	for (int i = 0; (i = res.indexOf(re, i)) >= 0;) {
1134 		switch (res[i].toLatin1()) {
1135 		case '<':
1136 			res.replace(i, 1, "&lt;");
1137 			i += 4;
1138 			break;
1139 		case '>':
1140 			res.replace(i, 1, "&gt;");
1141 			i += 4;
1142 			break;
1143 		case '&':
1144 			res.replace(i, 1, "&amp;");
1145 			i += 5;
1146 			break;
1147 		case '"':
1148 			res.replace(i, 1, "&quot;");
1149 			i += 6;
1150 			break;
1151 		case '\n':
1152 			res.replace(i, 1, "<br>");
1153 			i += 4;
1154 			break;
1155 		}
1156 	}
1157 	return res;
1158 }
1159 
1160 void ConfigInfoView::expr_print_help(void *data, struct symbol *sym, const char *str)
1161 {
1162 	QTextStream *stream = reinterpret_cast<QTextStream *>(data);
1163 
1164 	if (sym && sym->name && !(sym->flags & SYMBOL_CONST)) {
1165 		*stream << "<a href=\"s" << sym->name << "\">";
1166 		*stream << print_filter(str);
1167 		*stream << "</a>";
1168 	} else {
1169 		*stream << print_filter(str);
1170 	}
1171 }
1172 
1173 void ConfigInfoView::clicked(const QUrl &url)
1174 {
1175 	QByteArray str = url.toEncoded();
1176 	const std::size_t count = str.size();
1177 	char *data = new char[count + 2];  // '$' + '\0'
1178 	struct symbol **result;
1179 	struct menu *m = NULL;
1180 
1181 	if (count < 1) {
1182 		delete[] data;
1183 		return;
1184 	}
1185 
1186 	memcpy(data, str.constData(), count);
1187 	data[count] = '\0';
1188 
1189 	/* Seek for exact match */
1190 	data[0] = '^';
1191 	strcat(data, "$");
1192 	result = sym_re_search(data);
1193 	if (!result) {
1194 		delete[] data;
1195 		return;
1196 	}
1197 
1198 	sym = *result;
1199 
1200 	/* Seek for the menu which holds the symbol */
1201 	for (struct property *prop = sym->prop; prop; prop = prop->next) {
1202 		    if (prop->type != P_PROMPT && prop->type != P_MENU)
1203 			    continue;
1204 		    m = prop->menu;
1205 		    break;
1206 	}
1207 
1208 	if (!m) {
1209 		/* Symbol is not visible as a menu */
1210 		symbolInfo();
1211 		emit showDebugChanged(true);
1212 	} else {
1213 		emit menuSelected(m);
1214 	}
1215 
1216 	free(result);
1217 	delete[] data;
1218 }
1219 
1220 void ConfigInfoView::contextMenuEvent(QContextMenuEvent *event)
1221 {
1222 	contextMenu->popup(event->globalPos());
1223 	event->accept();
1224 }
1225 
1226 ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow *parent)
1227 	: Parent(parent), result(NULL)
1228 {
1229 	setObjectName("search");
1230 	setWindowTitle("Search Config");
1231 
1232 	QVBoxLayout* layout1 = new QVBoxLayout(this);
1233 	layout1->setContentsMargins(11, 11, 11, 11);
1234 	layout1->setSpacing(6);
1235 
1236 	QHBoxLayout* layout2 = new QHBoxLayout();
1237 	layout2->setContentsMargins(0, 0, 0, 0);
1238 	layout2->setSpacing(6);
1239 	layout2->addWidget(new QLabel("Find:", this));
1240 	editField = new QLineEdit(this);
1241 	connect(editField, &QLineEdit::returnPressed,
1242 		this, &ConfigSearchWindow::search);
1243 	layout2->addWidget(editField);
1244 	searchButton = new QPushButton("Search", this);
1245 	searchButton->setAutoDefault(false);
1246 	connect(searchButton, &QPushButton::clicked,
1247 		this, &ConfigSearchWindow::search);
1248 	layout2->addWidget(searchButton);
1249 	layout1->addLayout(layout2);
1250 
1251 	split = new QSplitter(this);
1252 	split->setOrientation(Qt::Vertical);
1253 	list = new ConfigList(split, "search");
1254 	list->mode = listMode;
1255 	info = new ConfigInfoView(split, "search");
1256 	connect(list, &ConfigList::menuChanged,
1257 		info, &ConfigInfoView::setInfo);
1258 	connect(list, &ConfigList::menuChanged,
1259 		parent, &ConfigMainWindow::setMenuLink);
1260 
1261 	layout1->addWidget(split);
1262 
1263 	QVariant x, y;
1264 	int width, height;
1265 	bool ok;
1266 
1267 	configSettings->beginGroup("search");
1268 	width = configSettings->value("/window width", parent->width() / 2).toInt();
1269 	height = configSettings->value("/window height", parent->height() / 2).toInt();
1270 	resize(width, height);
1271 	x = configSettings->value("/window x");
1272 	y = configSettings->value("/window y");
1273 	if (x.isValid() && y.isValid())
1274 		move(x.toInt(), y.toInt());
1275 	QList<int> sizes = configSettings->readSizes("/split", &ok);
1276 	if (ok)
1277 		split->setSizes(sizes);
1278 	configSettings->endGroup();
1279 	connect(configApp, &QApplication::aboutToQuit,
1280 		this, &ConfigSearchWindow::saveSettings);
1281 }
1282 
1283 void ConfigSearchWindow::saveSettings(void)
1284 {
1285 	if (!objectName().isEmpty()) {
1286 		configSettings->beginGroup(objectName());
1287 		configSettings->setValue("/window x", pos().x());
1288 		configSettings->setValue("/window y", pos().y());
1289 		configSettings->setValue("/window width", size().width());
1290 		configSettings->setValue("/window height", size().height());
1291 		configSettings->writeSizes("/split", split->sizes());
1292 		configSettings->endGroup();
1293 	}
1294 }
1295 
1296 void ConfigSearchWindow::search(void)
1297 {
1298 	struct symbol **p;
1299 	struct property *prop;
1300 	ConfigItem *lastItem = NULL;
1301 
1302 	free(result);
1303 	list->clear();
1304 	info->clear();
1305 
1306 	result = sym_re_search(editField->text().toLatin1());
1307 	if (!result)
1308 		return;
1309 	for (p = result; *p; p++) {
1310 		for_all_prompts((*p), prop)
1311 			lastItem = new ConfigItem(list, lastItem, prop->menu,
1312 						  menu_is_visible(prop->menu));
1313 	}
1314 }
1315 
1316 /*
1317  * Construct the complete config widget
1318  */
1319 ConfigMainWindow::ConfigMainWindow(void)
1320 	: searchWindow(0)
1321 {
1322 	bool ok = true;
1323 	QVariant x, y;
1324 	int width, height;
1325 	char title[256];
1326 
1327 	snprintf(title, sizeof(title), "%s%s",
1328 		rootmenu.prompt->text,
1329 		""
1330 		);
1331 	setWindowTitle(title);
1332 
1333 	QRect g = configApp->primaryScreen()->geometry();
1334 	width = configSettings->value("/window width", g.width() - 64).toInt();
1335 	height = configSettings->value("/window height", g.height() - 64).toInt();
1336 	resize(width, height);
1337 	x = configSettings->value("/window x");
1338 	y = configSettings->value("/window y");
1339 	if ((x.isValid())&&(y.isValid()))
1340 		move(x.toInt(), y.toInt());
1341 
1342 	// set up icons
1343 	ConfigItem::symbolYesIcon = QIcon(QPixmap(xpm_symbol_yes));
1344 	ConfigItem::symbolModIcon = QIcon(QPixmap(xpm_symbol_mod));
1345 	ConfigItem::symbolNoIcon = QIcon(QPixmap(xpm_symbol_no));
1346 	ConfigItem::choiceYesIcon = QIcon(QPixmap(xpm_choice_yes));
1347 	ConfigItem::choiceNoIcon = QIcon(QPixmap(xpm_choice_no));
1348 	ConfigItem::menuIcon = QIcon(QPixmap(xpm_menu));
1349 	ConfigItem::menubackIcon = QIcon(QPixmap(xpm_menuback));
1350 
1351 	QWidget *widget = new QWidget(this);
1352 	QVBoxLayout *layout = new QVBoxLayout(widget);
1353 	setCentralWidget(widget);
1354 
1355 	split1 = new QSplitter(widget);
1356 	split1->setOrientation(Qt::Horizontal);
1357 	split1->setChildrenCollapsible(false);
1358 
1359 	menuList = new ConfigList(widget, "menu");
1360 
1361 	split2 = new QSplitter(widget);
1362 	split2->setChildrenCollapsible(false);
1363 	split2->setOrientation(Qt::Vertical);
1364 
1365 	// create config tree
1366 	configList = new ConfigList(widget, "config");
1367 
1368 	helpText = new ConfigInfoView(widget, "help");
1369 
1370 	layout->addWidget(split2);
1371 	split2->addWidget(split1);
1372 	split1->addWidget(configList);
1373 	split1->addWidget(menuList);
1374 	split2->addWidget(helpText);
1375 
1376 	setTabOrder(configList, helpText);
1377 	configList->setFocus();
1378 
1379 	backAction = new QAction(QPixmap(xpm_back), "Back", this);
1380 	connect(backAction, &QAction::triggered,
1381 		this, &ConfigMainWindow::goBack);
1382 
1383 	QAction *quitAction = new QAction("&Quit", this);
1384 	quitAction->setShortcut(Qt::CTRL | Qt::Key_Q);
1385 	connect(quitAction, &QAction::triggered,
1386 		this, &ConfigMainWindow::close);
1387 
1388 	QAction *loadAction = new QAction(QPixmap(xpm_load), "&Load", this);
1389 	loadAction->setShortcut(Qt::CTRL | Qt::Key_L);
1390 	connect(loadAction, &QAction::triggered,
1391 		this, &ConfigMainWindow::loadConfig);
1392 
1393 	saveAction = new QAction(QPixmap(xpm_save), "&Save", this);
1394 	saveAction->setShortcut(Qt::CTRL | Qt::Key_S);
1395 	connect(saveAction, &QAction::triggered,
1396 		this, &ConfigMainWindow::saveConfig);
1397 
1398 	conf_set_changed_callback(conf_changed);
1399 
1400 	// Set saveAction's initial state
1401 	conf_changed();
1402 	configname = xstrdup(conf_get_configname());
1403 
1404 	QAction *saveAsAction = new QAction("Save &As...", this);
1405 	connect(saveAsAction, &QAction::triggered,
1406 		this, &ConfigMainWindow::saveConfigAs);
1407 	QAction *searchAction = new QAction("&Find", this);
1408 	searchAction->setShortcut(Qt::CTRL | Qt::Key_F);
1409 	connect(searchAction, &QAction::triggered,
1410 		this, &ConfigMainWindow::searchConfig);
1411 	singleViewAction = new QAction(QPixmap(xpm_single_view), "Single View", this);
1412 	singleViewAction->setCheckable(true);
1413 	connect(singleViewAction, &QAction::triggered,
1414 		this, &ConfigMainWindow::showSingleView);
1415 	splitViewAction = new QAction(QPixmap(xpm_split_view), "Split View", this);
1416 	splitViewAction->setCheckable(true);
1417 	connect(splitViewAction, &QAction::triggered,
1418 		this, &ConfigMainWindow::showSplitView);
1419 	fullViewAction = new QAction(QPixmap(xpm_tree_view), "Full View", this);
1420 	fullViewAction->setCheckable(true);
1421 	connect(fullViewAction, &QAction::triggered,
1422 		this, &ConfigMainWindow::showFullView);
1423 
1424 	QAction *showNameAction = new QAction("Show Name", this);
1425 	  showNameAction->setCheckable(true);
1426 	connect(showNameAction, &QAction::toggled,
1427 		configList, &ConfigList::setShowName);
1428 	showNameAction->setChecked(configList->showName);
1429 
1430 	QActionGroup *optGroup = new QActionGroup(this);
1431 	optGroup->setExclusive(true);
1432 	connect(optGroup, &QActionGroup::triggered,
1433 		configList, &ConfigList::setOptionMode);
1434 	connect(optGroup, &QActionGroup::triggered,
1435 		menuList, &ConfigList::setOptionMode);
1436 
1437 	ConfigList::showNormalAction = new QAction("Show Normal Options", optGroup);
1438 	ConfigList::showNormalAction->setCheckable(true);
1439 	ConfigList::showAllAction = new QAction("Show All Options", optGroup);
1440 	ConfigList::showAllAction->setCheckable(true);
1441 	ConfigList::showPromptAction = new QAction("Show Prompt Options", optGroup);
1442 	ConfigList::showPromptAction->setCheckable(true);
1443 
1444 	QAction *showDebugAction = new QAction("Show Debug Info", this);
1445 	  showDebugAction->setCheckable(true);
1446 	connect(showDebugAction, &QAction::toggled,
1447 		helpText, &ConfigInfoView::setShowDebug);
1448 	  showDebugAction->setChecked(helpText->showDebug());
1449 
1450 	QAction *showIntroAction = new QAction("Introduction", this);
1451 	connect(showIntroAction, &QAction::triggered,
1452 		this, &ConfigMainWindow::showIntro);
1453 	QAction *showAboutAction = new QAction("About", this);
1454 	connect(showAboutAction, &QAction::triggered,
1455 		this, &ConfigMainWindow::showAbout);
1456 
1457 	// init tool bar
1458 	QToolBar *toolBar = addToolBar("Tools");
1459 	toolBar->addAction(backAction);
1460 	toolBar->addSeparator();
1461 	toolBar->addAction(loadAction);
1462 	toolBar->addAction(saveAction);
1463 	toolBar->addSeparator();
1464 	toolBar->addAction(singleViewAction);
1465 	toolBar->addAction(splitViewAction);
1466 	toolBar->addAction(fullViewAction);
1467 
1468 	// create file menu
1469 	QMenu *menu = menuBar()->addMenu("&File");
1470 	menu->addAction(loadAction);
1471 	menu->addAction(saveAction);
1472 	menu->addAction(saveAsAction);
1473 	menu->addSeparator();
1474 	menu->addAction(quitAction);
1475 
1476 	// create edit menu
1477 	menu = menuBar()->addMenu("&Edit");
1478 	menu->addAction(searchAction);
1479 
1480 	// create options menu
1481 	menu = menuBar()->addMenu("&Option");
1482 	menu->addAction(showNameAction);
1483 	menu->addSeparator();
1484 	menu->addActions(optGroup->actions());
1485 	menu->addSeparator();
1486 	menu->addAction(showDebugAction);
1487 
1488 	// create help menu
1489 	menu = menuBar()->addMenu("&Help");
1490 	menu->addAction(showIntroAction);
1491 	menu->addAction(showAboutAction);
1492 
1493 	connect(helpText, &ConfigInfoView::anchorClicked,
1494 		helpText, &ConfigInfoView::clicked);
1495 
1496 	connect(configList, &ConfigList::menuChanged,
1497 		helpText, &ConfigInfoView::setInfo);
1498 	connect(configList, &ConfigList::menuSelected,
1499 		this, &ConfigMainWindow::changeMenu);
1500 	connect(configList, &ConfigList::itemSelected,
1501 		this, &ConfigMainWindow::changeItens);
1502 	connect(configList, &ConfigList::parentSelected,
1503 		this, &ConfigMainWindow::goBack);
1504 	connect(menuList, &ConfigList::menuChanged,
1505 		helpText, &ConfigInfoView::setInfo);
1506 	connect(menuList, &ConfigList::menuSelected,
1507 		this, &ConfigMainWindow::changeMenu);
1508 
1509 	connect(configList, &ConfigList::gotFocus,
1510 		helpText, &ConfigInfoView::setInfo);
1511 	connect(menuList, &ConfigList::gotFocus,
1512 		helpText, &ConfigInfoView::setInfo);
1513 	connect(menuList, &ConfigList::gotFocus,
1514 		this, &ConfigMainWindow::listFocusChanged);
1515 	connect(helpText, &ConfigInfoView::menuSelected,
1516 		this, &ConfigMainWindow::setMenuLink);
1517 
1518 	QString listMode = configSettings->value("/listMode", "symbol").toString();
1519 	if (listMode == "single")
1520 		showSingleView();
1521 	else if (listMode == "full")
1522 		showFullView();
1523 	else /*if (listMode == "split")*/
1524 		showSplitView();
1525 
1526 	// UI setup done, restore splitter positions
1527 	QList<int> sizes = configSettings->readSizes("/split1", &ok);
1528 	if (ok)
1529 		split1->setSizes(sizes);
1530 
1531 	sizes = configSettings->readSizes("/split2", &ok);
1532 	if (ok)
1533 		split2->setSizes(sizes);
1534 }
1535 
1536 void ConfigMainWindow::loadConfig(void)
1537 {
1538 	QString str;
1539 	QByteArray ba;
1540 	const char *name;
1541 
1542 	str = QFileDialog::getOpenFileName(this, "", configname);
1543 	if (str.isNull())
1544 		return;
1545 
1546 	ba = str.toLocal8Bit();
1547 	name = ba.data();
1548 
1549 	if (conf_read(name))
1550 		QMessageBox::information(this, "qconf", "Unable to load configuration!");
1551 
1552 	free(configname);
1553 	configname = xstrdup(name);
1554 
1555 	ConfigList::updateListAllForAll();
1556 }
1557 
1558 bool ConfigMainWindow::saveConfig(void)
1559 {
1560 	if (conf_write(configname)) {
1561 		QMessageBox::information(this, "qconf", "Unable to save configuration!");
1562 		return false;
1563 	}
1564 	conf_write_autoconf(0);
1565 
1566 	return true;
1567 }
1568 
1569 void ConfigMainWindow::saveConfigAs(void)
1570 {
1571 	QString str;
1572 	QByteArray ba;
1573 	const char *name;
1574 
1575 	str = QFileDialog::getSaveFileName(this, "", configname);
1576 	if (str.isNull())
1577 		return;
1578 
1579 	ba = str.toLocal8Bit();
1580 	name = ba.data();
1581 
1582 	if (conf_write(name)) {
1583 		QMessageBox::information(this, "qconf", "Unable to save configuration!");
1584 	}
1585 	conf_write_autoconf(0);
1586 
1587 	free(configname);
1588 	configname = xstrdup(name);
1589 }
1590 
1591 void ConfigMainWindow::searchConfig(void)
1592 {
1593 	if (!searchWindow)
1594 		searchWindow = new ConfigSearchWindow(this);
1595 	searchWindow->show();
1596 }
1597 
1598 void ConfigMainWindow::changeItens(struct menu *menu)
1599 {
1600 	configList->setRootMenu(menu);
1601 }
1602 
1603 void ConfigMainWindow::changeMenu(struct menu *menu)
1604 {
1605 	menuList->setRootMenu(menu);
1606 }
1607 
1608 void ConfigMainWindow::setMenuLink(struct menu *menu)
1609 {
1610 	struct menu *parent;
1611 	ConfigList* list = NULL;
1612 	ConfigItem* item;
1613 
1614 	if (configList->menuSkip(menu))
1615 		return;
1616 
1617 	switch (configList->mode) {
1618 	case singleMode:
1619 		list = configList;
1620 		parent = menu_get_parent_menu(menu);
1621 		if (!parent)
1622 			return;
1623 		list->setRootMenu(parent);
1624 		break;
1625 	case menuMode:
1626 		if (menu->flags & MENU_ROOT) {
1627 			menuList->setRootMenu(menu);
1628 			configList->clearSelection();
1629 			list = configList;
1630 		} else {
1631 			parent = menu_get_parent_menu(menu->parent);
1632 			if (!parent)
1633 				return;
1634 
1635 			/* Select the config view */
1636 			item = configList->findConfigItem(parent);
1637 			if (item) {
1638 				configList->setSelected(item, true);
1639 				configList->scrollToItem(item);
1640 			}
1641 
1642 			menuList->setRootMenu(parent);
1643 			menuList->clearSelection();
1644 			list = menuList;
1645 		}
1646 		break;
1647 	case fullMode:
1648 		list = configList;
1649 		break;
1650 	default:
1651 		break;
1652 	}
1653 
1654 	if (list) {
1655 		item = list->findConfigItem(menu);
1656 		if (item) {
1657 			list->setSelected(item, true);
1658 			list->scrollToItem(item);
1659 			list->setFocus();
1660 			helpText->setInfo(menu);
1661 		}
1662 	}
1663 }
1664 
1665 void ConfigMainWindow::listFocusChanged(void)
1666 {
1667 	if (menuList->mode == menuMode)
1668 		configList->clearSelection();
1669 }
1670 
1671 void ConfigMainWindow::goBack(void)
1672 {
1673 	if (configList->rootEntry == &rootmenu)
1674 		return;
1675 
1676 	configList->setParentMenu();
1677 }
1678 
1679 void ConfigMainWindow::showSingleView(void)
1680 {
1681 	singleViewAction->setEnabled(false);
1682 	singleViewAction->setChecked(true);
1683 	splitViewAction->setEnabled(true);
1684 	splitViewAction->setChecked(false);
1685 	fullViewAction->setEnabled(true);
1686 	fullViewAction->setChecked(false);
1687 
1688 	backAction->setEnabled(true);
1689 
1690 	menuList->hide();
1691 	menuList->setRootMenu(0);
1692 	configList->mode = singleMode;
1693 	if (configList->rootEntry == &rootmenu)
1694 		configList->updateListAll();
1695 	else
1696 		configList->setRootMenu(&rootmenu);
1697 	configList->setFocus();
1698 }
1699 
1700 void ConfigMainWindow::showSplitView(void)
1701 {
1702 	singleViewAction->setEnabled(true);
1703 	singleViewAction->setChecked(false);
1704 	splitViewAction->setEnabled(false);
1705 	splitViewAction->setChecked(true);
1706 	fullViewAction->setEnabled(true);
1707 	fullViewAction->setChecked(false);
1708 
1709 	backAction->setEnabled(false);
1710 
1711 	configList->mode = menuMode;
1712 	if (configList->rootEntry == &rootmenu)
1713 		configList->updateListAll();
1714 	else
1715 		configList->setRootMenu(&rootmenu);
1716 	configList->setAllOpen(true);
1717 	configApp->processEvents();
1718 	menuList->mode = symbolMode;
1719 	menuList->setRootMenu(&rootmenu);
1720 	menuList->setAllOpen(true);
1721 	menuList->show();
1722 	menuList->setFocus();
1723 }
1724 
1725 void ConfigMainWindow::showFullView(void)
1726 {
1727 	singleViewAction->setEnabled(true);
1728 	singleViewAction->setChecked(false);
1729 	splitViewAction->setEnabled(true);
1730 	splitViewAction->setChecked(false);
1731 	fullViewAction->setEnabled(false);
1732 	fullViewAction->setChecked(true);
1733 
1734 	backAction->setEnabled(false);
1735 
1736 	menuList->hide();
1737 	menuList->setRootMenu(0);
1738 	configList->mode = fullMode;
1739 	if (configList->rootEntry == &rootmenu)
1740 		configList->updateListAll();
1741 	else
1742 		configList->setRootMenu(&rootmenu);
1743 	configList->setFocus();
1744 }
1745 
1746 /*
1747  * ask for saving configuration before quitting
1748  */
1749 void ConfigMainWindow::closeEvent(QCloseEvent* e)
1750 {
1751 	if (!conf_get_changed()) {
1752 		e->accept();
1753 		return;
1754 	}
1755 
1756 	QMessageBox mb(QMessageBox::Icon::Warning, "qconf",
1757 		       "Save configuration?");
1758 
1759 	QPushButton *yb = mb.addButton(QMessageBox::Yes);
1760 	QPushButton *db = mb.addButton(QMessageBox::No);
1761 	QPushButton *cb = mb.addButton(QMessageBox::Cancel);
1762 
1763 	yb->setText("&Save Changes");
1764 	db->setText("&Discard Changes");
1765 	cb->setText("Cancel Exit");
1766 
1767 	mb.setDefaultButton(yb);
1768 	mb.setEscapeButton(cb);
1769 
1770 	switch (mb.exec()) {
1771 	case QMessageBox::Yes:
1772 		if (saveConfig())
1773 			e->accept();
1774 		else
1775 			e->ignore();
1776 		break;
1777 	case QMessageBox::No:
1778 		e->accept();
1779 		break;
1780 	case QMessageBox::Cancel:
1781 		e->ignore();
1782 		break;
1783 	}
1784 }
1785 
1786 void ConfigMainWindow::showIntro(void)
1787 {
1788 	static const QString str =
1789 		"Welcome to the qconf graphical configuration tool.\n"
1790 		"\n"
1791 		"For bool and tristate options, a blank box indicates the "
1792 		"feature is disabled, a check indicates it is enabled, and a "
1793 		"dot indicates that it is to be compiled as a module. Clicking "
1794 		"on the box will cycle through the three states. For int, hex, "
1795 		"and string options, double-clicking or pressing F2 on the "
1796 		"Value cell will allow you to edit the value.\n"
1797 		"\n"
1798 		"If you do not see an option (e.g., a device driver) that you "
1799 		"believe should be present, try turning on Show All Options "
1800 		"under the Options menu. Enabling Show Debug Info will help you"
1801 		"figure out what other options must be enabled to support the "
1802 		"option you are interested in, and hyperlinks will navigate to "
1803 		"them.\n"
1804 		"\n"
1805 		"Toggling Show Debug Info under the Options menu will show the "
1806 		"dependencies, which you can then match by examining other "
1807 		"options.\n";
1808 
1809 	QMessageBox::information(this, "qconf", str);
1810 }
1811 
1812 void ConfigMainWindow::showAbout(void)
1813 {
1814 	static const QString str = "qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n"
1815 		"Copyright (C) 2015 Boris Barbulovski <bbarbulovski@gmail.com>.\n"
1816 		"\n"
1817 		"Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n"
1818 		"\n"
1819 		"Qt Version: ";
1820 
1821 	QMessageBox::information(this, "qconf", str + qVersion());
1822 }
1823 
1824 void ConfigMainWindow::saveSettings(void)
1825 {
1826 	configSettings->setValue("/window x", pos().x());
1827 	configSettings->setValue("/window y", pos().y());
1828 	configSettings->setValue("/window width", size().width());
1829 	configSettings->setValue("/window height", size().height());
1830 
1831 	QString entry;
1832 	switch(configList->mode) {
1833 	case singleMode :
1834 		entry = "single";
1835 		break;
1836 
1837 	case symbolMode :
1838 		entry = "split";
1839 		break;
1840 
1841 	case fullMode :
1842 		entry = "full";
1843 		break;
1844 
1845 	default:
1846 		break;
1847 	}
1848 	configSettings->setValue("/listMode", entry);
1849 
1850 	configSettings->writeSizes("/split1", split1->sizes());
1851 	configSettings->writeSizes("/split2", split2->sizes());
1852 }
1853 
1854 void ConfigMainWindow::conf_changed(void)
1855 {
1856 	if (saveAction)
1857 		saveAction->setEnabled(conf_get_changed());
1858 }
1859 
1860 void fixup_rootmenu(struct menu *menu)
1861 {
1862 	struct menu *child;
1863 	static int menu_cnt = 0;
1864 
1865 	menu->flags |= MENU_ROOT;
1866 	for (child = menu->list; child; child = child->next) {
1867 		if (child->prompt && child->prompt->type == P_MENU) {
1868 			menu_cnt++;
1869 			fixup_rootmenu(child);
1870 			menu_cnt--;
1871 		} else if (!menu_cnt)
1872 			fixup_rootmenu(child);
1873 	}
1874 }
1875 
1876 static const char *progname;
1877 
1878 static void usage(void)
1879 {
1880 	printf("%s [-s] <config>\n", progname);
1881 	exit(0);
1882 }
1883 
1884 int main(int ac, char** av)
1885 {
1886 	ConfigMainWindow* v;
1887 	const char *name;
1888 
1889 	progname = av[0];
1890 	if (ac > 1 && av[1][0] == '-') {
1891 		switch (av[1][1]) {
1892 		case 's':
1893 			conf_set_message_callback(NULL);
1894 			break;
1895 		case 'h':
1896 		case '?':
1897 			usage();
1898 		}
1899 		name = av[2];
1900 	} else
1901 		name = av[1];
1902 	if (!name)
1903 		usage();
1904 
1905 	conf_parse(name);
1906 	fixup_rootmenu(&rootmenu);
1907 	conf_read(NULL);
1908 	//zconfdump(stdout);
1909 
1910 	configApp = new QApplication(ac, av);
1911 
1912 	configSettings = new ConfigSettings();
1913 	configSettings->beginGroup("/kconfig/qconf");
1914 	v = new ConfigMainWindow();
1915 
1916 	//zconfdump(stdout);
1917 	configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1918 	configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
1919 	v->show();
1920 	configApp->exec();
1921 
1922 	configSettings->endGroup();
1923 	delete configSettings;
1924 	delete v;
1925 	delete configApp;
1926 
1927 	return 0;
1928 }
1929