blob: 91b7e6fbc364ae53846130eb2a82517c422eb5d4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
Boris Barbulovskib4ff1de2015-09-22 11:36:38 -07003 * Copyright (C) 2015 Boris Barbulovski <bbarbulovski@gmail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Released under the terms of the GNU GPL v2.0.
5 */
6
Alexander Stein133c5f72010-08-31 17:34:37 +02007#include <qglobal.h>
8
Boris Barbulovskib1f8a452015-09-22 11:36:02 -07009#include <QMainWindow>
Boris Barbulovski041fbdc2015-09-22 11:36:05 -070010#include <QList>
Boris Barbulovski924bbb52015-09-22 11:36:06 -070011#include <qtextbrowser.h>
Boris Barbulovski85eaf282015-09-22 11:36:03 -070012#include <QAction>
Boris Barbulovskibea00772015-09-22 11:36:04 -070013#include <QFileDialog>
Boris Barbulovski76bede82015-09-22 11:36:07 -070014#include <QMenu>
Alexander Stein133c5f72010-08-31 17:34:37 +020015
16#include <qapplication.h>
Markus Heidelberg8d90c972009-05-18 01:36:52 +020017#include <qdesktopwidget.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <qtoolbar.h>
Roman Zippel43bf6122006-06-08 22:12:45 -070019#include <qlayout.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <qsplitter.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <qlineedit.h>
Roman Zippel43bf6122006-06-08 22:12:45 -070022#include <qlabel.h>
23#include <qpushbutton.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <qmenubar.h>
25#include <qmessagebox.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <qregexp.h>
Alexander Stein133c5f72010-08-31 17:34:37 +020027#include <qevent.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include <stdlib.h>
30
31#include "lkc.h"
32#include "qconf.h"
33
34#include "qconf.moc"
35#include "images.c"
36
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070037#ifdef _
38# undef _
39# define _ qgettext
40#endif
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042static QApplication *configApp;
Roman Zippel7fc925f2006-06-08 22:12:46 -070043static ConfigSettings *configSettings;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Boris Barbulovski85eaf282015-09-22 11:36:03 -070045QAction *ConfigMainWindow::saveAction;
Karsten Wiese3b354c52006-12-13 00:34:08 -080046
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070047static inline QString qgettext(const char* str)
48{
Roman Zippel43bf6122006-06-08 22:12:45 -070049 return QString::fromLocal8Bit(gettext(str));
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070050}
51
52static inline QString qgettext(const QString& str)
53{
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -070054 return QString::fromLocal8Bit(gettext(str.toLatin1()));
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070055}
56
Ben Hutchings00d4f8f2013-10-06 19:21:31 +010057ConfigSettings::ConfigSettings()
58 : QSettings("kernel.org", "qconf")
59{
60}
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062/**
63 * Reads a list of integer values from the application settings.
64 */
Boris Barbulovski041fbdc2015-09-22 11:36:05 -070065QList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
Boris Barbulovski041fbdc2015-09-22 11:36:05 -070067 QList<int> result;
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -070068 QStringList entryList = value(key).toStringList();
Li Zefanc1f96f02010-05-07 13:58:04 +080069 QStringList::Iterator it;
70
71 for (it = entryList.begin(); it != entryList.end(); ++it)
72 result.push_back((*it).toInt());
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74 return result;
75}
76
77/**
78 * Writes a list of integer values to the application settings.
79 */
Boris Barbulovski041fbdc2015-09-22 11:36:05 -070080bool ConfigSettings::writeSizes(const QString& key, const QList<int>& value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
82 QStringList stringList;
Boris Barbulovski041fbdc2015-09-22 11:36:05 -070083 QList<int>::ConstIterator it;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
85 for (it = value.begin(); it != value.end(); ++it)
86 stringList.push_back(QString::number(*it));
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -070087 setValue(key, stringList);
Boris Barbulovski59e56442015-09-22 11:36:18 -070088
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -070089 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Boris Barbulovski59e56442015-09-22 11:36:18 -070092
93/*
94 * set the new data
95 * TODO check the value
96 */
97void ConfigItem::okRename(int col)
98{
99}
100
101/*
102 * update the displayed of a menu entry
103 */
104void ConfigItem::updateMenu(void)
105{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700106 ConfigList* list;
107 struct symbol* sym;
108 struct property *prop;
109 QString prompt;
110 int type;
111 tristate expr;
112
113 list = listView();
114 if (goParent) {
115 setPixmap(promptColIdx, list->menuBackPix);
116 prompt = "..";
117 goto set_prompt;
118 }
119
120 sym = menu->sym;
121 prop = menu->prompt;
122 prompt = _(menu_get_prompt(menu));
123
124 if (prop) switch (prop->type) {
125 case P_MENU:
126 if (list->mode == singleMode || list->mode == symbolMode) {
127 /* a menuconfig entry is displayed differently
128 * depending whether it's at the view root or a child.
129 */
130 if (sym && list->rootEntry == menu)
131 break;
132 setPixmap(promptColIdx, list->menuPix);
133 } else {
134 if (sym)
135 break;
136 setPixmap(promptColIdx, QIcon());
137 }
138 goto set_prompt;
139 case P_COMMENT:
140 setPixmap(promptColIdx, QIcon());
141 goto set_prompt;
142 default:
143 ;
144 }
145 if (!sym)
146 goto set_prompt;
147
148 setText(nameColIdx, QString::fromLocal8Bit(sym->name));
149
150 type = sym_get_type(sym);
151 switch (type) {
152 case S_BOOLEAN:
153 case S_TRISTATE:
154 char ch;
155
156 if (!sym_is_changable(sym) && list->optMode == normalOpt) {
157 setPixmap(promptColIdx, QIcon());
158 setText(noColIdx, QString::null);
159 setText(modColIdx, QString::null);
160 setText(yesColIdx, QString::null);
161 break;
162 }
163 expr = sym_get_tristate_value(sym);
164 switch (expr) {
165 case yes:
166 if (sym_is_choice_value(sym) && type == S_BOOLEAN)
167 setPixmap(promptColIdx, list->choiceYesPix);
168 else
169 setPixmap(promptColIdx, list->symbolYesPix);
170 setText(yesColIdx, "Y");
171 ch = 'Y';
172 break;
173 case mod:
174 setPixmap(promptColIdx, list->symbolModPix);
175 setText(modColIdx, "M");
176 ch = 'M';
177 break;
178 default:
179 if (sym_is_choice_value(sym) && type == S_BOOLEAN)
180 setPixmap(promptColIdx, list->choiceNoPix);
181 else
182 setPixmap(promptColIdx, list->symbolNoPix);
183 setText(noColIdx, "N");
184 ch = 'N';
185 break;
186 }
187 if (expr != no)
188 setText(noColIdx, sym_tristate_within_range(sym, no) ? "_" : 0);
189 if (expr != mod)
190 setText(modColIdx, sym_tristate_within_range(sym, mod) ? "_" : 0);
191 if (expr != yes)
192 setText(yesColIdx, sym_tristate_within_range(sym, yes) ? "_" : 0);
193
194 setText(dataColIdx, QChar(ch));
195 break;
196 case S_INT:
197 case S_HEX:
198 case S_STRING:
199 const char* data;
200
201 data = sym_get_string_value(sym);
202
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700203 setText(dataColIdx, data);
204 if (type == S_STRING)
205 prompt = QString("%1: %2").arg(prompt).arg(data);
206 else
207 prompt = QString("(%2) %1").arg(prompt).arg(data);
208 break;
209 }
210 if (!sym_has_value(sym) && visible)
211 prompt += _(" (NEW)");
212set_prompt:
213 setText(promptColIdx, prompt);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700214}
215
216void ConfigItem::testUpdateMenu(bool v)
217{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700218 ConfigItem* i;
219
220 visible = v;
221 if (!menu)
222 return;
223
224 sym_calc_value(menu->sym);
225 if (menu->flags & MENU_CHANGED) {
226 /* the menu entry changed, so update all list items */
227 menu->flags &= ~MENU_CHANGED;
228 for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
229 i->updateMenu();
230 } else if (listView()->updateAll)
231 updateMenu();
Boris Barbulovski59e56442015-09-22 11:36:18 -0700232}
233
234
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700235/*
236 * construct a menu entry
237 */
238void ConfigItem::init(void)
239{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700240 if (menu) {
241 ConfigList* list = listView();
242 nextItem = (ConfigItem*)menu->data;
243 menu->data = this;
244
245 if (list->mode != fullMode)
246 setExpanded(true);
247 sym_calc_value(menu->sym);
248 }
249 updateMenu();
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700250}
251
252/*
253 * destruct a menu entry
254 */
255ConfigItem::~ConfigItem(void)
256{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700257 if (menu) {
258 ConfigItem** ip = (ConfigItem**)&menu->data;
259 for (; *ip; ip = &(*ip)->nextItem) {
260 if (*ip == this) {
261 *ip = nextItem;
262 break;
263 }
264 }
265 }
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700266}
267
Roman Zippel43bf6122006-06-08 22:12:45 -0700268ConfigLineEdit::ConfigLineEdit(ConfigView* parent)
269 : Parent(parent)
270{
Boris Barbulovskic14fa5e2015-09-22 11:36:21 -0700271 connect(this, SIGNAL(editingFinished()), SLOT(hide()));
Roman Zippel43bf6122006-06-08 22:12:45 -0700272}
273
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700274void ConfigLineEdit::show(ConfigItem* i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
276 item = i;
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700277 if (sym_get_string_value(item->menu->sym))
278 setText(QString::fromLocal8Bit(sym_get_string_value(item->menu->sym)));
279 else
280 setText(QString::null);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 Parent::show();
282 setFocus();
283}
284
285void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
286{
287 switch (e->key()) {
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200288 case Qt::Key_Escape:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 break;
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200290 case Qt::Key_Return:
291 case Qt::Key_Enter:
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700292 sym_set_string_value(item->menu->sym, text().toLatin1());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 parent()->updateList(item);
294 break;
295 default:
296 Parent::keyPressEvent(e);
297 return;
298 }
299 e->accept();
300 parent()->list->setFocus();
301 hide();
302}
303
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700304ConfigList::ConfigList(ConfigView* p, const char *name)
Boris Barbulovski59e56442015-09-22 11:36:18 -0700305 : Parent(p),
306 updateAll(false),
307 symbolYesPix(xpm_symbol_yes), symbolModPix(xpm_symbol_mod), symbolNoPix(xpm_symbol_no),
308 choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no),
309 menuPix(xpm_menu), menuInvPix(xpm_menu_inv), menuBackPix(xpm_menuback), voidPix(xpm_void),
Boris Barbulovskidbf62932015-09-22 11:36:26 -0700310 showName(false), showRange(false), showData(false), mode(singleMode), optMode(normalOpt),
Boris Barbulovski59e56442015-09-22 11:36:18 -0700311 rootEntry(0), headerPopup(0)
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700312{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700313 int i;
314
315 setObjectName(name);
Boris Barbulovskia5225e92015-09-22 11:36:29 -0700316 setSortingEnabled(false);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700317 setRootIsDecorated(true);
318
Boris Barbulovskif999cc02015-09-22 11:36:31 -0700319 setVerticalScrollMode(ScrollPerPixel);
320 setHorizontalScrollMode(ScrollPerPixel);
321
Boris Barbulovskia52cb3212015-09-22 11:36:24 -0700322 setHeaderLabels(QStringList() << _("Option") << _("Name") << "N" << "M" << "Y" << _("Value"));
323
Boris Barbulovskic14fa5e2015-09-22 11:36:21 -0700324 connect(this, SIGNAL(itemSelectionChanged(void)),
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700325 SLOT(updateSelection(void)));
326
327 if (name) {
328 configSettings->beginGroup(name);
329 showName = configSettings->value("/showName", false).toBool();
330 showRange = configSettings->value("/showRange", false).toBool();
331 showData = configSettings->value("/showData", false).toBool();
332 optMode = (enum optionMode)configSettings->value("/optionMode", 0).toInt();
333 configSettings->endGroup();
334 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
335 }
336
337 addColumn(promptColIdx);
338
339 reinit();
340}
341
342bool ConfigList::menuSkip(struct menu *menu)
343{
344 if (optMode == normalOpt && menu_is_visible(menu))
345 return false;
346 if (optMode == promptOpt && menu_has_prompt(menu))
347 return false;
348 if (optMode == allOpt)
349 return false;
350 return true;
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700351}
Boris Barbulovski59e56442015-09-22 11:36:18 -0700352
353void ConfigList::reinit(void)
354{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700355 removeColumn(dataColIdx);
356 removeColumn(yesColIdx);
357 removeColumn(modColIdx);
358 removeColumn(noColIdx);
359 removeColumn(nameColIdx);
360
361 if (showName)
362 addColumn(nameColIdx);
363 if (showRange) {
364 addColumn(noColIdx);
365 addColumn(modColIdx);
366 addColumn(yesColIdx);
367 }
368 if (showData)
369 addColumn(dataColIdx);
370
371 updateListAll();
Boris Barbulovski59e56442015-09-22 11:36:18 -0700372}
373
374void ConfigList::saveSettings(void)
375{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700376 if (!objectName().isEmpty()) {
377 configSettings->beginGroup(objectName());
378 configSettings->setValue("/showName", showName);
379 configSettings->setValue("/showRange", showRange);
380 configSettings->setValue("/showData", showData);
381 configSettings->setValue("/optionMode", (int)optMode);
382 configSettings->endGroup();
383 }
Boris Barbulovski59e56442015-09-22 11:36:18 -0700384}
385
386ConfigItem* ConfigList::findConfigItem(struct menu *menu)
387{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700388 ConfigItem* item = (ConfigItem*)menu->data;
389
390 for (; item; item = item->nextItem) {
391 if (this == item->listView())
392 break;
393 }
394
395 return item;
Boris Barbulovski59e56442015-09-22 11:36:18 -0700396}
397
398void ConfigList::updateSelection(void)
399{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700400 struct menu *menu;
401 enum prop_type type;
402
Boris Barbulovskibe596aa2015-09-22 11:36:28 -0700403 if (selectedItems().count() == 0)
404 return;
405
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700406 ConfigItem* item = (ConfigItem*)selectedItems().first();
407 if (!item)
408 return;
409
410 menu = item->menu;
411 emit menuChanged(menu);
412 if (!menu)
413 return;
414 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
415 if (mode == menuMode && type == P_MENU)
416 emit menuSelected(menu);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700417}
418
419void ConfigList::updateList(ConfigItem* item)
420{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700421 ConfigItem* last = 0;
422
423 if (!rootEntry) {
424 if (mode != listMode)
425 goto update;
426 QTreeWidgetItemIterator it(this);
427 ConfigItem* item;
428
429 while (*it) {
430 item = (ConfigItem*)(*it);
431 if (!item->menu)
432 continue;
433 item->testUpdateMenu(menu_is_visible(item->menu));
434
435 ++it;
436 }
437 return;
438 }
439
440 if (rootEntry != &rootmenu && (mode == singleMode ||
441 (mode == symbolMode && rootEntry->parent != &rootmenu))) {
Boris Barbulovskiee7298f2015-09-22 11:36:37 -0700442 item = (ConfigItem *)topLevelItem(0);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700443 if (!item)
444 item = new ConfigItem(this, 0, true);
445 last = item;
446 }
447 if ((mode == singleMode || (mode == symbolMode && !(rootEntry->flags & MENU_ROOT))) &&
448 rootEntry->sym && rootEntry->prompt) {
449 item = last ? last->nextSibling() : firstChild();
450 if (!item)
451 item = new ConfigItem(this, last, rootEntry, true);
452 else
453 item->testUpdateMenu(true);
454
455 updateMenuList(item, rootEntry);
456 update();
Boris Barbulovskif999cc02015-09-22 11:36:31 -0700457 resizeColumnToContents(0);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700458 return;
459 }
460update:
461 updateMenuList(this, rootEntry);
462 update();
Boris Barbulovskif999cc02015-09-22 11:36:31 -0700463 resizeColumnToContents(0);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700464}
465
466void ConfigList::setValue(ConfigItem* item, tristate val)
467{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700468 struct symbol* sym;
469 int type;
470 tristate oldval;
471
472 sym = item->menu ? item->menu->sym : 0;
473 if (!sym)
474 return;
475
476 type = sym_get_type(sym);
477 switch (type) {
478 case S_BOOLEAN:
479 case S_TRISTATE:
480 oldval = sym_get_tristate_value(sym);
481
482 if (!sym_set_tristate_value(sym, val))
483 return;
484 if (oldval == no && item->menu->list)
485 item->setExpanded(true);
486 parent()->updateList(item);
487 break;
488 }
Boris Barbulovski59e56442015-09-22 11:36:18 -0700489}
490
491void ConfigList::changeValue(ConfigItem* item)
492{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700493 struct symbol* sym;
494 struct menu* menu;
495 int type, oldexpr, newexpr;
496
497 menu = item->menu;
498 if (!menu)
499 return;
500 sym = menu->sym;
501 if (!sym) {
502 if (item->menu->list)
503 item->setExpanded(!item->isExpanded());
504 return;
505 }
506
507 type = sym_get_type(sym);
508 switch (type) {
509 case S_BOOLEAN:
510 case S_TRISTATE:
511 oldexpr = sym_get_tristate_value(sym);
512 newexpr = sym_toggle_tristate_value(sym);
513 if (item->menu->list) {
514 if (oldexpr == newexpr)
515 item->setExpanded(!item->isExpanded());
516 else if (oldexpr == no)
517 item->setExpanded(true);
518 }
519 if (oldexpr != newexpr)
520 parent()->updateList(item);
521 break;
522 case S_INT:
523 case S_HEX:
524 case S_STRING:
Boris Barbulovskie336b9f2015-09-22 11:36:34 -0700525 parent()->lineEdit->show(item);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700526 break;
527 }
Boris Barbulovski59e56442015-09-22 11:36:18 -0700528}
529
530void ConfigList::setRootMenu(struct menu *menu)
531{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700532 enum prop_type type;
533
534 if (rootEntry == menu)
535 return;
536 type = menu && menu->prompt ? menu->prompt->type : P_UNKNOWN;
537 if (type != P_MENU)
538 return;
539 updateMenuList(this, 0);
540 rootEntry = menu;
541 updateListAll();
542 if (currentItem()) {
543 currentItem()->setSelected(hasFocus());
544 scrollToItem(currentItem());
545 }
Boris Barbulovski59e56442015-09-22 11:36:18 -0700546}
547
548void ConfigList::setParentMenu(void)
549{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700550 ConfigItem* item;
551 struct menu *oldroot;
552
553 oldroot = rootEntry;
554 if (rootEntry == &rootmenu)
555 return;
556 setRootMenu(menu_get_parent_menu(rootEntry->parent));
557
558 QTreeWidgetItemIterator it(this);
559 while (*it) {
560 item = (ConfigItem *)(*it);
561 if (item->menu == oldroot) {
562 setCurrentItem(item);
563 scrollToItem(item);
564 break;
565 }
566
567 ++it;
568 }
Boris Barbulovski59e56442015-09-22 11:36:18 -0700569}
570
571/*
572 * update all the children of a menu entry
573 * removes/adds the entries from the parent widget as necessary
574 *
575 * parent: either the menu list widget or a menu entry widget
576 * menu: entry to be updated
577 */
Boris Barbulovski5c6f1552015-09-22 11:36:27 -0700578void ConfigList::updateMenuList(ConfigItem *parent, struct menu* menu)
Boris Barbulovski59e56442015-09-22 11:36:18 -0700579{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700580 struct menu* child;
581 ConfigItem* item;
582 ConfigItem* last;
583 bool visible;
584 enum prop_type type;
585
586 if (!menu) {
Boris Barbulovski5c6f1552015-09-22 11:36:27 -0700587 while (parent->childCount() > 0)
588 {
589 delete parent->takeChild(0);
590 }
591
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700592 return;
593 }
594
595 last = parent->firstChild();
596 if (last && !last->goParent)
597 last = 0;
598 for (child = menu->list; child; child = child->next) {
599 item = last ? last->nextSibling() : parent->firstChild();
600 type = child->prompt ? child->prompt->type : P_UNKNOWN;
601
602 switch (mode) {
603 case menuMode:
604 if (!(child->flags & MENU_ROOT))
605 goto hide;
606 break;
607 case symbolMode:
608 if (child->flags & MENU_ROOT)
609 goto hide;
610 break;
611 default:
612 break;
613 }
614
615 visible = menu_is_visible(child);
616 if (!menuSkip(child)) {
617 if (!child->sym && !child->list && !child->prompt)
618 continue;
619 if (!item || item->menu != child)
620 item = new ConfigItem(parent, last, child, visible);
621 else
622 item->testUpdateMenu(visible);
623
624 if (mode == fullMode || mode == menuMode || type != P_MENU)
625 updateMenuList(item, child);
626 else
627 updateMenuList(item, 0);
628 last = item;
629 continue;
630 }
631 hide:
632 if (item && item->menu == child) {
633 last = parent->firstChild();
634 if (last == item)
635 last = 0;
636 else while (last->nextSibling() != item)
637 last = last->nextSibling();
638 delete item;
639 }
640 }
Boris Barbulovski59e56442015-09-22 11:36:18 -0700641}
642
Boris Barbulovski5c6f1552015-09-22 11:36:27 -0700643void ConfigList::updateMenuList(ConfigList *parent, struct menu* menu)
644{
645 struct menu* child;
646 ConfigItem* item;
647 ConfigItem* last;
648 bool visible;
649 enum prop_type type;
650
651 if (!menu) {
652 while (parent->topLevelItemCount() > 0)
653 {
654 delete parent->takeTopLevelItem(0);
655 }
656
657 return;
658 }
659
660 last = (ConfigItem*)parent->topLevelItem(0);
661 if (last && !last->goParent)
662 last = 0;
663 for (child = menu->list; child; child = child->next) {
664 item = last ? last->nextSibling() : (ConfigItem*)parent->topLevelItem(0);
665 type = child->prompt ? child->prompt->type : P_UNKNOWN;
666
667 switch (mode) {
668 case menuMode:
669 if (!(child->flags & MENU_ROOT))
670 goto hide;
671 break;
672 case symbolMode:
673 if (child->flags & MENU_ROOT)
674 goto hide;
675 break;
676 default:
677 break;
678 }
679
680 visible = menu_is_visible(child);
681 if (!menuSkip(child)) {
682 if (!child->sym && !child->list && !child->prompt)
683 continue;
684 if (!item || item->menu != child)
685 item = new ConfigItem(parent, last, child, visible);
686 else
687 item->testUpdateMenu(visible);
688
689 if (mode == fullMode || mode == menuMode || type != P_MENU)
690 updateMenuList(item, child);
691 else
692 updateMenuList(item, 0);
693 last = item;
694 continue;
695 }
696 hide:
697 if (item && item->menu == child) {
698 last = (ConfigItem*)parent->topLevelItem(0);
699 if (last == item)
700 last = 0;
701 else while (last->nextSibling() != item)
702 last = last->nextSibling();
703 delete item;
704 }
705 }
706}
707
Boris Barbulovski59e56442015-09-22 11:36:18 -0700708void ConfigList::keyPressEvent(QKeyEvent* ev)
709{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700710 QTreeWidgetItem* i = currentItem();
711 ConfigItem* item;
712 struct menu *menu;
713 enum prop_type type;
714
715 if (ev->key() == Qt::Key_Escape && mode != fullMode && mode != listMode) {
716 emit parentSelected();
717 ev->accept();
718 return;
719 }
720
721 if (!i) {
722 Parent::keyPressEvent(ev);
723 return;
724 }
725 item = (ConfigItem*)i;
726
727 switch (ev->key()) {
728 case Qt::Key_Return:
729 case Qt::Key_Enter:
730 if (item->goParent) {
731 emit parentSelected();
732 break;
733 }
734 menu = item->menu;
735 if (!menu)
736 break;
737 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
738 if (type == P_MENU && rootEntry != menu &&
739 mode != fullMode && mode != menuMode) {
740 emit menuSelected(menu);
741 break;
742 }
743 case Qt::Key_Space:
744 changeValue(item);
745 break;
746 case Qt::Key_N:
747 setValue(item, no);
748 break;
749 case Qt::Key_M:
750 setValue(item, mod);
751 break;
752 case Qt::Key_Y:
753 setValue(item, yes);
754 break;
755 default:
756 Parent::keyPressEvent(ev);
757 return;
758 }
759 ev->accept();
Boris Barbulovski59e56442015-09-22 11:36:18 -0700760}
761
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700762void ConfigList::mousePressEvent(QMouseEvent* e)
Boris Barbulovski59e56442015-09-22 11:36:18 -0700763{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700764 //QPoint p(contentsToViewport(e->pos()));
765 //printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
766 Parent::mousePressEvent(e);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700767}
768
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700769void ConfigList::mouseReleaseEvent(QMouseEvent* e)
Boris Barbulovski59e56442015-09-22 11:36:18 -0700770{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700771 QPoint p = e->pos();
772 ConfigItem* item = (ConfigItem*)itemAt(p);
773 struct menu *menu;
774 enum prop_type ptype;
775 QIcon icon;
776 int idx, x;
777
778 if (!item)
779 goto skip;
780
781 menu = item->menu;
782 x = header()->offset() + p.x();
Boris Barbulovski76d53cb2015-09-22 11:36:35 -0700783 idx = header()->logicalIndexAt(x);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700784 switch (idx) {
785 case promptColIdx:
786 icon = item->pixmap(promptColIdx);
Boris Barbulovski76d53cb2015-09-22 11:36:35 -0700787 if (!icon.isNull()) {
788 int off = header()->sectionPosition(0) + visualRect(indexAt(p)).x() + 4; // 4 is Hardcoded image offset. There might be a way to do it properly.
789 if (x >= off && x < off + icon.availableSizes().first().width()) {
790 if (item->goParent) {
791 emit parentSelected();
792 break;
793 } else if (!menu)
794 break;
795 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
796 if (ptype == P_MENU && rootEntry != menu &&
797 mode != fullMode && mode != menuMode)
798 emit menuSelected(menu);
799 else
800 changeValue(item);
801 }
802 }
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700803 break;
804 case noColIdx:
805 setValue(item, no);
806 break;
807 case modColIdx:
808 setValue(item, mod);
809 break;
810 case yesColIdx:
811 setValue(item, yes);
812 break;
813 case dataColIdx:
814 changeValue(item);
815 break;
816 }
817
818skip:
819 //printf("contentsMouseReleaseEvent: %d,%d\n", p.x(), p.y());
820 Parent::mouseReleaseEvent(e);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700821}
822
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700823void ConfigList::mouseMoveEvent(QMouseEvent* e)
Boris Barbulovski59e56442015-09-22 11:36:18 -0700824{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700825 //QPoint p(contentsToViewport(e->pos()));
826 //printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
827 Parent::mouseMoveEvent(e);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700828}
829
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700830void ConfigList::mouseDoubleClickEvent(QMouseEvent* e)
Boris Barbulovski59e56442015-09-22 11:36:18 -0700831{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700832 QPoint p = e->pos(); // TODO: Check if this works(was contentsToViewport).
833 ConfigItem* item = (ConfigItem*)itemAt(p);
834 struct menu *menu;
835 enum prop_type ptype;
836
837 if (!item)
838 goto skip;
839 if (item->goParent) {
840 emit parentSelected();
841 goto skip;
842 }
843 menu = item->menu;
844 if (!menu)
845 goto skip;
846 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
847 if (ptype == P_MENU && (mode == singleMode || mode == symbolMode))
848 emit menuSelected(menu);
849 else if (menu->sym)
850 changeValue(item);
851
852skip:
853 //printf("contentsMouseDoubleClickEvent: %d,%d\n", p.x(), p.y());
854 Parent::mouseDoubleClickEvent(e);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700855}
856
857void ConfigList::focusInEvent(QFocusEvent *e)
858{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700859 struct menu *menu = NULL;
860
861 Parent::focusInEvent(e);
862
863 ConfigItem* item = (ConfigItem *)currentItem();
864 if (item) {
865 item->setSelected(true);
866 menu = item->menu;
867 }
868 emit gotFocus(menu);
Boris Barbulovski59e56442015-09-22 11:36:18 -0700869}
870
871void ConfigList::contextMenuEvent(QContextMenuEvent *e)
872{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700873 if (e->y() <= header()->geometry().bottom()) {
874 if (!headerPopup) {
875 QAction *action;
876
877 headerPopup = new QMenu(this);
878 action = new QAction(_("Show Name"), this);
879 action->setCheckable(true);
880 connect(action, SIGNAL(toggled(bool)),
881 parent(), SLOT(setShowName(bool)));
882 connect(parent(), SIGNAL(showNameChanged(bool)),
883 action, SLOT(setOn(bool)));
884 action->setChecked(showName);
885 headerPopup->addAction(action);
886 action = new QAction(_("Show Range"), this);
887 action->setCheckable(true);
888 connect(action, SIGNAL(toggled(bool)),
889 parent(), SLOT(setShowRange(bool)));
890 connect(parent(), SIGNAL(showRangeChanged(bool)),
891 action, SLOT(setOn(bool)));
892 action->setChecked(showRange);
893 headerPopup->addAction(action);
894 action = new QAction(_("Show Data"), this);
895 action->setCheckable(true);
896 connect(action, SIGNAL(toggled(bool)),
897 parent(), SLOT(setShowData(bool)));
898 connect(parent(), SIGNAL(showDataChanged(bool)),
899 action, SLOT(setOn(bool)));
900 action->setChecked(showData);
901 headerPopup->addAction(action);
902 }
903 headerPopup->exec(e->globalPos());
904 e->accept();
905 } else
906 e->ignore();
Boris Barbulovski59e56442015-09-22 11:36:18 -0700907}
908
Li Zefan39a48972010-05-10 16:33:41 +0800909ConfigView*ConfigView::viewList;
910QAction *ConfigView::showNormalAction;
911QAction *ConfigView::showAllAction;
912QAction *ConfigView::showPromptAction;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Roman Zippel7fc925f2006-06-08 22:12:46 -0700914ConfigView::ConfigView(QWidget* parent, const char *name)
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -0700915 : Parent(parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
Boris Barbulovski9bd36ed2015-09-22 11:36:22 -0700917 setObjectName(name);
Boris Barbulovski29a70162015-09-22 11:36:10 -0700918 QVBoxLayout *verticalLayout = new QVBoxLayout(this);
Boris Barbulovski92298b42015-09-22 11:36:11 -0700919 verticalLayout->setContentsMargins(0, 0, 0, 0);
Boris Barbulovski29a70162015-09-22 11:36:10 -0700920
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700921 list = new ConfigList(this);
Boris Barbulovski29a70162015-09-22 11:36:10 -0700922 verticalLayout->addWidget(list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 lineEdit = new ConfigLineEdit(this);
924 lineEdit->hide();
Boris Barbulovski29a70162015-09-22 11:36:10 -0700925 verticalLayout->addWidget(lineEdit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
927 this->nextView = viewList;
928 viewList = this;
929}
930
931ConfigView::~ConfigView(void)
932{
933 ConfigView** vp;
934
935 for (vp = &viewList; *vp; vp = &(*vp)->nextView) {
936 if (*vp == this) {
937 *vp = nextView;
938 break;
939 }
940 }
941}
942
Li Zefan39a48972010-05-10 16:33:41 +0800943void ConfigView::setOptionMode(QAction *act)
Roman Zippel7fc925f2006-06-08 22:12:46 -0700944{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700945 if (act == showNormalAction)
946 list->optMode = normalOpt;
947 else if (act == showAllAction)
948 list->optMode = allOpt;
949 else
950 list->optMode = promptOpt;
951
952 list->updateListAll();
Roman Zippel7fc925f2006-06-08 22:12:46 -0700953}
954
955void ConfigView::setShowName(bool b)
956{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700957 if (list->showName != b) {
958 list->showName = b;
959 list->reinit();
960 emit showNameChanged(b);
961 }
Roman Zippel7fc925f2006-06-08 22:12:46 -0700962}
963
964void ConfigView::setShowRange(bool b)
965{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700966 if (list->showRange != b) {
967 list->showRange = b;
968 list->reinit();
969 emit showRangeChanged(b);
970 }
Roman Zippel7fc925f2006-06-08 22:12:46 -0700971}
972
973void ConfigView::setShowData(bool b)
974{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700975 if (list->showData != b) {
976 list->showData = b;
977 list->reinit();
978 emit showDataChanged(b);
979 }
980}
981
982void ConfigList::setAllOpen(bool open)
983{
984 QTreeWidgetItemIterator it(this);
985
986 while (*it) {
987 (*it)->setExpanded(open);
988
989 ++it;
990 }
Roman Zippel7fc925f2006-06-08 22:12:46 -0700991}
992
Boris Barbulovski1019f1a2015-09-22 11:36:17 -0700993void ConfigView::updateList(ConfigItem* item)
Roman Zippel7fc925f2006-06-08 22:12:46 -0700994{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -0700995 ConfigView* v;
996
997 for (v = viewList; v; v = v->nextView)
998 v->list->updateList(item);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999}
1000
1001void ConfigView::updateListAll(void)
1002{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001003 ConfigView* v;
1004
1005 for (v = viewList; v; v = v->nextView)
1006 v->list->updateListAll();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
1008
Roman Zippel43bf6122006-06-08 22:12:45 -07001009ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001010 : Parent(parent), sym(0), _menu(0)
Roman Zippel43bf6122006-06-08 22:12:45 -07001011{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001012 setObjectName(name);
1013
1014
1015 if (!objectName().isEmpty()) {
1016 configSettings->beginGroup(objectName());
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001017 _showDebug = configSettings->value("/showDebug", false).toBool();
Roman Zippel7fc925f2006-06-08 22:12:46 -07001018 configSettings->endGroup();
1019 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
1020 }
1021}
1022
1023void ConfigInfoView::saveSettings(void)
1024{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001025 if (!objectName().isEmpty()) {
1026 configSettings->beginGroup(objectName());
1027 configSettings->setValue("/showDebug", showDebug());
1028 configSettings->endGroup();
1029 }
Roman Zippel43bf6122006-06-08 22:12:45 -07001030}
1031
1032void ConfigInfoView::setShowDebug(bool b)
1033{
1034 if (_showDebug != b) {
1035 _showDebug = b;
Alexander Stein133c5f72010-08-31 17:34:37 +02001036 if (_menu)
Roman Zippel43bf6122006-06-08 22:12:45 -07001037 menuInfo();
Roman Zippelab45d192006-06-08 22:12:47 -07001038 else if (sym)
1039 symbolInfo();
Roman Zippel43bf6122006-06-08 22:12:45 -07001040 emit showDebugChanged(b);
1041 }
1042}
1043
1044void ConfigInfoView::setInfo(struct menu *m)
1045{
Alexander Stein133c5f72010-08-31 17:34:37 +02001046 if (_menu == m)
Roman Zippelb65a47e2006-06-08 22:12:47 -07001047 return;
Alexander Stein133c5f72010-08-31 17:34:37 +02001048 _menu = m;
Roman Zippel6fa1da82007-01-10 23:15:31 -08001049 sym = NULL;
Alexander Stein133c5f72010-08-31 17:34:37 +02001050 if (!_menu)
Roman Zippel43bf6122006-06-08 22:12:45 -07001051 clear();
Roman Zippel6fa1da82007-01-10 23:15:31 -08001052 else
Roman Zippel43bf6122006-06-08 22:12:45 -07001053 menuInfo();
1054}
1055
Roman Zippelab45d192006-06-08 22:12:47 -07001056void ConfigInfoView::symbolInfo(void)
1057{
1058 QString str;
1059
1060 str += "<big>Symbol: <b>";
1061 str += print_filter(sym->name);
1062 str += "</b></big><br><br>value: ";
1063 str += print_filter(sym_get_string_value(sym));
1064 str += "<br>visibility: ";
1065 str += sym->visible == yes ? "y" : sym->visible == mod ? "m" : "n";
1066 str += "<br>";
1067 str += debug_info(sym);
1068
1069 setText(str);
1070}
1071
Roman Zippel43bf6122006-06-08 22:12:45 -07001072void ConfigInfoView::menuInfo(void)
1073{
1074 struct symbol* sym;
1075 QString head, debug, help;
1076
Alexander Stein133c5f72010-08-31 17:34:37 +02001077 sym = _menu->sym;
Roman Zippel43bf6122006-06-08 22:12:45 -07001078 if (sym) {
Alexander Stein133c5f72010-08-31 17:34:37 +02001079 if (_menu->prompt) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001080 head += "<big><b>";
Alexander Stein133c5f72010-08-31 17:34:37 +02001081 head += print_filter(_(_menu->prompt->text));
Roman Zippel43bf6122006-06-08 22:12:45 -07001082 head += "</b></big>";
1083 if (sym->name) {
1084 head += " (";
Roman Zippelab45d192006-06-08 22:12:47 -07001085 if (showDebug())
1086 head += QString().sprintf("<a href=\"s%p\">", sym);
Roman Zippel43bf6122006-06-08 22:12:45 -07001087 head += print_filter(sym->name);
Roman Zippelab45d192006-06-08 22:12:47 -07001088 if (showDebug())
1089 head += "</a>";
Roman Zippel43bf6122006-06-08 22:12:45 -07001090 head += ")";
1091 }
1092 } else if (sym->name) {
1093 head += "<big><b>";
Roman Zippelab45d192006-06-08 22:12:47 -07001094 if (showDebug())
1095 head += QString().sprintf("<a href=\"s%p\">", sym);
Roman Zippel43bf6122006-06-08 22:12:45 -07001096 head += print_filter(sym->name);
Roman Zippelab45d192006-06-08 22:12:47 -07001097 if (showDebug())
1098 head += "</a>";
Roman Zippel43bf6122006-06-08 22:12:45 -07001099 head += "</b></big>";
1100 }
1101 head += "<br><br>";
1102
1103 if (showDebug())
1104 debug = debug_info(sym);
1105
Cheng Renquand74c15f2009-07-12 16:11:47 +08001106 struct gstr help_gstr = str_new();
Alexander Stein133c5f72010-08-31 17:34:37 +02001107 menu_get_ext_help(_menu, &help_gstr);
Cheng Renquand74c15f2009-07-12 16:11:47 +08001108 help = print_filter(str_get(&help_gstr));
1109 str_free(&help_gstr);
Alexander Stein133c5f72010-08-31 17:34:37 +02001110 } else if (_menu->prompt) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001111 head += "<big><b>";
Alexander Stein133c5f72010-08-31 17:34:37 +02001112 head += print_filter(_(_menu->prompt->text));
Roman Zippel43bf6122006-06-08 22:12:45 -07001113 head += "</b></big><br><br>";
1114 if (showDebug()) {
Alexander Stein133c5f72010-08-31 17:34:37 +02001115 if (_menu->prompt->visible.expr) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001116 debug += "&nbsp;&nbsp;dep: ";
Alexander Stein133c5f72010-08-31 17:34:37 +02001117 expr_print(_menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
Roman Zippel43bf6122006-06-08 22:12:45 -07001118 debug += "<br><br>";
1119 }
1120 }
1121 }
1122 if (showDebug())
Alexander Stein133c5f72010-08-31 17:34:37 +02001123 debug += QString().sprintf("defined at %s:%d<br><br>", _menu->file->name, _menu->lineno);
Roman Zippel43bf6122006-06-08 22:12:45 -07001124
1125 setText(head + debug + help);
1126}
1127
1128QString ConfigInfoView::debug_info(struct symbol *sym)
1129{
1130 QString debug;
1131
1132 debug += "type: ";
1133 debug += print_filter(sym_type_name(sym->type));
1134 if (sym_is_choice(sym))
1135 debug += " (choice)";
1136 debug += "<br>";
1137 if (sym->rev_dep.expr) {
1138 debug += "reverse dep: ";
1139 expr_print(sym->rev_dep.expr, expr_print_help, &debug, E_NONE);
1140 debug += "<br>";
1141 }
1142 for (struct property *prop = sym->prop; prop; prop = prop->next) {
1143 switch (prop->type) {
1144 case P_PROMPT:
1145 case P_MENU:
Roman Zippelab45d192006-06-08 22:12:47 -07001146 debug += QString().sprintf("prompt: <a href=\"m%p\">", prop->menu);
Roman Zippel43bf6122006-06-08 22:12:45 -07001147 debug += print_filter(_(prop->text));
Roman Zippelab45d192006-06-08 22:12:47 -07001148 debug += "</a><br>";
Roman Zippel43bf6122006-06-08 22:12:45 -07001149 break;
1150 case P_DEFAULT:
Roman Zippel93449082008-01-14 04:50:54 +01001151 case P_SELECT:
1152 case P_RANGE:
1153 case P_ENV:
1154 debug += prop_get_type_name(prop->type);
1155 debug += ": ";
Roman Zippel43bf6122006-06-08 22:12:45 -07001156 expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1157 debug += "<br>";
1158 break;
1159 case P_CHOICE:
1160 if (sym_is_choice(sym)) {
1161 debug += "choice: ";
1162 expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1163 debug += "<br>";
1164 }
1165 break;
Roman Zippel43bf6122006-06-08 22:12:45 -07001166 default:
1167 debug += "unknown property: ";
1168 debug += prop_get_type_name(prop->type);
1169 debug += "<br>";
1170 }
1171 if (prop->visible.expr) {
1172 debug += "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
1173 expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
1174 debug += "<br>";
1175 }
1176 }
1177 debug += "<br>";
1178
1179 return debug;
1180}
1181
1182QString ConfigInfoView::print_filter(const QString &str)
1183{
1184 QRegExp re("[<>&\"\\n]");
1185 QString res = str;
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001186 for (int i = 0; (i = res.indexOf(re, i)) >= 0;) {
1187 switch (res[i].toLatin1()) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001188 case '<':
1189 res.replace(i, 1, "&lt;");
1190 i += 4;
1191 break;
1192 case '>':
1193 res.replace(i, 1, "&gt;");
1194 i += 4;
1195 break;
1196 case '&':
1197 res.replace(i, 1, "&amp;");
1198 i += 5;
1199 break;
1200 case '"':
1201 res.replace(i, 1, "&quot;");
1202 i += 6;
1203 break;
1204 case '\n':
1205 res.replace(i, 1, "<br>");
1206 i += 4;
1207 break;
1208 }
1209 }
1210 return res;
1211}
1212
Roman Zippelab45d192006-06-08 22:12:47 -07001213void ConfigInfoView::expr_print_help(void *data, struct symbol *sym, const char *str)
Roman Zippel43bf6122006-06-08 22:12:45 -07001214{
Roman Zippelab45d192006-06-08 22:12:47 -07001215 QString* text = reinterpret_cast<QString*>(data);
1216 QString str2 = print_filter(str);
1217
1218 if (sym && sym->name && !(sym->flags & SYMBOL_CONST)) {
1219 *text += QString().sprintf("<a href=\"s%p\">", sym);
1220 *text += str2;
1221 *text += "</a>";
1222 } else
1223 *text += str2;
Roman Zippel43bf6122006-06-08 22:12:45 -07001224}
1225
Boris Barbulovski924bbb52015-09-22 11:36:06 -07001226QMenu* ConfigInfoView::createStandardContextMenu(const QPoint & pos)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001227{
Boris Barbulovski924bbb52015-09-22 11:36:06 -07001228 QMenu* popup = Parent::createStandardContextMenu(pos);
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001229 QAction* action = new QAction(_("Show Debug Info"), popup);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001230 action->setCheckable(true);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001231 connect(action, SIGNAL(toggled(bool)), SLOT(setShowDebug(bool)));
1232 connect(this, SIGNAL(showDebugChanged(bool)), action, SLOT(setOn(bool)));
Boris Barbulovski9c862352015-09-22 11:36:12 -07001233 action->setChecked(showDebug());
Boris Barbulovski924bbb52015-09-22 11:36:06 -07001234 popup->addSeparator();
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001235 popup->addAction(action);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001236 return popup;
1237}
1238
Boris Barbulovski924bbb52015-09-22 11:36:06 -07001239void ConfigInfoView::contextMenuEvent(QContextMenuEvent *e)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001240{
Boris Barbulovski924bbb52015-09-22 11:36:06 -07001241 Parent::contextMenuEvent(e);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001242}
1243
Marco Costalba63431e72006-10-05 19:12:59 +02001244ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *name)
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001245 : Parent(parent), result(NULL)
Roman Zippel43bf6122006-06-08 22:12:45 -07001246{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001247 setObjectName(name);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001248 setWindowTitle("Search Config");
Roman Zippel43bf6122006-06-08 22:12:45 -07001249
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001250 QVBoxLayout* layout1 = new QVBoxLayout(this);
1251 layout1->setContentsMargins(11, 11, 11, 11);
1252 layout1->setSpacing(6);
1253 QHBoxLayout* layout2 = new QHBoxLayout(0);
1254 layout2->setContentsMargins(0, 0, 0, 0);
1255 layout2->setSpacing(6);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001256 layout2->addWidget(new QLabel(_("Find:"), this));
Roman Zippel43bf6122006-06-08 22:12:45 -07001257 editField = new QLineEdit(this);
1258 connect(editField, SIGNAL(returnPressed()), SLOT(search()));
1259 layout2->addWidget(editField);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001260 searchButton = new QPushButton(_("Search"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001261 searchButton->setAutoDefault(false);
Roman Zippel43bf6122006-06-08 22:12:45 -07001262 connect(searchButton, SIGNAL(clicked()), SLOT(search()));
1263 layout2->addWidget(searchButton);
1264 layout1->addLayout(layout2);
1265
Roman Zippel7fc925f2006-06-08 22:12:46 -07001266 split = new QSplitter(this);
Markus Heidelberg7298b932009-05-18 01:36:50 +02001267 split->setOrientation(Qt::Vertical);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001268 list = new ConfigView(split, name);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001269 list->list->mode = listMode;
Roman Zippel7fc925f2006-06-08 22:12:46 -07001270 info = new ConfigInfoView(split, name);
Roman Zippel43bf6122006-06-08 22:12:45 -07001271 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1272 info, SLOT(setInfo(struct menu *)));
Marco Costalba63431e72006-10-05 19:12:59 +02001273 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1274 parent, SLOT(setMenuLink(struct menu *)));
1275
Roman Zippel43bf6122006-06-08 22:12:45 -07001276 layout1->addWidget(split);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001277
1278 if (name) {
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001279 QVariant x, y;
1280 int width, height;
Roman Zippel7fc925f2006-06-08 22:12:46 -07001281 bool ok;
1282
1283 configSettings->beginGroup(name);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001284 width = configSettings->value("/window width", parent->width() / 2).toInt();
1285 height = configSettings->value("/window height", parent->height() / 2).toInt();
Roman Zippel7fc925f2006-06-08 22:12:46 -07001286 resize(width, height);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001287 x = configSettings->value("/window x");
1288 y = configSettings->value("/window y");
1289 if ((x.isValid())&&(y.isValid()))
1290 move(x.toInt(), y.toInt());
Boris Barbulovski041fbdc2015-09-22 11:36:05 -07001291 QList<int> sizes = configSettings->readSizes("/split", &ok);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001292 if (ok)
1293 split->setSizes(sizes);
1294 configSettings->endGroup();
1295 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
1296 }
1297}
1298
1299void ConfigSearchWindow::saveSettings(void)
1300{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001301 if (!objectName().isEmpty()) {
1302 configSettings->beginGroup(objectName());
1303 configSettings->setValue("/window x", pos().x());
1304 configSettings->setValue("/window y", pos().y());
1305 configSettings->setValue("/window width", size().width());
1306 configSettings->setValue("/window height", size().height());
1307 configSettings->writeSizes("/split", split->sizes());
1308 configSettings->endGroup();
1309 }
Roman Zippel43bf6122006-06-08 22:12:45 -07001310}
1311
1312void ConfigSearchWindow::search(void)
1313{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001314 struct symbol **p;
1315 struct property *prop;
1316 ConfigItem *lastItem = NULL;
1317
1318 free(result);
1319 list->list->clear();
1320 info->clear();
1321
1322 result = sym_re_search(editField->text().toLatin1());
1323 if (!result)
1324 return;
1325 for (p = result; *p; p++) {
1326 for_all_prompts((*p), prop)
1327 lastItem = new ConfigItem(list->list, lastItem, prop->menu,
1328 menu_is_visible(prop->menu));
1329 }
Roman Zippel43bf6122006-06-08 22:12:45 -07001330}
1331
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332/*
1333 * Construct the complete config widget
1334 */
1335ConfigMainWindow::ConfigMainWindow(void)
Roman Zippelf12aa702006-11-25 11:09:31 -08001336 : searchWindow(0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337{
1338 QMenuBar* menu;
Boris Barbulovski92119932015-09-22 11:36:16 -07001339 bool ok = true;
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001340 QVariant x, y;
1341 int width, height;
Randy Dunlapa54bb702007-10-20 11:18:47 -07001342 char title[256];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Markus Heidelberg8d90c972009-05-18 01:36:52 +02001344 QDesktopWidget *d = configApp->desktop();
Arnaud Lacombe09548282010-08-18 01:57:13 -04001345 snprintf(title, sizeof(title), "%s%s",
1346 rootmenu.prompt->text,
Michal Marek76a136c2010-09-01 17:39:27 +02001347 ""
Michal Marek76a136c2010-09-01 17:39:27 +02001348 );
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001349 setWindowTitle(title);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001351 width = configSettings->value("/window width", d->width() - 64).toInt();
1352 height = configSettings->value("/window height", d->height() - 64).toInt();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 resize(width, height);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001354 x = configSettings->value("/window x");
1355 y = configSettings->value("/window y");
1356 if ((x.isValid())&&(y.isValid()))
1357 move(x.toInt(), y.toInt());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 split1 = new QSplitter(this);
Markus Heidelberg7298b932009-05-18 01:36:50 +02001360 split1->setOrientation(Qt::Horizontal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 setCentralWidget(split1);
1362
Roman Zippel7fc925f2006-06-08 22:12:46 -07001363 menuView = new ConfigView(split1, "menu");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 menuList = menuView->list;
1365
1366 split2 = new QSplitter(split1);
Markus Heidelberg7298b932009-05-18 01:36:50 +02001367 split2->setOrientation(Qt::Vertical);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
1369 // create config tree
Roman Zippel7fc925f2006-06-08 22:12:46 -07001370 configView = new ConfigView(split2, "config");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 configList = configView->list;
1372
Roman Zippel7fc925f2006-06-08 22:12:46 -07001373 helpText = new ConfigInfoView(split2, "help");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
1375 setTabOrder(configList, helpText);
1376 configList->setFocus();
1377
1378 menu = menuBar();
Boris Barbulovskib1f8a452015-09-22 11:36:02 -07001379 toolBar = new QToolBar("Tools", this);
Boris Barbulovski29a70162015-09-22 11:36:10 -07001380 addToolBar(toolBar);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001382 backAction = new QAction(QPixmap(xpm_back), _("Back"), this);
Boris Barbulovski92119932015-09-22 11:36:16 -07001383 connect(backAction, SIGNAL(triggered(bool)), SLOT(goBack()));
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001384 backAction->setEnabled(false);
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001385 QAction *quitAction = new QAction(_("&Quit"), this);
1386 quitAction->setShortcut(Qt::CTRL + Qt::Key_Q);
Boris Barbulovski92119932015-09-22 11:36:16 -07001387 connect(quitAction, SIGNAL(triggered(bool)), SLOT(close()));
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001388 QAction *loadAction = new QAction(QPixmap(xpm_load), _("&Load"), this);
1389 loadAction->setShortcut(Qt::CTRL + Qt::Key_L);
Boris Barbulovski92119932015-09-22 11:36:16 -07001390 connect(loadAction, SIGNAL(triggered(bool)), SLOT(loadConfig()));
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001391 saveAction = new QAction(QPixmap(xpm_save), _("&Save"), this);
1392 saveAction->setShortcut(Qt::CTRL + Qt::Key_S);
Boris Barbulovski92119932015-09-22 11:36:16 -07001393 connect(saveAction, SIGNAL(triggered(bool)), SLOT(saveConfig()));
Karsten Wiese3b354c52006-12-13 00:34:08 -08001394 conf_set_changed_callback(conf_changed);
1395 // Set saveAction's initial state
1396 conf_changed();
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001397 QAction *saveAsAction = new QAction(_("Save &As..."), this);
Boris Barbulovski92119932015-09-22 11:36:16 -07001398 connect(saveAsAction, SIGNAL(triggered(bool)), SLOT(saveConfigAs()));
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001399 QAction *searchAction = new QAction(_("&Find"), this);
1400 searchAction->setShortcut(Qt::CTRL + Qt::Key_F);
Boris Barbulovski92119932015-09-22 11:36:16 -07001401 connect(searchAction, SIGNAL(triggered(bool)), SLOT(searchConfig()));
Boris Barbulovski780505e2015-09-22 11:36:13 -07001402 singleViewAction = new QAction(QPixmap(xpm_single_view), _("Single View"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001403 singleViewAction->setCheckable(true);
Boris Barbulovski92119932015-09-22 11:36:16 -07001404 connect(singleViewAction, SIGNAL(triggered(bool)), SLOT(showSingleView()));
Boris Barbulovski780505e2015-09-22 11:36:13 -07001405 splitViewAction = new QAction(QPixmap(xpm_split_view), _("Split View"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001406 splitViewAction->setCheckable(true);
Boris Barbulovski92119932015-09-22 11:36:16 -07001407 connect(splitViewAction, SIGNAL(triggered(bool)), SLOT(showSplitView()));
Boris Barbulovski780505e2015-09-22 11:36:13 -07001408 fullViewAction = new QAction(QPixmap(xpm_tree_view), _("Full View"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001409 fullViewAction->setCheckable(true);
Boris Barbulovski92119932015-09-22 11:36:16 -07001410 connect(fullViewAction, SIGNAL(triggered(bool)), SLOT(showFullView()));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001412 QAction *showNameAction = new QAction(_("Show Name"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001413 showNameAction->setCheckable(true);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001414 connect(showNameAction, SIGNAL(toggled(bool)), configView, SLOT(setShowName(bool)));
Boris Barbulovski9c862352015-09-22 11:36:12 -07001415 showNameAction->setChecked(configView->showName());
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001416 QAction *showRangeAction = new QAction(_("Show Range"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001417 showRangeAction->setCheckable(true);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001418 connect(showRangeAction, SIGNAL(toggled(bool)), configView, SLOT(setShowRange(bool)));
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001419 QAction *showDataAction = new QAction(_("Show Data"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001420 showDataAction->setCheckable(true);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001421 connect(showDataAction, SIGNAL(toggled(bool)), configView, SLOT(setShowData(bool)));
Li Zefan39a48972010-05-10 16:33:41 +08001422
1423 QActionGroup *optGroup = new QActionGroup(this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001424 optGroup->setExclusive(true);
Boris Barbulovski92119932015-09-22 11:36:16 -07001425 connect(optGroup, SIGNAL(triggered(QAction*)), configView,
Li Zefan39a48972010-05-10 16:33:41 +08001426 SLOT(setOptionMode(QAction *)));
Boris Barbulovski92119932015-09-22 11:36:16 -07001427 connect(optGroup, SIGNAL(triggered(QAction *)), menuView,
Li Zefan39a48972010-05-10 16:33:41 +08001428 SLOT(setOptionMode(QAction *)));
1429
Alexander Stein133c5f72010-08-31 17:34:37 +02001430 configView->showNormalAction = new QAction(_("Show Normal Options"), optGroup);
1431 configView->showAllAction = new QAction(_("Show All Options"), optGroup);
1432 configView->showPromptAction = new QAction(_("Show Prompt Options"), optGroup);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001433 configView->showNormalAction->setCheckable(true);
1434 configView->showAllAction->setCheckable(true);
1435 configView->showPromptAction->setCheckable(true);
Li Zefan39a48972010-05-10 16:33:41 +08001436
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001437 QAction *showDebugAction = new QAction( _("Show Debug Info"), this);
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001438 showDebugAction->setCheckable(true);
Roman Zippel43bf6122006-06-08 22:12:45 -07001439 connect(showDebugAction, SIGNAL(toggled(bool)), helpText, SLOT(setShowDebug(bool)));
Boris Barbulovski9c862352015-09-22 11:36:12 -07001440 showDebugAction->setChecked(helpText->showDebug());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001442 QAction *showIntroAction = new QAction( _("Introduction"), this);
Boris Barbulovski92119932015-09-22 11:36:16 -07001443 connect(showIntroAction, SIGNAL(triggered(bool)), SLOT(showIntro()));
Boris Barbulovski85eaf282015-09-22 11:36:03 -07001444 QAction *showAboutAction = new QAction( _("About"), this);
Boris Barbulovski92119932015-09-22 11:36:16 -07001445 connect(showAboutAction, SIGNAL(triggered(bool)), SLOT(showAbout()));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
1447 // init tool bar
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001448 toolBar->addAction(backAction);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 toolBar->addSeparator();
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001450 toolBar->addAction(loadAction);
1451 toolBar->addAction(saveAction);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 toolBar->addSeparator();
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001453 toolBar->addAction(singleViewAction);
1454 toolBar->addAction(splitViewAction);
1455 toolBar->addAction(fullViewAction);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
1457 // create config menu
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001458 QMenu* config = menu->addMenu(_("&File"));
1459 config->addAction(loadAction);
1460 config->addAction(saveAction);
1461 config->addAction(saveAsAction);
Boris Barbulovski76bede82015-09-22 11:36:07 -07001462 config->addSeparator();
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001463 config->addAction(quitAction);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
Shlomi Fish66e7c722007-02-14 00:32:58 -08001465 // create edit menu
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001466 QMenu* editMenu = menu->addMenu(_("&Edit"));
1467 editMenu->addAction(searchAction);
Shlomi Fish66e7c722007-02-14 00:32:58 -08001468
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 // create options menu
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001470 QMenu* optionMenu = menu->addMenu(_("&Option"));
1471 optionMenu->addAction(showNameAction);
1472 optionMenu->addAction(showRangeAction);
1473 optionMenu->addAction(showDataAction);
Boris Barbulovski76bede82015-09-22 11:36:07 -07001474 optionMenu->addSeparator();
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001475 optionMenu->addActions(optGroup->actions());
Boris Barbulovski76bede82015-09-22 11:36:07 -07001476 optionMenu->addSeparator();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
1478 // create help menu
Boris Barbulovski76bede82015-09-22 11:36:07 -07001479 menu->addSeparator();
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001480 QMenu* helpMenu = menu->addMenu(_("&Help"));
1481 helpMenu->addAction(showIntroAction);
1482 helpMenu->addAction(showAboutAction);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001484 connect(configList, SIGNAL(menuChanged(struct menu *)),
1485 helpText, SLOT(setInfo(struct menu *)));
1486 connect(configList, SIGNAL(menuSelected(struct menu *)),
1487 SLOT(changeMenu(struct menu *)));
1488 connect(configList, SIGNAL(parentSelected()),
1489 SLOT(goBack()));
1490 connect(menuList, SIGNAL(menuChanged(struct menu *)),
1491 helpText, SLOT(setInfo(struct menu *)));
1492 connect(menuList, SIGNAL(menuSelected(struct menu *)),
1493 SLOT(changeMenu(struct menu *)));
1494
1495 connect(configList, SIGNAL(gotFocus(struct menu *)),
1496 helpText, SLOT(setInfo(struct menu *)));
1497 connect(menuList, SIGNAL(gotFocus(struct menu *)),
1498 helpText, SLOT(setInfo(struct menu *)));
1499 connect(menuList, SIGNAL(gotFocus(struct menu *)),
1500 SLOT(listFocusChanged(void)));
Roman Zippelb65a47e2006-06-08 22:12:47 -07001501 connect(helpText, SIGNAL(menuSelected(struct menu *)),
1502 SLOT(setMenuLink(struct menu *)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001504 QString listMode = configSettings->value("/listMode", "symbol").toString();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 if (listMode == "single")
1506 showSingleView();
1507 else if (listMode == "full")
1508 showFullView();
1509 else /*if (listMode == "split")*/
1510 showSplitView();
1511
1512 // UI setup done, restore splitter positions
Boris Barbulovski041fbdc2015-09-22 11:36:05 -07001513 QList<int> sizes = configSettings->readSizes("/split1", &ok);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 if (ok)
1515 split1->setSizes(sizes);
1516
Roman Zippel7fc925f2006-06-08 22:12:46 -07001517 sizes = configSettings->readSizes("/split2", &ok);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 if (ok)
1519 split2->setSizes(sizes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520}
1521
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522void ConfigMainWindow::loadConfig(void)
1523{
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001524 QString s = QFileDialog::getOpenFileName(this, "", conf_get_configname());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 if (s.isNull())
1526 return;
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -07001527 if (conf_read(QFile::encodeName(s)))
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001528 QMessageBox::information(this, "qconf", _("Unable to load configuration!"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 ConfigView::updateListAll();
1530}
1531
Michal Marekbac6aa82011-05-25 15:10:25 +02001532bool ConfigMainWindow::saveConfig(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533{
Michal Marekbac6aa82011-05-25 15:10:25 +02001534 if (conf_write(NULL)) {
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001535 QMessageBox::information(this, "qconf", _("Unable to save configuration!"));
Michal Marekbac6aa82011-05-25 15:10:25 +02001536 return false;
1537 }
1538 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539}
1540
1541void ConfigMainWindow::saveConfigAs(void)
1542{
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001543 QString s = QFileDialog::getSaveFileName(this, "", conf_get_configname());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 if (s.isNull())
1545 return;
Arnaud Lacombed49e4682011-05-24 14:16:18 -04001546 saveConfig();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547}
1548
Roman Zippel43bf6122006-06-08 22:12:45 -07001549void ConfigMainWindow::searchConfig(void)
1550{
1551 if (!searchWindow)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001552 searchWindow = new ConfigSearchWindow(this, "search");
Roman Zippel43bf6122006-06-08 22:12:45 -07001553 searchWindow->show();
1554}
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556void ConfigMainWindow::changeMenu(struct menu *menu)
1557{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001558 configList->setRootMenu(menu);
1559 if (configList->rootEntry->parent == &rootmenu)
1560 backAction->setEnabled(false);
1561 else
1562 backAction->setEnabled(true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563}
1564
Roman Zippelb65a47e2006-06-08 22:12:47 -07001565void ConfigMainWindow::setMenuLink(struct menu *menu)
1566{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001567 struct menu *parent;
1568 ConfigList* list = NULL;
1569 ConfigItem* item;
1570
1571 if (configList->menuSkip(menu))
1572 return;
1573
1574 switch (configList->mode) {
1575 case singleMode:
1576 list = configList;
1577 parent = menu_get_parent_menu(menu);
1578 if (!parent)
1579 return;
1580 list->setRootMenu(parent);
1581 break;
1582 case symbolMode:
1583 if (menu->flags & MENU_ROOT) {
1584 configList->setRootMenu(menu);
1585 configList->clearSelection();
1586 list = menuList;
1587 } else {
1588 list = configList;
1589 parent = menu_get_parent_menu(menu->parent);
1590 if (!parent)
1591 return;
1592 item = menuList->findConfigItem(parent);
1593 if (item) {
1594 item->setSelected(true);
1595 menuList->scrollToItem(item);
1596 }
1597 list->setRootMenu(parent);
1598 }
1599 break;
1600 case fullMode:
1601 list = configList;
1602 break;
1603 default:
1604 break;
1605 }
1606
1607 if (list) {
1608 item = list->findConfigItem(menu);
1609 if (item) {
1610 item->setSelected(true);
1611 list->scrollToItem(item);
1612 list->setFocus();
1613 }
1614 }
Roman Zippelb65a47e2006-06-08 22:12:47 -07001615}
1616
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617void ConfigMainWindow::listFocusChanged(void)
1618{
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001619 if (menuList->mode == menuMode)
1620 configList->clearSelection();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621}
1622
1623void ConfigMainWindow::goBack(void)
1624{
Boris Barbulovski5df9da92015-09-22 11:36:36 -07001625 ConfigItem* item, *oldSelection;
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001626
1627 configList->setParentMenu();
1628 if (configList->rootEntry == &rootmenu)
1629 backAction->setEnabled(false);
Boris Barbulovskibe596aa2015-09-22 11:36:28 -07001630
1631 if (menuList->selectedItems().count() == 0)
1632 return;
1633
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001634 item = (ConfigItem*)menuList->selectedItems().first();
Boris Barbulovski5df9da92015-09-22 11:36:36 -07001635 oldSelection = item;
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001636 while (item) {
1637 if (item->menu == configList->rootEntry) {
Boris Barbulovski5df9da92015-09-22 11:36:36 -07001638 oldSelection->setSelected(false);
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001639 item->setSelected(true);
1640 break;
1641 }
1642 item = (ConfigItem*)item->parent();
1643 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644}
1645
1646void ConfigMainWindow::showSingleView(void)
1647{
Boris Barbulovski780505e2015-09-22 11:36:13 -07001648 singleViewAction->setEnabled(false);
1649 singleViewAction->setChecked(true);
1650 splitViewAction->setEnabled(true);
1651 splitViewAction->setChecked(false);
1652 fullViewAction->setEnabled(true);
1653 fullViewAction->setChecked(false);
1654
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 menuView->hide();
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001656 menuList->setRootMenu(0);
1657 configList->mode = singleMode;
1658 if (configList->rootEntry == &rootmenu)
1659 configList->updateListAll();
1660 else
1661 configList->setRootMenu(&rootmenu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 configList->setFocus();
1663}
1664
1665void ConfigMainWindow::showSplitView(void)
1666{
Boris Barbulovski780505e2015-09-22 11:36:13 -07001667 singleViewAction->setEnabled(true);
1668 singleViewAction->setChecked(false);
1669 splitViewAction->setEnabled(false);
1670 splitViewAction->setChecked(true);
1671 fullViewAction->setEnabled(true);
1672 fullViewAction->setChecked(false);
1673
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001674 configList->mode = symbolMode;
1675 if (configList->rootEntry == &rootmenu)
1676 configList->updateListAll();
1677 else
1678 configList->setRootMenu(&rootmenu);
1679 configList->setAllOpen(true);
1680 configApp->processEvents();
1681 menuList->mode = menuMode;
1682 menuList->setRootMenu(&rootmenu);
1683 menuList->setAllOpen(true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 menuView->show();
1685 menuList->setFocus();
1686}
1687
1688void ConfigMainWindow::showFullView(void)
1689{
Boris Barbulovski780505e2015-09-22 11:36:13 -07001690 singleViewAction->setEnabled(true);
1691 singleViewAction->setChecked(false);
1692 splitViewAction->setEnabled(true);
1693 splitViewAction->setChecked(false);
1694 fullViewAction->setEnabled(false);
1695 fullViewAction->setChecked(true);
1696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 menuView->hide();
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001698 menuList->setRootMenu(0);
1699 configList->mode = fullMode;
1700 if (configList->rootEntry == &rootmenu)
1701 configList->updateListAll();
1702 else
1703 configList->setRootMenu(&rootmenu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 configList->setFocus();
1705}
1706
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707/*
1708 * ask for saving configuration before quitting
1709 * TODO ask only when something changed
1710 */
1711void ConfigMainWindow::closeEvent(QCloseEvent* e)
1712{
Karsten Wieseb3214292006-12-13 00:34:06 -08001713 if (!conf_get_changed()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 e->accept();
1715 return;
1716 }
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001717 QMessageBox mb("qconf", _("Save configuration?"), QMessageBox::Warning,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 QMessageBox::Yes | QMessageBox::Default, QMessageBox::No, QMessageBox::Cancel | QMessageBox::Escape);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001719 mb.setButtonText(QMessageBox::Yes, _("&Save Changes"));
1720 mb.setButtonText(QMessageBox::No, _("&Discard Changes"));
1721 mb.setButtonText(QMessageBox::Cancel, _("Cancel Exit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 switch (mb.exec()) {
1723 case QMessageBox::Yes:
Michal Marekbac6aa82011-05-25 15:10:25 +02001724 if (saveConfig())
1725 e->accept();
1726 else
1727 e->ignore();
1728 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 case QMessageBox::No:
1730 e->accept();
1731 break;
1732 case QMessageBox::Cancel:
1733 e->ignore();
1734 break;
1735 }
1736}
1737
1738void ConfigMainWindow::showIntro(void)
1739{
Arnaud Lacombe652cf982010-08-14 23:51:40 -04001740 static const QString str = _("Welcome to the qconf graphical configuration tool.\n\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 "For each option, a blank box indicates the feature is disabled, a check\n"
1742 "indicates it is enabled, and a dot indicates that it is to be compiled\n"
1743 "as a module. Clicking on the box will cycle through the three states.\n\n"
1744 "If you do not see an option (e.g., a device driver) that you believe\n"
1745 "should be present, try turning on Show All Options under the Options menu.\n"
1746 "Although there is no cross reference yet to help you figure out what other\n"
1747 "options must be enabled to support the option you are interested in, you can\n"
1748 "still view the help of a grayed-out option.\n\n"
1749 "Toggling Show Debug Info under the Options menu will show the dependencies,\n"
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001750 "which you can then match by examining other options.\n\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
1752 QMessageBox::information(this, "qconf", str);
1753}
1754
1755void ConfigMainWindow::showAbout(void)
1756{
Boris Barbulovskib4ff1de2015-09-22 11:36:38 -07001757 static const QString str = _("qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n"
1758 "Copyright (C) 2015 Boris Barbulovski <bbarbulovski@gmail.com>.\n\n"
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001759 "Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
1761 QMessageBox::information(this, "qconf", str);
1762}
1763
1764void ConfigMainWindow::saveSettings(void)
1765{
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001766 configSettings->setValue("/window x", pos().x());
1767 configSettings->setValue("/window y", pos().y());
1768 configSettings->setValue("/window width", size().width());
1769 configSettings->setValue("/window height", size().height());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
1771 QString entry;
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001772 switch(configList->mode) {
1773 case singleMode :
1774 entry = "single";
1775 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
Boris Barbulovskid5d973c2015-09-22 11:36:19 -07001777 case symbolMode :
1778 entry = "split";
1779 break;
1780
1781 case fullMode :
1782 entry = "full";
1783 break;
1784
1785 default:
1786 break;
1787 }
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001788 configSettings->setValue("/listMode", entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Roman Zippel7fc925f2006-06-08 22:12:46 -07001790 configSettings->writeSizes("/split1", split1->sizes());
1791 configSettings->writeSizes("/split2", split2->sizes());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792}
1793
Karsten Wiese3b354c52006-12-13 00:34:08 -08001794void ConfigMainWindow::conf_changed(void)
1795{
1796 if (saveAction)
1797 saveAction->setEnabled(conf_get_changed());
1798}
1799
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800void fixup_rootmenu(struct menu *menu)
1801{
1802 struct menu *child;
1803 static int menu_cnt = 0;
1804
1805 menu->flags |= MENU_ROOT;
1806 for (child = menu->list; child; child = child->next) {
1807 if (child->prompt && child->prompt->type == P_MENU) {
1808 menu_cnt++;
1809 fixup_rootmenu(child);
1810 menu_cnt--;
1811 } else if (!menu_cnt)
1812 fixup_rootmenu(child);
1813 }
1814}
1815
1816static const char *progname;
1817
1818static void usage(void)
1819{
Boris Barbulovski68ccb7e2015-09-22 11:36:15 -07001820 printf(_("%s [-s] <config>\n").toLatin1().constData(), progname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 exit(0);
1822}
1823
1824int main(int ac, char** av)
1825{
1826 ConfigMainWindow* v;
1827 const char *name;
1828
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -07001829 bindtextdomain(PACKAGE, LOCALEDIR);
1830 textdomain(PACKAGE);
1831
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 progname = av[0];
1833 configApp = new QApplication(ac, av);
1834 if (ac > 1 && av[1][0] == '-') {
1835 switch (av[1][1]) {
Michal Marek0a1f00a2015-04-08 13:30:42 +02001836 case 's':
1837 conf_set_message_callback(NULL);
1838 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 case 'h':
1840 case '?':
1841 usage();
1842 }
1843 name = av[2];
1844 } else
1845 name = av[1];
1846 if (!name)
1847 usage();
1848
1849 conf_parse(name);
1850 fixup_rootmenu(&rootmenu);
1851 conf_read(NULL);
1852 //zconfdump(stdout);
1853
Roman Zippel7fc925f2006-06-08 22:12:46 -07001854 configSettings = new ConfigSettings();
1855 configSettings->beginGroup("/kconfig/qconf");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 v = new ConfigMainWindow();
1857
1858 //zconfdump(stdout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1860 configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
Roman Zippel43bf6122006-06-08 22:12:45 -07001861 v->show();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 configApp->exec();
1863
Roman Zippel7fc925f2006-06-08 22:12:46 -07001864 configSettings->endGroup();
1865 delete configSettings;
1866
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 return 0;
1868}