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