blob: 06dd2e33581de5de81863bd1b74b2fb7100af5ed [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
4 */
5
Alexander Stein133c5f72010-08-31 17:34:37 +02006#include <qglobal.h>
7
8#if QT_VERSION < 0x040000
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <qmainwindow.h>
Alexander Stein133c5f72010-08-31 17:34:37 +020010#include <qvbox.h>
11#include <qvaluelist.h>
12#include <qtextbrowser.h>
13#include <qaction.h>
14#include <qheader.h>
15#include <qfiledialog.h>
16#include <qdragobject.h>
17#include <qpopupmenu.h>
18#else
19#include <q3mainwindow.h>
20#include <q3vbox.h>
21#include <q3valuelist.h>
22#include <q3textbrowser.h>
23#include <q3action.h>
24#include <q3header.h>
25#include <q3filedialog.h>
26#include <q3dragobject.h>
27#include <q3popupmenu.h>
28#endif
29
30#include <qapplication.h>
Markus Heidelberg8d90c972009-05-18 01:36:52 +020031#include <qdesktopwidget.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <qtoolbar.h>
Roman Zippel43bf6122006-06-08 22:12:45 -070033#include <qlayout.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <qsplitter.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <qlineedit.h>
Roman Zippel43bf6122006-06-08 22:12:45 -070036#include <qlabel.h>
37#include <qpushbutton.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <qmenubar.h>
39#include <qmessagebox.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <qregexp.h>
Alexander Stein133c5f72010-08-31 17:34:37 +020041#include <qevent.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <stdlib.h>
44
45#include "lkc.h"
46#include "qconf.h"
47
48#include "qconf.moc"
49#include "images.c"
50
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070051#ifdef _
52# undef _
53# define _ qgettext
54#endif
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056static QApplication *configApp;
Roman Zippel7fc925f2006-06-08 22:12:46 -070057static ConfigSettings *configSettings;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Alexander Stein133c5f72010-08-31 17:34:37 +020059Q3Action *ConfigMainWindow::saveAction;
Karsten Wiese3b354c52006-12-13 00:34:08 -080060
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070061static inline QString qgettext(const char* str)
62{
Roman Zippel43bf6122006-06-08 22:12:45 -070063 return QString::fromLocal8Bit(gettext(str));
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070064}
65
66static inline QString qgettext(const QString& str)
67{
Roman Zippel43bf6122006-06-08 22:12:45 -070068 return QString::fromLocal8Bit(gettext(str.latin1()));
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -070069}
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/**
72 * Reads a list of integer values from the application settings.
73 */
Alexander Stein133c5f72010-08-31 17:34:37 +020074Q3ValueList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
Alexander Stein133c5f72010-08-31 17:34:37 +020076 Q3ValueList<int> result;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 QStringList entryList = readListEntry(key, ok);
Li Zefanc1f96f02010-05-07 13:58:04 +080078 QStringList::Iterator it;
79
80 for (it = entryList.begin(); it != entryList.end(); ++it)
81 result.push_back((*it).toInt());
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83 return result;
84}
85
86/**
87 * Writes a list of integer values to the application settings.
88 */
Alexander Stein133c5f72010-08-31 17:34:37 +020089bool ConfigSettings::writeSizes(const QString& key, const Q3ValueList<int>& value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
91 QStringList stringList;
Alexander Stein133c5f72010-08-31 17:34:37 +020092 Q3ValueList<int>::ConstIterator it;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 for (it = value.begin(); it != value.end(); ++it)
95 stringList.push_back(QString::number(*it));
96 return writeEntry(key, stringList);
97}
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100/*
101 * set the new data
102 * TODO check the value
103 */
104void ConfigItem::okRename(int col)
105{
106 Parent::okRename(col);
107 sym_set_string_value(menu->sym, text(dataColIdx).latin1());
Karsten Wiese49e56462007-02-14 00:32:57 -0800108 listView()->updateList(this);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/*
112 * update the displayed of a menu entry
113 */
114void ConfigItem::updateMenu(void)
115{
116 ConfigList* list;
117 struct symbol* sym;
118 struct property *prop;
119 QString prompt;
120 int type;
121 tristate expr;
122
123 list = listView();
124 if (goParent) {
125 setPixmap(promptColIdx, list->menuBackPix);
126 prompt = "..";
127 goto set_prompt;
128 }
129
130 sym = menu->sym;
131 prop = menu->prompt;
EGRY Gaborc21a2d92008-01-11 23:52:07 +0100132 prompt = _(menu_get_prompt(menu));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
134 if (prop) switch (prop->type) {
135 case P_MENU:
136 if (list->mode == singleMode || list->mode == symbolMode) {
137 /* a menuconfig entry is displayed differently
138 * depending whether it's at the view root or a child.
139 */
140 if (sym && list->rootEntry == menu)
141 break;
142 setPixmap(promptColIdx, list->menuPix);
143 } else {
144 if (sym)
145 break;
146 setPixmap(promptColIdx, 0);
147 }
148 goto set_prompt;
149 case P_COMMENT:
150 setPixmap(promptColIdx, 0);
151 goto set_prompt;
152 default:
153 ;
154 }
155 if (!sym)
156 goto set_prompt;
157
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700158 setText(nameColIdx, QString::fromLocal8Bit(sym->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160 type = sym_get_type(sym);
161 switch (type) {
162 case S_BOOLEAN:
163 case S_TRISTATE:
164 char ch;
165
Li Zefan39a48972010-05-10 16:33:41 +0800166 if (!sym_is_changable(sym) && list->optMode == normalOpt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 setPixmap(promptColIdx, 0);
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700168 setText(noColIdx, QString::null);
169 setText(modColIdx, QString::null);
170 setText(yesColIdx, QString::null);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 break;
172 }
173 expr = sym_get_tristate_value(sym);
174 switch (expr) {
175 case yes:
176 if (sym_is_choice_value(sym) && type == S_BOOLEAN)
177 setPixmap(promptColIdx, list->choiceYesPix);
178 else
179 setPixmap(promptColIdx, list->symbolYesPix);
180 setText(yesColIdx, "Y");
181 ch = 'Y';
182 break;
183 case mod:
184 setPixmap(promptColIdx, list->symbolModPix);
185 setText(modColIdx, "M");
186 ch = 'M';
187 break;
188 default:
189 if (sym_is_choice_value(sym) && type == S_BOOLEAN)
190 setPixmap(promptColIdx, list->choiceNoPix);
191 else
192 setPixmap(promptColIdx, list->symbolNoPix);
193 setText(noColIdx, "N");
194 ch = 'N';
195 break;
196 }
197 if (expr != no)
198 setText(noColIdx, sym_tristate_within_range(sym, no) ? "_" : 0);
199 if (expr != mod)
200 setText(modColIdx, sym_tristate_within_range(sym, mod) ? "_" : 0);
201 if (expr != yes)
202 setText(yesColIdx, sym_tristate_within_range(sym, yes) ? "_" : 0);
203
204 setText(dataColIdx, QChar(ch));
205 break;
206 case S_INT:
207 case S_HEX:
208 case S_STRING:
209 const char* data;
210
211 data = sym_get_string_value(sym);
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 int i = list->mapIdx(dataColIdx);
214 if (i >= 0)
215 setRenameEnabled(i, TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 setText(dataColIdx, data);
217 if (type == S_STRING)
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700218 prompt = QString("%1: %2").arg(prompt).arg(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 else
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700220 prompt = QString("(%2) %1").arg(prompt).arg(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 break;
222 }
223 if (!sym_has_value(sym) && visible)
EGRY Gaborc21a2d92008-01-11 23:52:07 +0100224 prompt += _(" (NEW)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225set_prompt:
226 setText(promptColIdx, prompt);
227}
228
229void ConfigItem::testUpdateMenu(bool v)
230{
231 ConfigItem* i;
232
233 visible = v;
234 if (!menu)
235 return;
236
237 sym_calc_value(menu->sym);
238 if (menu->flags & MENU_CHANGED) {
239 /* the menu entry changed, so update all list items */
240 menu->flags &= ~MENU_CHANGED;
241 for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
242 i->updateMenu();
243 } else if (listView()->updateAll)
244 updateMenu();
245}
246
247void ConfigItem::paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align)
248{
249 ConfigList* list = listView();
250
251 if (visible) {
252 if (isSelected() && !list->hasFocus() && list->mode == menuMode)
253 Parent::paintCell(p, list->inactivedColorGroup, column, width, align);
254 else
255 Parent::paintCell(p, cg, column, width, align);
256 } else
257 Parent::paintCell(p, list->disabledColorGroup, column, width, align);
258}
259
260/*
261 * construct a menu entry
262 */
263void ConfigItem::init(void)
264{
265 if (menu) {
266 ConfigList* list = listView();
267 nextItem = (ConfigItem*)menu->data;
268 menu->data = this;
269
270 if (list->mode != fullMode)
271 setOpen(TRUE);
272 sym_calc_value(menu->sym);
273 }
274 updateMenu();
275}
276
277/*
278 * destruct a menu entry
279 */
280ConfigItem::~ConfigItem(void)
281{
282 if (menu) {
283 ConfigItem** ip = (ConfigItem**)&menu->data;
284 for (; *ip; ip = &(*ip)->nextItem) {
285 if (*ip == this) {
286 *ip = nextItem;
287 break;
288 }
289 }
290 }
291}
292
Roman Zippel43bf6122006-06-08 22:12:45 -0700293ConfigLineEdit::ConfigLineEdit(ConfigView* parent)
294 : Parent(parent)
295{
296 connect(this, SIGNAL(lostFocus()), SLOT(hide()));
297}
298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299void ConfigLineEdit::show(ConfigItem* i)
300{
301 item = i;
302 if (sym_get_string_value(item->menu->sym))
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700303 setText(QString::fromLocal8Bit(sym_get_string_value(item->menu->sym)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 else
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -0700305 setText(QString::null);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 Parent::show();
307 setFocus();
308}
309
310void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
311{
312 switch (e->key()) {
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200313 case Qt::Key_Escape:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 break;
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200315 case Qt::Key_Return:
316 case Qt::Key_Enter:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 sym_set_string_value(item->menu->sym, text().latin1());
318 parent()->updateList(item);
319 break;
320 default:
321 Parent::keyPressEvent(e);
322 return;
323 }
324 e->accept();
325 parent()->list->setFocus();
326 hide();
327}
328
Roman Zippel7fc925f2006-06-08 22:12:46 -0700329ConfigList::ConfigList(ConfigView* p, const char *name)
330 : Parent(p, name),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 updateAll(false),
332 symbolYesPix(xpm_symbol_yes), symbolModPix(xpm_symbol_mod), symbolNoPix(xpm_symbol_no),
333 choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no),
334 menuPix(xpm_menu), menuInvPix(xpm_menu_inv), menuBackPix(xpm_menuback), voidPix(xpm_void),
Li Zefan39a48972010-05-10 16:33:41 +0800335 showName(false), showRange(false), showData(false), optMode(normalOpt),
Roman Zippel7fc925f2006-06-08 22:12:46 -0700336 rootEntry(0), headerPopup(0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
338 int i;
339
340 setSorting(-1);
341 setRootIsDecorated(TRUE);
342 disabledColorGroup = palette().active();
343 disabledColorGroup.setColor(QColorGroup::Text, palette().disabled().text());
344 inactivedColorGroup = palette().active();
345 inactivedColorGroup.setColor(QColorGroup::Highlight, palette().disabled().highlight());
346
347 connect(this, SIGNAL(selectionChanged(void)),
348 SLOT(updateSelection(void)));
349
Roman Zippel7fc925f2006-06-08 22:12:46 -0700350 if (name) {
351 configSettings->beginGroup(name);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700352 showName = configSettings->readBoolEntry("/showName", false);
353 showRange = configSettings->readBoolEntry("/showRange", false);
354 showData = configSettings->readBoolEntry("/showData", false);
Li Zefan39a48972010-05-10 16:33:41 +0800355 optMode = (enum optionMode)configSettings->readNumEntry("/optionMode", false);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700356 configSettings->endGroup();
357 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 }
359
360 for (i = 0; i < colNr; i++)
361 colMap[i] = colRevMap[i] = -1;
EGRY Gaborc21a2d92008-01-11 23:52:07 +0100362 addColumn(promptColIdx, _("Option"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 reinit();
365}
366
Li Zefan39a48972010-05-10 16:33:41 +0800367bool ConfigList::menuSkip(struct menu *menu)
368{
369 if (optMode == normalOpt && menu_is_visible(menu))
370 return false;
371 if (optMode == promptOpt && menu_has_prompt(menu))
372 return false;
373 if (optMode == allOpt)
374 return false;
375 return true;
376}
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378void ConfigList::reinit(void)
379{
380 removeColumn(dataColIdx);
381 removeColumn(yesColIdx);
382 removeColumn(modColIdx);
383 removeColumn(noColIdx);
384 removeColumn(nameColIdx);
385
386 if (showName)
EGRY Gaborc21a2d92008-01-11 23:52:07 +0100387 addColumn(nameColIdx, _("Name"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (showRange) {
389 addColumn(noColIdx, "N");
390 addColumn(modColIdx, "M");
391 addColumn(yesColIdx, "Y");
392 }
393 if (showData)
EGRY Gaborc21a2d92008-01-11 23:52:07 +0100394 addColumn(dataColIdx, _("Value"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 updateListAll();
397}
398
Roman Zippel7fc925f2006-06-08 22:12:46 -0700399void ConfigList::saveSettings(void)
400{
401 if (name()) {
402 configSettings->beginGroup(name());
403 configSettings->writeEntry("/showName", showName);
404 configSettings->writeEntry("/showRange", showRange);
405 configSettings->writeEntry("/showData", showData);
Li Zefan39a48972010-05-10 16:33:41 +0800406 configSettings->writeEntry("/optionMode", (int)optMode);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700407 configSettings->endGroup();
408 }
409}
410
Roman Zippelb65a47e2006-06-08 22:12:47 -0700411ConfigItem* ConfigList::findConfigItem(struct menu *menu)
412{
413 ConfigItem* item = (ConfigItem*)menu->data;
414
415 for (; item; item = item->nextItem) {
416 if (this == item->listView())
417 break;
418 }
419
420 return item;
421}
422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423void ConfigList::updateSelection(void)
424{
425 struct menu *menu;
426 enum prop_type type;
427
428 ConfigItem* item = (ConfigItem*)selectedItem();
429 if (!item)
430 return;
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 menu = item->menu;
Roman Zippel43bf6122006-06-08 22:12:45 -0700433 emit menuChanged(menu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (!menu)
435 return;
436 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
437 if (mode == menuMode && type == P_MENU)
438 emit menuSelected(menu);
439}
440
441void ConfigList::updateList(ConfigItem* item)
442{
443 ConfigItem* last = 0;
444
Roman Zippel43bf6122006-06-08 22:12:45 -0700445 if (!rootEntry) {
446 if (mode != listMode)
447 goto update;
Alexander Stein133c5f72010-08-31 17:34:37 +0200448 Q3ListViewItemIterator it(this);
Roman Zippel43bf6122006-06-08 22:12:45 -0700449 ConfigItem* item;
450
451 for (; it.current(); ++it) {
452 item = (ConfigItem*)it.current();
453 if (!item->menu)
454 continue;
455 item->testUpdateMenu(menu_is_visible(item->menu));
456 }
457 return;
458 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 if (rootEntry != &rootmenu && (mode == singleMode ||
461 (mode == symbolMode && rootEntry->parent != &rootmenu))) {
462 item = firstChild();
463 if (!item)
464 item = new ConfigItem(this, 0, true);
465 last = item;
466 }
467 if ((mode == singleMode || (mode == symbolMode && !(rootEntry->flags & MENU_ROOT))) &&
468 rootEntry->sym && rootEntry->prompt) {
469 item = last ? last->nextSibling() : firstChild();
470 if (!item)
471 item = new ConfigItem(this, last, rootEntry, true);
472 else
473 item->testUpdateMenu(true);
474
475 updateMenuList(item, rootEntry);
476 triggerUpdate();
477 return;
478 }
479update:
480 updateMenuList(this, rootEntry);
481 triggerUpdate();
482}
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484void ConfigList::setValue(ConfigItem* item, tristate val)
485{
486 struct symbol* sym;
487 int type;
488 tristate oldval;
489
490 sym = item->menu ? item->menu->sym : 0;
491 if (!sym)
492 return;
493
494 type = sym_get_type(sym);
495 switch (type) {
496 case S_BOOLEAN:
497 case S_TRISTATE:
498 oldval = sym_get_tristate_value(sym);
499
500 if (!sym_set_tristate_value(sym, val))
501 return;
502 if (oldval == no && item->menu->list)
503 item->setOpen(TRUE);
504 parent()->updateList(item);
505 break;
506 }
507}
508
509void ConfigList::changeValue(ConfigItem* item)
510{
511 struct symbol* sym;
512 struct menu* menu;
513 int type, oldexpr, newexpr;
514
515 menu = item->menu;
516 if (!menu)
517 return;
518 sym = menu->sym;
519 if (!sym) {
520 if (item->menu->list)
521 item->setOpen(!item->isOpen());
522 return;
523 }
524
525 type = sym_get_type(sym);
526 switch (type) {
527 case S_BOOLEAN:
528 case S_TRISTATE:
529 oldexpr = sym_get_tristate_value(sym);
530 newexpr = sym_toggle_tristate_value(sym);
531 if (item->menu->list) {
532 if (oldexpr == newexpr)
533 item->setOpen(!item->isOpen());
534 else if (oldexpr == no)
535 item->setOpen(TRUE);
536 }
537 if (oldexpr != newexpr)
538 parent()->updateList(item);
539 break;
540 case S_INT:
541 case S_HEX:
542 case S_STRING:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (colMap[dataColIdx] >= 0)
544 item->startRename(colMap[dataColIdx]);
545 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 parent()->lineEdit->show(item);
547 break;
548 }
549}
550
551void ConfigList::setRootMenu(struct menu *menu)
552{
553 enum prop_type type;
554
555 if (rootEntry == menu)
556 return;
557 type = menu && menu->prompt ? menu->prompt->type : P_UNKNOWN;
558 if (type != P_MENU)
559 return;
560 updateMenuList(this, 0);
561 rootEntry = menu;
562 updateListAll();
563 setSelected(currentItem(), hasFocus());
Roman Zippelb65a47e2006-06-08 22:12:47 -0700564 ensureItemVisible(currentItem());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565}
566
567void ConfigList::setParentMenu(void)
568{
569 ConfigItem* item;
570 struct menu *oldroot;
571
572 oldroot = rootEntry;
573 if (rootEntry == &rootmenu)
574 return;
575 setRootMenu(menu_get_parent_menu(rootEntry->parent));
576
Alexander Stein133c5f72010-08-31 17:34:37 +0200577 Q3ListViewItemIterator it(this);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 for (; (item = (ConfigItem*)it.current()); it++) {
579 if (item->menu == oldroot) {
580 setCurrentItem(item);
581 ensureItemVisible(item);
582 break;
583 }
584 }
585}
586
Roman Zippel7fc925f2006-06-08 22:12:46 -0700587/*
588 * update all the children of a menu entry
589 * removes/adds the entries from the parent widget as necessary
590 *
591 * parent: either the menu list widget or a menu entry widget
592 * menu: entry to be updated
593 */
594template <class P>
595void ConfigList::updateMenuList(P* parent, struct menu* menu)
596{
597 struct menu* child;
598 ConfigItem* item;
599 ConfigItem* last;
600 bool visible;
601 enum prop_type type;
602
603 if (!menu) {
604 while ((item = parent->firstChild()))
605 delete item;
606 return;
607 }
608
609 last = parent->firstChild();
610 if (last && !last->goParent)
611 last = 0;
612 for (child = menu->list; child; child = child->next) {
613 item = last ? last->nextSibling() : parent->firstChild();
614 type = child->prompt ? child->prompt->type : P_UNKNOWN;
615
616 switch (mode) {
617 case menuMode:
618 if (!(child->flags & MENU_ROOT))
619 goto hide;
620 break;
621 case symbolMode:
622 if (child->flags & MENU_ROOT)
623 goto hide;
624 break;
625 default:
626 break;
627 }
628
629 visible = menu_is_visible(child);
Li Zefan39a48972010-05-10 16:33:41 +0800630 if (!menuSkip(child)) {
Cyrill V. Gorcunoved8b4d42007-02-14 00:33:03 -0800631 if (!child->sym && !child->list && !child->prompt)
632 continue;
Roman Zippel7fc925f2006-06-08 22:12:46 -0700633 if (!item || item->menu != child)
634 item = new ConfigItem(parent, last, child, visible);
635 else
636 item->testUpdateMenu(visible);
637
638 if (mode == fullMode || mode == menuMode || type != P_MENU)
639 updateMenuList(item, child);
640 else
641 updateMenuList(item, 0);
642 last = item;
643 continue;
644 }
645 hide:
646 if (item && item->menu == child) {
647 last = parent->firstChild();
648 if (last == item)
649 last = 0;
650 else while (last->nextSibling() != item)
651 last = last->nextSibling();
652 delete item;
653 }
654 }
655}
656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657void ConfigList::keyPressEvent(QKeyEvent* ev)
658{
Alexander Stein133c5f72010-08-31 17:34:37 +0200659 Q3ListViewItem* i = currentItem();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 ConfigItem* item;
661 struct menu *menu;
662 enum prop_type type;
663
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200664 if (ev->key() == Qt::Key_Escape && mode != fullMode && mode != listMode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 emit parentSelected();
666 ev->accept();
667 return;
668 }
669
670 if (!i) {
671 Parent::keyPressEvent(ev);
672 return;
673 }
674 item = (ConfigItem*)i;
675
676 switch (ev->key()) {
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200677 case Qt::Key_Return:
678 case Qt::Key_Enter:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 if (item->goParent) {
680 emit parentSelected();
681 break;
682 }
683 menu = item->menu;
684 if (!menu)
685 break;
686 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
687 if (type == P_MENU && rootEntry != menu &&
688 mode != fullMode && mode != menuMode) {
689 emit menuSelected(menu);
690 break;
691 }
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200692 case Qt::Key_Space:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 changeValue(item);
694 break;
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200695 case Qt::Key_N:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 setValue(item, no);
697 break;
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200698 case Qt::Key_M:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 setValue(item, mod);
700 break;
Markus Heidelbergfbb86372009-05-18 01:36:51 +0200701 case Qt::Key_Y:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 setValue(item, yes);
703 break;
704 default:
705 Parent::keyPressEvent(ev);
706 return;
707 }
708 ev->accept();
709}
710
711void ConfigList::contentsMousePressEvent(QMouseEvent* e)
712{
713 //QPoint p(contentsToViewport(e->pos()));
714 //printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
715 Parent::contentsMousePressEvent(e);
716}
717
718void ConfigList::contentsMouseReleaseEvent(QMouseEvent* e)
719{
720 QPoint p(contentsToViewport(e->pos()));
721 ConfigItem* item = (ConfigItem*)itemAt(p);
722 struct menu *menu;
723 enum prop_type ptype;
724 const QPixmap* pm;
725 int idx, x;
726
727 if (!item)
728 goto skip;
729
730 menu = item->menu;
731 x = header()->offset() + p.x();
732 idx = colRevMap[header()->sectionAt(x)];
733 switch (idx) {
734 case promptColIdx:
735 pm = item->pixmap(promptColIdx);
736 if (pm) {
737 int off = header()->sectionPos(0) + itemMargin() +
738 treeStepSize() * (item->depth() + (rootIsDecorated() ? 1 : 0));
739 if (x >= off && x < off + pm->width()) {
740 if (item->goParent) {
741 emit parentSelected();
742 break;
743 } else if (!menu)
744 break;
745 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
746 if (ptype == P_MENU && rootEntry != menu &&
747 mode != fullMode && mode != menuMode)
748 emit menuSelected(menu);
749 else
750 changeValue(item);
751 }
752 }
753 break;
754 case noColIdx:
755 setValue(item, no);
756 break;
757 case modColIdx:
758 setValue(item, mod);
759 break;
760 case yesColIdx:
761 setValue(item, yes);
762 break;
763 case dataColIdx:
764 changeValue(item);
765 break;
766 }
767
768skip:
769 //printf("contentsMouseReleaseEvent: %d,%d\n", p.x(), p.y());
770 Parent::contentsMouseReleaseEvent(e);
771}
772
773void ConfigList::contentsMouseMoveEvent(QMouseEvent* e)
774{
775 //QPoint p(contentsToViewport(e->pos()));
776 //printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
777 Parent::contentsMouseMoveEvent(e);
778}
779
780void ConfigList::contentsMouseDoubleClickEvent(QMouseEvent* e)
781{
782 QPoint p(contentsToViewport(e->pos()));
783 ConfigItem* item = (ConfigItem*)itemAt(p);
784 struct menu *menu;
785 enum prop_type ptype;
786
787 if (!item)
788 goto skip;
789 if (item->goParent) {
790 emit parentSelected();
791 goto skip;
792 }
793 menu = item->menu;
794 if (!menu)
795 goto skip;
796 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
797 if (ptype == P_MENU && (mode == singleMode || mode == symbolMode))
798 emit menuSelected(menu);
799 else if (menu->sym)
800 changeValue(item);
801
802skip:
803 //printf("contentsMouseDoubleClickEvent: %d,%d\n", p.x(), p.y());
804 Parent::contentsMouseDoubleClickEvent(e);
805}
806
807void ConfigList::focusInEvent(QFocusEvent *e)
808{
Roman Zippelb65a47e2006-06-08 22:12:47 -0700809 struct menu *menu = NULL;
810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 Parent::focusInEvent(e);
812
Roman Zippelb65a47e2006-06-08 22:12:47 -0700813 ConfigItem* item = (ConfigItem *)currentItem();
814 if (item) {
815 setSelected(item, TRUE);
816 menu = item->menu;
817 }
818 emit gotFocus(menu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819}
820
Roman Zippel7fc925f2006-06-08 22:12:46 -0700821void ConfigList::contextMenuEvent(QContextMenuEvent *e)
822{
823 if (e->y() <= header()->geometry().bottom()) {
824 if (!headerPopup) {
Alexander Stein133c5f72010-08-31 17:34:37 +0200825 Q3Action *action;
Roman Zippel7fc925f2006-06-08 22:12:46 -0700826
Alexander Stein133c5f72010-08-31 17:34:37 +0200827 headerPopup = new Q3PopupMenu(this);
828 action = new Q3Action(NULL, _("Show Name"), 0, this);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700829 action->setToggleAction(TRUE);
830 connect(action, SIGNAL(toggled(bool)),
831 parent(), SLOT(setShowName(bool)));
832 connect(parent(), SIGNAL(showNameChanged(bool)),
833 action, SLOT(setOn(bool)));
834 action->setOn(showName);
835 action->addTo(headerPopup);
Alexander Stein133c5f72010-08-31 17:34:37 +0200836 action = new Q3Action(NULL, _("Show Range"), 0, this);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700837 action->setToggleAction(TRUE);
838 connect(action, SIGNAL(toggled(bool)),
839 parent(), SLOT(setShowRange(bool)));
840 connect(parent(), SIGNAL(showRangeChanged(bool)),
841 action, SLOT(setOn(bool)));
842 action->setOn(showRange);
843 action->addTo(headerPopup);
Alexander Stein133c5f72010-08-31 17:34:37 +0200844 action = new Q3Action(NULL, _("Show Data"), 0, this);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700845 action->setToggleAction(TRUE);
846 connect(action, SIGNAL(toggled(bool)),
847 parent(), SLOT(setShowData(bool)));
848 connect(parent(), SIGNAL(showDataChanged(bool)),
849 action, SLOT(setOn(bool)));
850 action->setOn(showData);
851 action->addTo(headerPopup);
852 }
853 headerPopup->exec(e->globalPos());
854 e->accept();
855 } else
856 e->ignore();
857}
858
Li Zefan39a48972010-05-10 16:33:41 +0800859ConfigView*ConfigView::viewList;
860QAction *ConfigView::showNormalAction;
861QAction *ConfigView::showAllAction;
862QAction *ConfigView::showPromptAction;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Roman Zippel7fc925f2006-06-08 22:12:46 -0700864ConfigView::ConfigView(QWidget* parent, const char *name)
865 : Parent(parent, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
Roman Zippel7fc925f2006-06-08 22:12:46 -0700867 list = new ConfigList(this, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 lineEdit = new ConfigLineEdit(this);
869 lineEdit->hide();
870
871 this->nextView = viewList;
872 viewList = this;
873}
874
875ConfigView::~ConfigView(void)
876{
877 ConfigView** vp;
878
879 for (vp = &viewList; *vp; vp = &(*vp)->nextView) {
880 if (*vp == this) {
881 *vp = nextView;
882 break;
883 }
884 }
885}
886
Li Zefan39a48972010-05-10 16:33:41 +0800887void ConfigView::setOptionMode(QAction *act)
Roman Zippel7fc925f2006-06-08 22:12:46 -0700888{
Li Zefan39a48972010-05-10 16:33:41 +0800889 if (act == showNormalAction)
890 list->optMode = normalOpt;
891 else if (act == showAllAction)
892 list->optMode = allOpt;
893 else
894 list->optMode = promptOpt;
895
896 list->updateListAll();
Roman Zippel7fc925f2006-06-08 22:12:46 -0700897}
898
899void ConfigView::setShowName(bool b)
900{
901 if (list->showName != b) {
902 list->showName = b;
903 list->reinit();
904 emit showNameChanged(b);
905 }
906}
907
908void ConfigView::setShowRange(bool b)
909{
910 if (list->showRange != b) {
911 list->showRange = b;
912 list->reinit();
913 emit showRangeChanged(b);
914 }
915}
916
917void ConfigView::setShowData(bool b)
918{
919 if (list->showData != b) {
920 list->showData = b;
921 list->reinit();
922 emit showDataChanged(b);
923 }
924}
925
926void ConfigList::setAllOpen(bool open)
927{
Alexander Stein133c5f72010-08-31 17:34:37 +0200928 Q3ListViewItemIterator it(this);
Roman Zippel7fc925f2006-06-08 22:12:46 -0700929
930 for (; it.current(); it++)
931 it.current()->setOpen(open);
932}
933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934void ConfigView::updateList(ConfigItem* item)
935{
936 ConfigView* v;
937
938 for (v = viewList; v; v = v->nextView)
939 v->list->updateList(item);
940}
941
942void ConfigView::updateListAll(void)
943{
944 ConfigView* v;
945
946 for (v = viewList; v; v = v->nextView)
947 v->list->updateListAll();
948}
949
Roman Zippel43bf6122006-06-08 22:12:45 -0700950ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
Alexander Stein133c5f72010-08-31 17:34:37 +0200951 : Parent(parent, name), sym(0), _menu(0)
Roman Zippel43bf6122006-06-08 22:12:45 -0700952{
Roman Zippel7fc925f2006-06-08 22:12:46 -0700953 if (name) {
954 configSettings->beginGroup(name);
955 _showDebug = configSettings->readBoolEntry("/showDebug", false);
956 configSettings->endGroup();
957 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
958 }
959}
960
961void ConfigInfoView::saveSettings(void)
962{
963 if (name()) {
964 configSettings->beginGroup(name());
965 configSettings->writeEntry("/showDebug", showDebug());
966 configSettings->endGroup();
967 }
Roman Zippel43bf6122006-06-08 22:12:45 -0700968}
969
970void ConfigInfoView::setShowDebug(bool b)
971{
972 if (_showDebug != b) {
973 _showDebug = b;
Alexander Stein133c5f72010-08-31 17:34:37 +0200974 if (_menu)
Roman Zippel43bf6122006-06-08 22:12:45 -0700975 menuInfo();
Roman Zippelab45d192006-06-08 22:12:47 -0700976 else if (sym)
977 symbolInfo();
Roman Zippel43bf6122006-06-08 22:12:45 -0700978 emit showDebugChanged(b);
979 }
980}
981
982void ConfigInfoView::setInfo(struct menu *m)
983{
Alexander Stein133c5f72010-08-31 17:34:37 +0200984 if (_menu == m)
Roman Zippelb65a47e2006-06-08 22:12:47 -0700985 return;
Alexander Stein133c5f72010-08-31 17:34:37 +0200986 _menu = m;
Roman Zippel6fa1da82007-01-10 23:15:31 -0800987 sym = NULL;
Alexander Stein133c5f72010-08-31 17:34:37 +0200988 if (!_menu)
Roman Zippel43bf6122006-06-08 22:12:45 -0700989 clear();
Roman Zippel6fa1da82007-01-10 23:15:31 -0800990 else
Roman Zippel43bf6122006-06-08 22:12:45 -0700991 menuInfo();
992}
993
Roman Zippelab45d192006-06-08 22:12:47 -0700994void ConfigInfoView::symbolInfo(void)
995{
996 QString str;
997
998 str += "<big>Symbol: <b>";
999 str += print_filter(sym->name);
1000 str += "</b></big><br><br>value: ";
1001 str += print_filter(sym_get_string_value(sym));
1002 str += "<br>visibility: ";
1003 str += sym->visible == yes ? "y" : sym->visible == mod ? "m" : "n";
1004 str += "<br>";
1005 str += debug_info(sym);
1006
1007 setText(str);
1008}
1009
Roman Zippel43bf6122006-06-08 22:12:45 -07001010void ConfigInfoView::menuInfo(void)
1011{
1012 struct symbol* sym;
1013 QString head, debug, help;
1014
Alexander Stein133c5f72010-08-31 17:34:37 +02001015 sym = _menu->sym;
Roman Zippel43bf6122006-06-08 22:12:45 -07001016 if (sym) {
Alexander Stein133c5f72010-08-31 17:34:37 +02001017 if (_menu->prompt) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001018 head += "<big><b>";
Alexander Stein133c5f72010-08-31 17:34:37 +02001019 head += print_filter(_(_menu->prompt->text));
Roman Zippel43bf6122006-06-08 22:12:45 -07001020 head += "</b></big>";
1021 if (sym->name) {
1022 head += " (";
Roman Zippelab45d192006-06-08 22:12:47 -07001023 if (showDebug())
1024 head += QString().sprintf("<a href=\"s%p\">", sym);
Roman Zippel43bf6122006-06-08 22:12:45 -07001025 head += print_filter(sym->name);
Roman Zippelab45d192006-06-08 22:12:47 -07001026 if (showDebug())
1027 head += "</a>";
Roman Zippel43bf6122006-06-08 22:12:45 -07001028 head += ")";
1029 }
1030 } else if (sym->name) {
1031 head += "<big><b>";
Roman Zippelab45d192006-06-08 22:12:47 -07001032 if (showDebug())
1033 head += QString().sprintf("<a href=\"s%p\">", sym);
Roman Zippel43bf6122006-06-08 22:12:45 -07001034 head += print_filter(sym->name);
Roman Zippelab45d192006-06-08 22:12:47 -07001035 if (showDebug())
1036 head += "</a>";
Roman Zippel43bf6122006-06-08 22:12:45 -07001037 head += "</b></big>";
1038 }
1039 head += "<br><br>";
1040
1041 if (showDebug())
1042 debug = debug_info(sym);
1043
Cheng Renquand74c15f2009-07-12 16:11:47 +08001044 struct gstr help_gstr = str_new();
Alexander Stein133c5f72010-08-31 17:34:37 +02001045 menu_get_ext_help(_menu, &help_gstr);
Cheng Renquand74c15f2009-07-12 16:11:47 +08001046 help = print_filter(str_get(&help_gstr));
1047 str_free(&help_gstr);
Alexander Stein133c5f72010-08-31 17:34:37 +02001048 } else if (_menu->prompt) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001049 head += "<big><b>";
Alexander Stein133c5f72010-08-31 17:34:37 +02001050 head += print_filter(_(_menu->prompt->text));
Roman Zippel43bf6122006-06-08 22:12:45 -07001051 head += "</b></big><br><br>";
1052 if (showDebug()) {
Alexander Stein133c5f72010-08-31 17:34:37 +02001053 if (_menu->prompt->visible.expr) {
Roman Zippel43bf6122006-06-08 22:12:45 -07001054 debug += "&nbsp;&nbsp;dep: ";
Alexander Stein133c5f72010-08-31 17:34:37 +02001055 expr_print(_menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
Roman Zippel43bf6122006-06-08 22:12:45 -07001056 debug += "<br><br>";
1057 }
1058 }
1059 }
1060 if (showDebug())
Alexander Stein133c5f72010-08-31 17:34:37 +02001061 debug += QString().sprintf("defined at %s:%d<br><br>", _menu->file->name, _menu->lineno);
Roman Zippel43bf6122006-06-08 22:12:45 -07001062
1063 setText(head + debug + help);
1064}
1065
1066QString ConfigInfoView::debug_info(struct symbol *sym)
1067{
1068 QString debug;
1069
1070 debug += "type: ";
1071 debug += print_filter(sym_type_name(sym->type));
1072 if (sym_is_choice(sym))
1073 debug += " (choice)";
1074 debug += "<br>";
1075 if (sym->rev_dep.expr) {
1076 debug += "reverse dep: ";
1077 expr_print(sym->rev_dep.expr, expr_print_help, &debug, E_NONE);
1078 debug += "<br>";
1079 }
1080 for (struct property *prop = sym->prop; prop; prop = prop->next) {
1081 switch (prop->type) {
1082 case P_PROMPT:
1083 case P_MENU:
Roman Zippelab45d192006-06-08 22:12:47 -07001084 debug += QString().sprintf("prompt: <a href=\"m%p\">", prop->menu);
Roman Zippel43bf6122006-06-08 22:12:45 -07001085 debug += print_filter(_(prop->text));
Roman Zippelab45d192006-06-08 22:12:47 -07001086 debug += "</a><br>";
Roman Zippel43bf6122006-06-08 22:12:45 -07001087 break;
1088 case P_DEFAULT:
Roman Zippel93449082008-01-14 04:50:54 +01001089 case P_SELECT:
1090 case P_RANGE:
1091 case P_ENV:
1092 debug += prop_get_type_name(prop->type);
1093 debug += ": ";
Roman Zippel43bf6122006-06-08 22:12:45 -07001094 expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1095 debug += "<br>";
1096 break;
1097 case P_CHOICE:
1098 if (sym_is_choice(sym)) {
1099 debug += "choice: ";
1100 expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1101 debug += "<br>";
1102 }
1103 break;
Roman Zippel43bf6122006-06-08 22:12:45 -07001104 default:
1105 debug += "unknown property: ";
1106 debug += prop_get_type_name(prop->type);
1107 debug += "<br>";
1108 }
1109 if (prop->visible.expr) {
1110 debug += "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
1111 expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
1112 debug += "<br>";
1113 }
1114 }
1115 debug += "<br>";
1116
1117 return debug;
1118}
1119
1120QString ConfigInfoView::print_filter(const QString &str)
1121{
1122 QRegExp re("[<>&\"\\n]");
1123 QString res = str;
1124 for (int i = 0; (i = res.find(re, i)) >= 0;) {
1125 switch (res[i].latin1()) {
1126 case '<':
1127 res.replace(i, 1, "&lt;");
1128 i += 4;
1129 break;
1130 case '>':
1131 res.replace(i, 1, "&gt;");
1132 i += 4;
1133 break;
1134 case '&':
1135 res.replace(i, 1, "&amp;");
1136 i += 5;
1137 break;
1138 case '"':
1139 res.replace(i, 1, "&quot;");
1140 i += 6;
1141 break;
1142 case '\n':
1143 res.replace(i, 1, "<br>");
1144 i += 4;
1145 break;
1146 }
1147 }
1148 return res;
1149}
1150
Roman Zippelab45d192006-06-08 22:12:47 -07001151void ConfigInfoView::expr_print_help(void *data, struct symbol *sym, const char *str)
Roman Zippel43bf6122006-06-08 22:12:45 -07001152{
Roman Zippelab45d192006-06-08 22:12:47 -07001153 QString* text = reinterpret_cast<QString*>(data);
1154 QString str2 = print_filter(str);
1155
1156 if (sym && sym->name && !(sym->flags & SYMBOL_CONST)) {
1157 *text += QString().sprintf("<a href=\"s%p\">", sym);
1158 *text += str2;
1159 *text += "</a>";
1160 } else
1161 *text += str2;
Roman Zippel43bf6122006-06-08 22:12:45 -07001162}
1163
Alexander Stein133c5f72010-08-31 17:34:37 +02001164Q3PopupMenu* ConfigInfoView::createPopupMenu(const QPoint& pos)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001165{
Alexander Stein133c5f72010-08-31 17:34:37 +02001166 Q3PopupMenu* popup = Parent::createPopupMenu(pos);
1167 Q3Action* action = new Q3Action(NULL, _("Show Debug Info"), 0, popup);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001168 action->setToggleAction(TRUE);
1169 connect(action, SIGNAL(toggled(bool)), SLOT(setShowDebug(bool)));
1170 connect(this, SIGNAL(showDebugChanged(bool)), action, SLOT(setOn(bool)));
1171 action->setOn(showDebug());
1172 popup->insertSeparator();
1173 action->addTo(popup);
1174 return popup;
1175}
1176
1177void ConfigInfoView::contentsContextMenuEvent(QContextMenuEvent *e)
1178{
1179 Parent::contentsContextMenuEvent(e);
1180}
1181
Marco Costalba63431e72006-10-05 19:12:59 +02001182ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *name)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001183 : Parent(parent, name), result(NULL)
Roman Zippel43bf6122006-06-08 22:12:45 -07001184{
1185 setCaption("Search Config");
1186
1187 QVBoxLayout* layout1 = new QVBoxLayout(this, 11, 6);
1188 QHBoxLayout* layout2 = new QHBoxLayout(0, 0, 6);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001189 layout2->addWidget(new QLabel(_("Find:"), this));
Roman Zippel43bf6122006-06-08 22:12:45 -07001190 editField = new QLineEdit(this);
1191 connect(editField, SIGNAL(returnPressed()), SLOT(search()));
1192 layout2->addWidget(editField);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001193 searchButton = new QPushButton(_("Search"), this);
Roman Zippel43bf6122006-06-08 22:12:45 -07001194 searchButton->setAutoDefault(FALSE);
1195 connect(searchButton, SIGNAL(clicked()), SLOT(search()));
1196 layout2->addWidget(searchButton);
1197 layout1->addLayout(layout2);
1198
Roman Zippel7fc925f2006-06-08 22:12:46 -07001199 split = new QSplitter(this);
Markus Heidelberg7298b932009-05-18 01:36:50 +02001200 split->setOrientation(Qt::Vertical);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001201 list = new ConfigView(split, name);
Roman Zippel43bf6122006-06-08 22:12:45 -07001202 list->list->mode = listMode;
Roman Zippel7fc925f2006-06-08 22:12:46 -07001203 info = new ConfigInfoView(split, name);
Roman Zippel43bf6122006-06-08 22:12:45 -07001204 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1205 info, SLOT(setInfo(struct menu *)));
Marco Costalba63431e72006-10-05 19:12:59 +02001206 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1207 parent, SLOT(setMenuLink(struct menu *)));
1208
Roman Zippel43bf6122006-06-08 22:12:45 -07001209 layout1->addWidget(split);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001210
1211 if (name) {
1212 int x, y, width, height;
1213 bool ok;
1214
1215 configSettings->beginGroup(name);
1216 width = configSettings->readNumEntry("/window width", parent->width() / 2);
1217 height = configSettings->readNumEntry("/window height", parent->height() / 2);
1218 resize(width, height);
1219 x = configSettings->readNumEntry("/window x", 0, &ok);
1220 if (ok)
1221 y = configSettings->readNumEntry("/window y", 0, &ok);
1222 if (ok)
1223 move(x, y);
Alexander Stein133c5f72010-08-31 17:34:37 +02001224 Q3ValueList<int> sizes = configSettings->readSizes("/split", &ok);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001225 if (ok)
1226 split->setSizes(sizes);
1227 configSettings->endGroup();
1228 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
1229 }
1230}
1231
1232void ConfigSearchWindow::saveSettings(void)
1233{
1234 if (name()) {
1235 configSettings->beginGroup(name());
1236 configSettings->writeEntry("/window x", pos().x());
1237 configSettings->writeEntry("/window y", pos().y());
1238 configSettings->writeEntry("/window width", size().width());
1239 configSettings->writeEntry("/window height", size().height());
1240 configSettings->writeSizes("/split", split->sizes());
1241 configSettings->endGroup();
1242 }
Roman Zippel43bf6122006-06-08 22:12:45 -07001243}
1244
1245void ConfigSearchWindow::search(void)
1246{
1247 struct symbol **p;
1248 struct property *prop;
1249 ConfigItem *lastItem = NULL;
1250
1251 free(result);
1252 list->list->clear();
Cyrill V. Gorcunov786fb182007-02-14 00:32:59 -08001253 info->clear();
Roman Zippel43bf6122006-06-08 22:12:45 -07001254
1255 result = sym_re_search(editField->text().latin1());
1256 if (!result)
1257 return;
1258 for (p = result; *p; p++) {
1259 for_all_prompts((*p), prop)
1260 lastItem = new ConfigItem(list->list, lastItem, prop->menu,
1261 menu_is_visible(prop->menu));
1262 }
1263}
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265/*
1266 * Construct the complete config widget
1267 */
1268ConfigMainWindow::ConfigMainWindow(void)
Roman Zippelf12aa702006-11-25 11:09:31 -08001269 : searchWindow(0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270{
1271 QMenuBar* menu;
Roman Zippel7fc925f2006-06-08 22:12:46 -07001272 bool ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 int x, y, width, height;
Randy Dunlapa54bb702007-10-20 11:18:47 -07001274 char title[256];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Markus Heidelberg8d90c972009-05-18 01:36:52 +02001276 QDesktopWidget *d = configApp->desktop();
Arnaud Lacombe09548282010-08-18 01:57:13 -04001277 snprintf(title, sizeof(title), "%s%s",
1278 rootmenu.prompt->text,
Michal Marek76a136c2010-09-01 17:39:27 +02001279#if QT_VERSION < 0x040000
1280 " (Qt3)"
1281#else
1282 ""
1283#endif
1284 );
Randy Dunlapa54bb702007-10-20 11:18:47 -07001285 setCaption(title);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
Roman Zippel7fc925f2006-06-08 22:12:46 -07001287 width = configSettings->readNumEntry("/window width", d->width() - 64);
1288 height = configSettings->readNumEntry("/window height", d->height() - 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 resize(width, height);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001290 x = configSettings->readNumEntry("/window x", 0, &ok);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 if (ok)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001292 y = configSettings->readNumEntry("/window y", 0, &ok);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 if (ok)
1294 move(x, y);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
1296 split1 = new QSplitter(this);
Markus Heidelberg7298b932009-05-18 01:36:50 +02001297 split1->setOrientation(Qt::Horizontal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 setCentralWidget(split1);
1299
Roman Zippel7fc925f2006-06-08 22:12:46 -07001300 menuView = new ConfigView(split1, "menu");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 menuList = menuView->list;
1302
1303 split2 = new QSplitter(split1);
Markus Heidelberg7298b932009-05-18 01:36:50 +02001304 split2->setOrientation(Qt::Vertical);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
1306 // create config tree
Roman Zippel7fc925f2006-06-08 22:12:46 -07001307 configView = new ConfigView(split2, "config");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 configList = configView->list;
1309
Roman Zippel7fc925f2006-06-08 22:12:46 -07001310 helpText = new ConfigInfoView(split2, "help");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 helpText->setTextFormat(Qt::RichText);
1312
1313 setTabOrder(configList, helpText);
1314 configList->setFocus();
1315
1316 menu = menuBar();
Alexander Stein133c5f72010-08-31 17:34:37 +02001317 toolBar = new Q3ToolBar("Tools", this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Alexander Stein133c5f72010-08-31 17:34:37 +02001319 backAction = new Q3Action("Back", QPixmap(xpm_back), _("Back"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 connect(backAction, SIGNAL(activated()), SLOT(goBack()));
1321 backAction->setEnabled(FALSE);
Alexander Stein133c5f72010-08-31 17:34:37 +02001322 Q3Action *quitAction = new Q3Action("Quit", _("&Quit"), Qt::CTRL + Qt::Key_Q, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 connect(quitAction, SIGNAL(activated()), SLOT(close()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001324 Q3Action *loadAction = new Q3Action("Load", QPixmap(xpm_load), _("&Load"), Qt::CTRL + Qt::Key_L, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 connect(loadAction, SIGNAL(activated()), SLOT(loadConfig()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001326 saveAction = new Q3Action("Save", QPixmap(xpm_save), _("&Save"), Qt::CTRL + Qt::Key_S, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 connect(saveAction, SIGNAL(activated()), SLOT(saveConfig()));
Karsten Wiese3b354c52006-12-13 00:34:08 -08001328 conf_set_changed_callback(conf_changed);
1329 // Set saveAction's initial state
1330 conf_changed();
Alexander Stein133c5f72010-08-31 17:34:37 +02001331 Q3Action *saveAsAction = new Q3Action("Save As...", _("Save &As..."), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 connect(saveAsAction, SIGNAL(activated()), SLOT(saveConfigAs()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001333 Q3Action *searchAction = new Q3Action("Find", _("&Find"), Qt::CTRL + Qt::Key_F, this);
Roman Zippel43bf6122006-06-08 22:12:45 -07001334 connect(searchAction, SIGNAL(activated()), SLOT(searchConfig()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001335 Q3Action *singleViewAction = new Q3Action("Single View", QPixmap(xpm_single_view), _("Single View"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 connect(singleViewAction, SIGNAL(activated()), SLOT(showSingleView()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001337 Q3Action *splitViewAction = new Q3Action("Split View", QPixmap(xpm_split_view), _("Split View"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 connect(splitViewAction, SIGNAL(activated()), SLOT(showSplitView()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001339 Q3Action *fullViewAction = new Q3Action("Full View", QPixmap(xpm_tree_view), _("Full View"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 connect(fullViewAction, SIGNAL(activated()), SLOT(showFullView()));
1341
Alexander Stein133c5f72010-08-31 17:34:37 +02001342 Q3Action *showNameAction = new Q3Action(NULL, _("Show Name"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 showNameAction->setToggleAction(TRUE);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001344 connect(showNameAction, SIGNAL(toggled(bool)), configView, SLOT(setShowName(bool)));
1345 connect(configView, SIGNAL(showNameChanged(bool)), showNameAction, SLOT(setOn(bool)));
1346 showNameAction->setOn(configView->showName());
Alexander Stein133c5f72010-08-31 17:34:37 +02001347 Q3Action *showRangeAction = new Q3Action(NULL, _("Show Range"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 showRangeAction->setToggleAction(TRUE);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001349 connect(showRangeAction, SIGNAL(toggled(bool)), configView, SLOT(setShowRange(bool)));
1350 connect(configView, SIGNAL(showRangeChanged(bool)), showRangeAction, SLOT(setOn(bool)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 showRangeAction->setOn(configList->showRange);
Alexander Stein133c5f72010-08-31 17:34:37 +02001352 Q3Action *showDataAction = new Q3Action(NULL, _("Show Data"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 showDataAction->setToggleAction(TRUE);
Roman Zippel7fc925f2006-06-08 22:12:46 -07001354 connect(showDataAction, SIGNAL(toggled(bool)), configView, SLOT(setShowData(bool)));
1355 connect(configView, SIGNAL(showDataChanged(bool)), showDataAction, SLOT(setOn(bool)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 showDataAction->setOn(configList->showData);
Li Zefan39a48972010-05-10 16:33:41 +08001357
1358 QActionGroup *optGroup = new QActionGroup(this);
1359 optGroup->setExclusive(TRUE);
1360 connect(optGroup, SIGNAL(selected(QAction *)), configView,
1361 SLOT(setOptionMode(QAction *)));
1362 connect(optGroup, SIGNAL(selected(QAction *)), menuView,
1363 SLOT(setOptionMode(QAction *)));
1364
Alexander Stein133c5f72010-08-31 17:34:37 +02001365#if QT_VERSION >= 0x040000
1366 configView->showNormalAction = new QAction(_("Show Normal Options"), optGroup);
1367 configView->showAllAction = new QAction(_("Show All Options"), optGroup);
1368 configView->showPromptAction = new QAction(_("Show Prompt Options"), optGroup);
1369#else
1370 configView->showNormalAction = new QAction(_("Show Normal Options"), 0, optGroup);
1371 configView->showAllAction = new QAction(_("Show All Options"), 0, optGroup);
1372 configView->showPromptAction = new QAction(_("Show Prompt Options"), 0, optGroup);
1373#endif
Li Zefan39a48972010-05-10 16:33:41 +08001374 configView->showNormalAction->setToggleAction(TRUE);
1375 configView->showNormalAction->setOn(configList->optMode == normalOpt);
1376 configView->showAllAction->setToggleAction(TRUE);
1377 configView->showAllAction->setOn(configList->optMode == allOpt);
1378 configView->showPromptAction->setToggleAction(TRUE);
1379 configView->showPromptAction->setOn(configList->optMode == promptOpt);
1380
Alexander Stein133c5f72010-08-31 17:34:37 +02001381 Q3Action *showDebugAction = new Q3Action(NULL, _("Show Debug Info"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 showDebugAction->setToggleAction(TRUE);
Roman Zippel43bf6122006-06-08 22:12:45 -07001383 connect(showDebugAction, SIGNAL(toggled(bool)), helpText, SLOT(setShowDebug(bool)));
1384 connect(helpText, SIGNAL(showDebugChanged(bool)), showDebugAction, SLOT(setOn(bool)));
Roman Zippel7fc925f2006-06-08 22:12:46 -07001385 showDebugAction->setOn(helpText->showDebug());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Alexander Stein133c5f72010-08-31 17:34:37 +02001387 Q3Action *showIntroAction = new Q3Action(NULL, _("Introduction"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 connect(showIntroAction, SIGNAL(activated()), SLOT(showIntro()));
Alexander Stein133c5f72010-08-31 17:34:37 +02001389 Q3Action *showAboutAction = new Q3Action(NULL, _("About"), 0, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 connect(showAboutAction, SIGNAL(activated()), SLOT(showAbout()));
1391
1392 // init tool bar
1393 backAction->addTo(toolBar);
1394 toolBar->addSeparator();
1395 loadAction->addTo(toolBar);
1396 saveAction->addTo(toolBar);
1397 toolBar->addSeparator();
1398 singleViewAction->addTo(toolBar);
1399 splitViewAction->addTo(toolBar);
1400 fullViewAction->addTo(toolBar);
1401
1402 // create config menu
Alexander Stein133c5f72010-08-31 17:34:37 +02001403 Q3PopupMenu* config = new Q3PopupMenu(this);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001404 menu->insertItem(_("&File"), config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 loadAction->addTo(config);
1406 saveAction->addTo(config);
1407 saveAsAction->addTo(config);
1408 config->insertSeparator();
1409 quitAction->addTo(config);
1410
Shlomi Fish66e7c722007-02-14 00:32:58 -08001411 // create edit menu
Alexander Stein133c5f72010-08-31 17:34:37 +02001412 Q3PopupMenu* editMenu = new Q3PopupMenu(this);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001413 menu->insertItem(_("&Edit"), editMenu);
Shlomi Fish66e7c722007-02-14 00:32:58 -08001414 searchAction->addTo(editMenu);
1415
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 // create options menu
Alexander Stein133c5f72010-08-31 17:34:37 +02001417 Q3PopupMenu* optionMenu = new Q3PopupMenu(this);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001418 menu->insertItem(_("&Option"), optionMenu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 showNameAction->addTo(optionMenu);
1420 showRangeAction->addTo(optionMenu);
1421 showDataAction->addTo(optionMenu);
1422 optionMenu->insertSeparator();
Li Zefan39a48972010-05-10 16:33:41 +08001423 optGroup->addTo(optionMenu);
1424 optionMenu->insertSeparator();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
1426 // create help menu
Alexander Stein133c5f72010-08-31 17:34:37 +02001427 Q3PopupMenu* helpMenu = new Q3PopupMenu(this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 menu->insertSeparator();
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001429 menu->insertItem(_("&Help"), helpMenu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 showIntroAction->addTo(helpMenu);
1431 showAboutAction->addTo(helpMenu);
1432
Roman Zippel43bf6122006-06-08 22:12:45 -07001433 connect(configList, SIGNAL(menuChanged(struct menu *)),
1434 helpText, SLOT(setInfo(struct menu *)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 connect(configList, SIGNAL(menuSelected(struct menu *)),
1436 SLOT(changeMenu(struct menu *)));
1437 connect(configList, SIGNAL(parentSelected()),
1438 SLOT(goBack()));
Roman Zippel43bf6122006-06-08 22:12:45 -07001439 connect(menuList, SIGNAL(menuChanged(struct menu *)),
1440 helpText, SLOT(setInfo(struct menu *)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 connect(menuList, SIGNAL(menuSelected(struct menu *)),
1442 SLOT(changeMenu(struct menu *)));
1443
Roman Zippelb65a47e2006-06-08 22:12:47 -07001444 connect(configList, SIGNAL(gotFocus(struct menu *)),
1445 helpText, SLOT(setInfo(struct menu *)));
1446 connect(menuList, SIGNAL(gotFocus(struct menu *)),
1447 helpText, SLOT(setInfo(struct menu *)));
1448 connect(menuList, SIGNAL(gotFocus(struct menu *)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 SLOT(listFocusChanged(void)));
Roman Zippelb65a47e2006-06-08 22:12:47 -07001450 connect(helpText, SIGNAL(menuSelected(struct menu *)),
1451 SLOT(setMenuLink(struct menu *)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
Roman Zippel7fc925f2006-06-08 22:12:46 -07001453 QString listMode = configSettings->readEntry("/listMode", "symbol");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 if (listMode == "single")
1455 showSingleView();
1456 else if (listMode == "full")
1457 showFullView();
1458 else /*if (listMode == "split")*/
1459 showSplitView();
1460
1461 // UI setup done, restore splitter positions
Alexander Stein133c5f72010-08-31 17:34:37 +02001462 Q3ValueList<int> sizes = configSettings->readSizes("/split1", &ok);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 if (ok)
1464 split1->setSizes(sizes);
1465
Roman Zippel7fc925f2006-06-08 22:12:46 -07001466 sizes = configSettings->readSizes("/split2", &ok);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 if (ok)
1468 split2->setSizes(sizes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469}
1470
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471void ConfigMainWindow::loadConfig(void)
1472{
Alexander Stein133c5f72010-08-31 17:34:37 +02001473 QString s = Q3FileDialog::getOpenFileName(conf_get_configname(), NULL, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 if (s.isNull())
1475 return;
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -07001476 if (conf_read(QFile::encodeName(s)))
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001477 QMessageBox::information(this, "qconf", _("Unable to load configuration!"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 ConfigView::updateListAll();
1479}
1480
1481void ConfigMainWindow::saveConfig(void)
1482{
1483 if (conf_write(NULL))
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001484 QMessageBox::information(this, "qconf", _("Unable to save configuration!"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485}
1486
1487void ConfigMainWindow::saveConfigAs(void)
1488{
Alexander Stein133c5f72010-08-31 17:34:37 +02001489 QString s = Q3FileDialog::getSaveFileName(conf_get_configname(), NULL, this);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 if (s.isNull())
1491 return;
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -07001492 if (conf_write(QFile::encodeName(s)))
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001493 QMessageBox::information(this, "qconf", _("Unable to save configuration!"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494}
1495
Roman Zippel43bf6122006-06-08 22:12:45 -07001496void ConfigMainWindow::searchConfig(void)
1497{
1498 if (!searchWindow)
Roman Zippel7fc925f2006-06-08 22:12:46 -07001499 searchWindow = new ConfigSearchWindow(this, "search");
Roman Zippel43bf6122006-06-08 22:12:45 -07001500 searchWindow->show();
1501}
1502
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503void ConfigMainWindow::changeMenu(struct menu *menu)
1504{
1505 configList->setRootMenu(menu);
Cyrill V. Gorcunovf253f002007-02-14 00:33:00 -08001506 if (configList->rootEntry->parent == &rootmenu)
1507 backAction->setEnabled(FALSE);
1508 else
1509 backAction->setEnabled(TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510}
1511
Roman Zippelb65a47e2006-06-08 22:12:47 -07001512void ConfigMainWindow::setMenuLink(struct menu *menu)
1513{
1514 struct menu *parent;
1515 ConfigList* list = NULL;
1516 ConfigItem* item;
1517
Li Zefan39a48972010-05-10 16:33:41 +08001518 if (configList->menuSkip(menu))
Roman Zippelb65a47e2006-06-08 22:12:47 -07001519 return;
1520
1521 switch (configList->mode) {
1522 case singleMode:
1523 list = configList;
1524 parent = menu_get_parent_menu(menu);
1525 if (!parent)
1526 return;
1527 list->setRootMenu(parent);
1528 break;
1529 case symbolMode:
1530 if (menu->flags & MENU_ROOT) {
1531 configList->setRootMenu(menu);
1532 configList->clearSelection();
1533 list = menuList;
1534 } else {
1535 list = configList;
1536 parent = menu_get_parent_menu(menu->parent);
1537 if (!parent)
1538 return;
1539 item = menuList->findConfigItem(parent);
1540 if (item) {
1541 menuList->setSelected(item, TRUE);
1542 menuList->ensureItemVisible(item);
1543 }
1544 list->setRootMenu(parent);
1545 }
1546 break;
1547 case fullMode:
1548 list = configList;
1549 break;
Markus Heidelberg98403a92009-05-18 01:36:49 +02001550 default:
1551 break;
Roman Zippelb65a47e2006-06-08 22:12:47 -07001552 }
1553
1554 if (list) {
1555 item = list->findConfigItem(menu);
1556 if (item) {
1557 list->setSelected(item, TRUE);
1558 list->ensureItemVisible(item);
1559 list->setFocus();
1560 }
1561 }
1562}
1563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564void ConfigMainWindow::listFocusChanged(void)
1565{
Roman Zippelb65a47e2006-06-08 22:12:47 -07001566 if (menuList->mode == menuMode)
1567 configList->clearSelection();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568}
1569
1570void ConfigMainWindow::goBack(void)
1571{
1572 ConfigItem* item;
1573
1574 configList->setParentMenu();
1575 if (configList->rootEntry == &rootmenu)
1576 backAction->setEnabled(FALSE);
1577 item = (ConfigItem*)menuList->selectedItem();
1578 while (item) {
1579 if (item->menu == configList->rootEntry) {
1580 menuList->setSelected(item, TRUE);
1581 break;
1582 }
1583 item = (ConfigItem*)item->parent();
1584 }
1585}
1586
1587void ConfigMainWindow::showSingleView(void)
1588{
1589 menuView->hide();
1590 menuList->setRootMenu(0);
1591 configList->mode = singleMode;
1592 if (configList->rootEntry == &rootmenu)
1593 configList->updateListAll();
1594 else
1595 configList->setRootMenu(&rootmenu);
1596 configList->setAllOpen(TRUE);
1597 configList->setFocus();
1598}
1599
1600void ConfigMainWindow::showSplitView(void)
1601{
1602 configList->mode = symbolMode;
1603 if (configList->rootEntry == &rootmenu)
1604 configList->updateListAll();
1605 else
1606 configList->setRootMenu(&rootmenu);
1607 configList->setAllOpen(TRUE);
1608 configApp->processEvents();
1609 menuList->mode = menuMode;
1610 menuList->setRootMenu(&rootmenu);
1611 menuList->setAllOpen(TRUE);
1612 menuView->show();
1613 menuList->setFocus();
1614}
1615
1616void ConfigMainWindow::showFullView(void)
1617{
1618 menuView->hide();
1619 menuList->setRootMenu(0);
1620 configList->mode = fullMode;
1621 if (configList->rootEntry == &rootmenu)
1622 configList->updateListAll();
1623 else
1624 configList->setRootMenu(&rootmenu);
1625 configList->setAllOpen(FALSE);
1626 configList->setFocus();
1627}
1628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629/*
1630 * ask for saving configuration before quitting
1631 * TODO ask only when something changed
1632 */
1633void ConfigMainWindow::closeEvent(QCloseEvent* e)
1634{
Karsten Wieseb3214292006-12-13 00:34:06 -08001635 if (!conf_get_changed()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 e->accept();
1637 return;
1638 }
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001639 QMessageBox mb("qconf", _("Save configuration?"), QMessageBox::Warning,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 QMessageBox::Yes | QMessageBox::Default, QMessageBox::No, QMessageBox::Cancel | QMessageBox::Escape);
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001641 mb.setButtonText(QMessageBox::Yes, _("&Save Changes"));
1642 mb.setButtonText(QMessageBox::No, _("&Discard Changes"));
1643 mb.setButtonText(QMessageBox::Cancel, _("Cancel Exit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 switch (mb.exec()) {
1645 case QMessageBox::Yes:
1646 conf_write(NULL);
1647 case QMessageBox::No:
1648 e->accept();
1649 break;
1650 case QMessageBox::Cancel:
1651 e->ignore();
1652 break;
1653 }
1654}
1655
1656void ConfigMainWindow::showIntro(void)
1657{
Arnaud Lacombe652cf982010-08-14 23:51:40 -04001658 static const QString str = _("Welcome to the qconf graphical configuration tool.\n\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 "For each option, a blank box indicates the feature is disabled, a check\n"
1660 "indicates it is enabled, and a dot indicates that it is to be compiled\n"
1661 "as a module. Clicking on the box will cycle through the three states.\n\n"
1662 "If you do not see an option (e.g., a device driver) that you believe\n"
1663 "should be present, try turning on Show All Options under the Options menu.\n"
1664 "Although there is no cross reference yet to help you figure out what other\n"
1665 "options must be enabled to support the option you are interested in, you can\n"
1666 "still view the help of a grayed-out option.\n\n"
1667 "Toggling Show Debug Info under the Options menu will show the dependencies,\n"
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001668 "which you can then match by examining other options.\n\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
1670 QMessageBox::information(this, "qconf", str);
1671}
1672
1673void ConfigMainWindow::showAbout(void)
1674{
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001675 static const QString str = _("qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n\n"
1676 "Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 QMessageBox::information(this, "qconf", str);
1679}
1680
1681void ConfigMainWindow::saveSettings(void)
1682{
Roman Zippel7fc925f2006-06-08 22:12:46 -07001683 configSettings->writeEntry("/window x", pos().x());
1684 configSettings->writeEntry("/window y", pos().y());
1685 configSettings->writeEntry("/window width", size().width());
1686 configSettings->writeEntry("/window height", size().height());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
1688 QString entry;
1689 switch(configList->mode) {
1690 case singleMode :
1691 entry = "single";
1692 break;
1693
1694 case symbolMode :
1695 entry = "split";
1696 break;
1697
1698 case fullMode :
1699 entry = "full";
1700 break;
Markus Heidelberg98403a92009-05-18 01:36:49 +02001701
1702 default:
1703 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 }
Roman Zippel7fc925f2006-06-08 22:12:46 -07001705 configSettings->writeEntry("/listMode", entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
Roman Zippel7fc925f2006-06-08 22:12:46 -07001707 configSettings->writeSizes("/split1", split1->sizes());
1708 configSettings->writeSizes("/split2", split2->sizes());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709}
1710
Karsten Wiese3b354c52006-12-13 00:34:08 -08001711void ConfigMainWindow::conf_changed(void)
1712{
1713 if (saveAction)
1714 saveAction->setEnabled(conf_get_changed());
1715}
1716
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717void fixup_rootmenu(struct menu *menu)
1718{
1719 struct menu *child;
1720 static int menu_cnt = 0;
1721
1722 menu->flags |= MENU_ROOT;
1723 for (child = menu->list; child; child = child->next) {
1724 if (child->prompt && child->prompt->type == P_MENU) {
1725 menu_cnt++;
1726 fixup_rootmenu(child);
1727 menu_cnt--;
1728 } else if (!menu_cnt)
1729 fixup_rootmenu(child);
1730 }
1731}
1732
1733static const char *progname;
1734
1735static void usage(void)
1736{
EGRY Gaborc21a2d92008-01-11 23:52:07 +01001737 printf(_("%s <config>\n"), progname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 exit(0);
1739}
1740
1741int main(int ac, char** av)
1742{
1743 ConfigMainWindow* v;
1744 const char *name;
1745
Arnaldo Carvalho de Melo3b9fa092005-05-05 15:09:46 -07001746 bindtextdomain(PACKAGE, LOCALEDIR);
1747 textdomain(PACKAGE);
1748
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749#ifndef LKC_DIRECT_LINK
1750 kconfig_load();
1751#endif
1752
1753 progname = av[0];
1754 configApp = new QApplication(ac, av);
1755 if (ac > 1 && av[1][0] == '-') {
1756 switch (av[1][1]) {
1757 case 'h':
1758 case '?':
1759 usage();
1760 }
1761 name = av[2];
1762 } else
1763 name = av[1];
1764 if (!name)
1765 usage();
1766
1767 conf_parse(name);
1768 fixup_rootmenu(&rootmenu);
1769 conf_read(NULL);
1770 //zconfdump(stdout);
1771
Roman Zippel7fc925f2006-06-08 22:12:46 -07001772 configSettings = new ConfigSettings();
1773 configSettings->beginGroup("/kconfig/qconf");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 v = new ConfigMainWindow();
1775
1776 //zconfdump(stdout);
Roman Zippel43bf6122006-06-08 22:12:45 -07001777 configApp->setMainWidget(v);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1779 configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
Roman Zippel43bf6122006-06-08 22:12:45 -07001780 v->show();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 configApp->exec();
1782
Roman Zippel7fc925f2006-06-08 22:12:46 -07001783 configSettings->endGroup();
1784 delete configSettings;
1785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 return 0;
1787}