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