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