Loading...
1/*
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Copyright (C) 2015 Boris Barbulovski <bbarbulovski@gmail.com>
4 * Released under the terms of the GNU GPL v2.0.
5 */
6
7#include <qglobal.h>
8
9#include <QMainWindow>
10#include <QList>
11#include <qtextbrowser.h>
12#include <QAction>
13#include <QFileDialog>
14#include <QMenu>
15
16#include <qapplication.h>
17#include <qdesktopwidget.h>
18#include <qtoolbar.h>
19#include <qlayout.h>
20#include <qsplitter.h>
21#include <qlineedit.h>
22#include <qlabel.h>
23#include <qpushbutton.h>
24#include <qmenubar.h>
25#include <qmessagebox.h>
26#include <qregexp.h>
27#include <qevent.h>
28
29#include <stdlib.h>
30
31#include "lkc.h"
32#include "qconf.h"
33
34#include "qconf.moc"
35#include "images.c"
36
37#ifdef _
38# undef _
39# define _ qgettext
40#endif
41
42static QApplication *configApp;
43static ConfigSettings *configSettings;
44
45QAction *ConfigMainWindow::saveAction;
46
47static inline QString qgettext(const char* str)
48{
49 return QString::fromLocal8Bit(gettext(str));
50}
51
52static inline QString qgettext(const QString& str)
53{
54 return QString::fromLocal8Bit(gettext(str.toLatin1()));
55}
56
57ConfigSettings::ConfigSettings()
58 : QSettings("kernel.org", "qconf")
59{
60}
61
62/**
63 * Reads a list of integer values from the application settings.
64 */
65QList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
66{
67 QList<int> result;
68 QStringList entryList = value(key).toStringList();
69 QStringList::Iterator it;
70
71 for (it = entryList.begin(); it != entryList.end(); ++it)
72 result.push_back((*it).toInt());
73
74 return result;
75}
76
77/**
78 * Writes a list of integer values to the application settings.
79 */
80bool ConfigSettings::writeSizes(const QString& key, const QList<int>& value)
81{
82 QStringList stringList;
83 QList<int>::ConstIterator it;
84
85 for (it = value.begin(); it != value.end(); ++it)
86 stringList.push_back(QString::number(*it));
87 setValue(key, stringList);
88
89 return true;
90}
91
92
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{
106 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
203 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);
214}
215
216void ConfigItem::testUpdateMenu(bool v)
217{
218 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();
232}
233
234
235/*
236 * construct a menu entry
237 */
238void ConfigItem::init(void)
239{
240 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();
250}
251
252/*
253 * destruct a menu entry
254 */
255ConfigItem::~ConfigItem(void)
256{
257 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 }
266}
267
268ConfigLineEdit::ConfigLineEdit(ConfigView* parent)
269 : Parent(parent)
270{
271 connect(this, SIGNAL(editingFinished()), SLOT(hide()));
272}
273
274void ConfigLineEdit::show(ConfigItem* i)
275{
276 item = i;
277 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);
281 Parent::show();
282 setFocus();
283}
284
285void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
286{
287 switch (e->key()) {
288 case Qt::Key_Escape:
289 break;
290 case Qt::Key_Return:
291 case Qt::Key_Enter:
292 sym_set_string_value(item->menu->sym, text().toLatin1());
293 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
304ConfigList::ConfigList(ConfigView* p, const char *name)
305 : 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),
310 showName(false), showRange(false), showData(false), mode(singleMode), optMode(normalOpt),
311 rootEntry(0), headerPopup(0)
312{
313 int i;
314
315 setObjectName(name);
316 setSortingEnabled(false);
317 setRootIsDecorated(true);
318
319 setVerticalScrollMode(ScrollPerPixel);
320 setHorizontalScrollMode(ScrollPerPixel);
321
322 setHeaderLabels(QStringList() << _("Option") << _("Name") << "N" << "M" << "Y" << _("Value"));
323
324 connect(this, SIGNAL(itemSelectionChanged(void)),
325 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;
351}
352
353void ConfigList::reinit(void)
354{
355 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();
372}
373
374void ConfigList::saveSettings(void)
375{
376 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 }
384}
385
386ConfigItem* ConfigList::findConfigItem(struct menu *menu)
387{
388 ConfigItem* item = (ConfigItem*)menu->data;
389
390 for (; item; item = item->nextItem) {
391 if (this == item->listView())
392 break;
393 }
394
395 return item;
396}
397
398void ConfigList::updateSelection(void)
399{
400 struct menu *menu;
401 enum prop_type type;
402
403 if (selectedItems().count() == 0)
404 return;
405
406 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);
417}
418
419void ConfigList::updateList(ConfigItem* item)
420{
421 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))) {
442 item = (ConfigItem *)topLevelItem(0);
443 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();
457 resizeColumnToContents(0);
458 return;
459 }
460update:
461 updateMenuList(this, rootEntry);
462 update();
463 resizeColumnToContents(0);
464}
465
466void ConfigList::setValue(ConfigItem* item, tristate val)
467{
468 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 }
489}
490
491void ConfigList::changeValue(ConfigItem* item)
492{
493 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:
525 parent()->lineEdit->show(item);
526 break;
527 }
528}
529
530void ConfigList::setRootMenu(struct menu *menu)
531{
532 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 }
546}
547
548void ConfigList::setParentMenu(void)
549{
550 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 }
569}
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 */
578void ConfigList::updateMenuList(ConfigItem *parent, struct menu* menu)
579{
580 struct menu* child;
581 ConfigItem* item;
582 ConfigItem* last;
583 bool visible;
584 enum prop_type type;
585
586 if (!menu) {
587 while (parent->childCount() > 0)
588 {
589 delete parent->takeChild(0);
590 }
591
592 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 }
641}
642
643void 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
708void ConfigList::keyPressEvent(QKeyEvent* ev)
709{
710 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();
760}
761
762void ConfigList::mousePressEvent(QMouseEvent* e)
763{
764 //QPoint p(contentsToViewport(e->pos()));
765 //printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
766 Parent::mousePressEvent(e);
767}
768
769void ConfigList::mouseReleaseEvent(QMouseEvent* e)
770{
771 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();
783 idx = header()->logicalIndexAt(x);
784 switch (idx) {
785 case promptColIdx:
786 icon = item->pixmap(promptColIdx);
787 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 }
803 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);
821}
822
823void ConfigList::mouseMoveEvent(QMouseEvent* e)
824{
825 //QPoint p(contentsToViewport(e->pos()));
826 //printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
827 Parent::mouseMoveEvent(e);
828}
829
830void ConfigList::mouseDoubleClickEvent(QMouseEvent* e)
831{
832 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);
855}
856
857void ConfigList::focusInEvent(QFocusEvent *e)
858{
859 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);
869}
870
871void ConfigList::contextMenuEvent(QContextMenuEvent *e)
872{
873 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();
907}
908
909ConfigView*ConfigView::viewList;
910QAction *ConfigView::showNormalAction;
911QAction *ConfigView::showAllAction;
912QAction *ConfigView::showPromptAction;
913
914ConfigView::ConfigView(QWidget* parent, const char *name)
915 : Parent(parent)
916{
917 setObjectName(name);
918 QVBoxLayout *verticalLayout = new QVBoxLayout(this);
919 verticalLayout->setContentsMargins(0, 0, 0, 0);
920
921 list = new ConfigList(this);
922 verticalLayout->addWidget(list);
923 lineEdit = new ConfigLineEdit(this);
924 lineEdit->hide();
925 verticalLayout->addWidget(lineEdit);
926
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
943void ConfigView::setOptionMode(QAction *act)
944{
945 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();
953}
954
955void ConfigView::setShowName(bool b)
956{
957 if (list->showName != b) {
958 list->showName = b;
959 list->reinit();
960 emit showNameChanged(b);
961 }
962}
963
964void ConfigView::setShowRange(bool b)
965{
966 if (list->showRange != b) {
967 list->showRange = b;
968 list->reinit();
969 emit showRangeChanged(b);
970 }
971}
972
973void ConfigView::setShowData(bool b)
974{
975 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 }
991}
992
993void ConfigView::updateList(ConfigItem* item)
994{
995 ConfigView* v;
996
997 for (v = viewList; v; v = v->nextView)
998 v->list->updateList(item);
999}
1000
1001void ConfigView::updateListAll(void)
1002{
1003 ConfigView* v;
1004
1005 for (v = viewList; v; v = v->nextView)
1006 v->list->updateListAll();
1007}
1008
1009ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
1010 : Parent(parent), sym(0), _menu(0)
1011{
1012 setObjectName(name);
1013
1014
1015 if (!objectName().isEmpty()) {
1016 configSettings->beginGroup(objectName());
1017 _showDebug = configSettings->value("/showDebug", false).toBool();
1018 configSettings->endGroup();
1019 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
1020 }
1021}
1022
1023void ConfigInfoView::saveSettings(void)
1024{
1025 if (!objectName().isEmpty()) {
1026 configSettings->beginGroup(objectName());
1027 configSettings->setValue("/showDebug", showDebug());
1028 configSettings->endGroup();
1029 }
1030}
1031
1032void ConfigInfoView::setShowDebug(bool b)
1033{
1034 if (_showDebug != b) {
1035 _showDebug = b;
1036 if (_menu)
1037 menuInfo();
1038 else if (sym)
1039 symbolInfo();
1040 emit showDebugChanged(b);
1041 }
1042}
1043
1044void ConfigInfoView::setInfo(struct menu *m)
1045{
1046 if (_menu == m)
1047 return;
1048 _menu = m;
1049 sym = NULL;
1050 if (!_menu)
1051 clear();
1052 else
1053 menuInfo();
1054}
1055
1056void 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
1072void ConfigInfoView::menuInfo(void)
1073{
1074 struct symbol* sym;
1075 QString head, debug, help;
1076
1077 sym = _menu->sym;
1078 if (sym) {
1079 if (_menu->prompt) {
1080 head += "<big><b>";
1081 head += print_filter(_(_menu->prompt->text));
1082 head += "</b></big>";
1083 if (sym->name) {
1084 head += " (";
1085 if (showDebug())
1086 head += QString().sprintf("<a href=\"s%p\">", sym);
1087 head += print_filter(sym->name);
1088 if (showDebug())
1089 head += "</a>";
1090 head += ")";
1091 }
1092 } else if (sym->name) {
1093 head += "<big><b>";
1094 if (showDebug())
1095 head += QString().sprintf("<a href=\"s%p\">", sym);
1096 head += print_filter(sym->name);
1097 if (showDebug())
1098 head += "</a>";
1099 head += "</b></big>";
1100 }
1101 head += "<br><br>";
1102
1103 if (showDebug())
1104 debug = debug_info(sym);
1105
1106 struct gstr help_gstr = str_new();
1107 menu_get_ext_help(_menu, &help_gstr);
1108 help = print_filter(str_get(&help_gstr));
1109 str_free(&help_gstr);
1110 } else if (_menu->prompt) {
1111 head += "<big><b>";
1112 head += print_filter(_(_menu->prompt->text));
1113 head += "</b></big><br><br>";
1114 if (showDebug()) {
1115 if (_menu->prompt->visible.expr) {
1116 debug += " dep: ";
1117 expr_print(_menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
1118 debug += "<br><br>";
1119 }
1120 }
1121 }
1122 if (showDebug())
1123 debug += QString().sprintf("defined at %s:%d<br><br>", _menu->file->name, _menu->lineno);
1124
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:
1146 debug += QString().sprintf("prompt: <a href=\"m%p\">", prop->menu);
1147 debug += print_filter(_(prop->text));
1148 debug += "</a><br>";
1149 break;
1150 case P_DEFAULT:
1151 case P_SELECT:
1152 case P_RANGE:
1153 case P_ENV:
1154 debug += prop_get_type_name(prop->type);
1155 debug += ": ";
1156 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;
1166 default:
1167 debug += "unknown property: ";
1168 debug += prop_get_type_name(prop->type);
1169 debug += "<br>";
1170 }
1171 if (prop->visible.expr) {
1172 debug += " 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;
1186 for (int i = 0; (i = res.indexOf(re, i)) >= 0;) {
1187 switch (res[i].toLatin1()) {
1188 case '<':
1189 res.replace(i, 1, "<");
1190 i += 4;
1191 break;
1192 case '>':
1193 res.replace(i, 1, ">");
1194 i += 4;
1195 break;
1196 case '&':
1197 res.replace(i, 1, "&");
1198 i += 5;
1199 break;
1200 case '"':
1201 res.replace(i, 1, """);
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
1213void ConfigInfoView::expr_print_help(void *data, struct symbol *sym, const char *str)
1214{
1215 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;
1224}
1225
1226QMenu* ConfigInfoView::createStandardContextMenu(const QPoint & pos)
1227{
1228 QMenu* popup = Parent::createStandardContextMenu(pos);
1229 QAction* action = new QAction(_("Show Debug Info"), popup);
1230 action->setCheckable(true);
1231 connect(action, SIGNAL(toggled(bool)), SLOT(setShowDebug(bool)));
1232 connect(this, SIGNAL(showDebugChanged(bool)), action, SLOT(setOn(bool)));
1233 action->setChecked(showDebug());
1234 popup->addSeparator();
1235 popup->addAction(action);
1236 return popup;
1237}
1238
1239void ConfigInfoView::contextMenuEvent(QContextMenuEvent *e)
1240{
1241 Parent::contextMenuEvent(e);
1242}
1243
1244ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *name)
1245 : Parent(parent), result(NULL)
1246{
1247 setObjectName(name);
1248 setWindowTitle("Search Config");
1249
1250 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);
1256 layout2->addWidget(new QLabel(_("Find:"), this));
1257 editField = new QLineEdit(this);
1258 connect(editField, SIGNAL(returnPressed()), SLOT(search()));
1259 layout2->addWidget(editField);
1260 searchButton = new QPushButton(_("Search"), this);
1261 searchButton->setAutoDefault(false);
1262 connect(searchButton, SIGNAL(clicked()), SLOT(search()));
1263 layout2->addWidget(searchButton);
1264 layout1->addLayout(layout2);
1265
1266 split = new QSplitter(this);
1267 split->setOrientation(Qt::Vertical);
1268 list = new ConfigView(split, name);
1269 list->list->mode = listMode;
1270 info = new ConfigInfoView(split, name);
1271 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1272 info, SLOT(setInfo(struct menu *)));
1273 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1274 parent, SLOT(setMenuLink(struct menu *)));
1275
1276 layout1->addWidget(split);
1277
1278 if (name) {
1279 QVariant x, y;
1280 int width, height;
1281 bool ok;
1282
1283 configSettings->beginGroup(name);
1284 width = configSettings->value("/window width", parent->width() / 2).toInt();
1285 height = configSettings->value("/window height", parent->height() / 2).toInt();
1286 resize(width, height);
1287 x = configSettings->value("/window x");
1288 y = configSettings->value("/window y");
1289 if ((x.isValid())&&(y.isValid()))
1290 move(x.toInt(), y.toInt());
1291 QList<int> sizes = configSettings->readSizes("/split", &ok);
1292 if (ok)
1293 split->setSizes(sizes);
1294 configSettings->endGroup();
1295 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
1296 }
1297}
1298
1299void ConfigSearchWindow::saveSettings(void)
1300{
1301 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 }
1310}
1311
1312void ConfigSearchWindow::search(void)
1313{
1314 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 }
1330}
1331
1332/*
1333 * Construct the complete config widget
1334 */
1335ConfigMainWindow::ConfigMainWindow(void)
1336 : searchWindow(0)
1337{
1338 QMenuBar* menu;
1339 bool ok = true;
1340 QVariant x, y;
1341 int width, height;
1342 char title[256];
1343
1344 QDesktopWidget *d = configApp->desktop();
1345 snprintf(title, sizeof(title), "%s%s",
1346 rootmenu.prompt->text,
1347 ""
1348 );
1349 setWindowTitle(title);
1350
1351 width = configSettings->value("/window width", d->width() - 64).toInt();
1352 height = configSettings->value("/window height", d->height() - 64).toInt();
1353 resize(width, height);
1354 x = configSettings->value("/window x");
1355 y = configSettings->value("/window y");
1356 if ((x.isValid())&&(y.isValid()))
1357 move(x.toInt(), y.toInt());
1358
1359 split1 = new QSplitter(this);
1360 split1->setOrientation(Qt::Horizontal);
1361 setCentralWidget(split1);
1362
1363 menuView = new ConfigView(split1, "menu");
1364 menuList = menuView->list;
1365
1366 split2 = new QSplitter(split1);
1367 split2->setOrientation(Qt::Vertical);
1368
1369 // create config tree
1370 configView = new ConfigView(split2, "config");
1371 configList = configView->list;
1372
1373 helpText = new ConfigInfoView(split2, "help");
1374
1375 setTabOrder(configList, helpText);
1376 configList->setFocus();
1377
1378 menu = menuBar();
1379 toolBar = new QToolBar("Tools", this);
1380 addToolBar(toolBar);
1381
1382 backAction = new QAction(QPixmap(xpm_back), _("Back"), this);
1383 connect(backAction, SIGNAL(triggered(bool)), SLOT(goBack()));
1384 backAction->setEnabled(false);
1385 QAction *quitAction = new QAction(_("&Quit"), this);
1386 quitAction->setShortcut(Qt::CTRL + Qt::Key_Q);
1387 connect(quitAction, SIGNAL(triggered(bool)), SLOT(close()));
1388 QAction *loadAction = new QAction(QPixmap(xpm_load), _("&Load"), this);
1389 loadAction->setShortcut(Qt::CTRL + Qt::Key_L);
1390 connect(loadAction, SIGNAL(triggered(bool)), SLOT(loadConfig()));
1391 saveAction = new QAction(QPixmap(xpm_save), _("&Save"), this);
1392 saveAction->setShortcut(Qt::CTRL + Qt::Key_S);
1393 connect(saveAction, SIGNAL(triggered(bool)), SLOT(saveConfig()));
1394 conf_set_changed_callback(conf_changed);
1395 // Set saveAction's initial state
1396 conf_changed();
1397 QAction *saveAsAction = new QAction(_("Save &As..."), this);
1398 connect(saveAsAction, SIGNAL(triggered(bool)), SLOT(saveConfigAs()));
1399 QAction *searchAction = new QAction(_("&Find"), this);
1400 searchAction->setShortcut(Qt::CTRL + Qt::Key_F);
1401 connect(searchAction, SIGNAL(triggered(bool)), SLOT(searchConfig()));
1402 singleViewAction = new QAction(QPixmap(xpm_single_view), _("Single View"), this);
1403 singleViewAction->setCheckable(true);
1404 connect(singleViewAction, SIGNAL(triggered(bool)), SLOT(showSingleView()));
1405 splitViewAction = new QAction(QPixmap(xpm_split_view), _("Split View"), this);
1406 splitViewAction->setCheckable(true);
1407 connect(splitViewAction, SIGNAL(triggered(bool)), SLOT(showSplitView()));
1408 fullViewAction = new QAction(QPixmap(xpm_tree_view), _("Full View"), this);
1409 fullViewAction->setCheckable(true);
1410 connect(fullViewAction, SIGNAL(triggered(bool)), SLOT(showFullView()));
1411
1412 QAction *showNameAction = new QAction(_("Show Name"), this);
1413 showNameAction->setCheckable(true);
1414 connect(showNameAction, SIGNAL(toggled(bool)), configView, SLOT(setShowName(bool)));
1415 showNameAction->setChecked(configView->showName());
1416 QAction *showRangeAction = new QAction(_("Show Range"), this);
1417 showRangeAction->setCheckable(true);
1418 connect(showRangeAction, SIGNAL(toggled(bool)), configView, SLOT(setShowRange(bool)));
1419 QAction *showDataAction = new QAction(_("Show Data"), this);
1420 showDataAction->setCheckable(true);
1421 connect(showDataAction, SIGNAL(toggled(bool)), configView, SLOT(setShowData(bool)));
1422
1423 QActionGroup *optGroup = new QActionGroup(this);
1424 optGroup->setExclusive(true);
1425 connect(optGroup, SIGNAL(triggered(QAction*)), configView,
1426 SLOT(setOptionMode(QAction *)));
1427 connect(optGroup, SIGNAL(triggered(QAction *)), menuView,
1428 SLOT(setOptionMode(QAction *)));
1429
1430 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);
1433 configView->showNormalAction->setCheckable(true);
1434 configView->showAllAction->setCheckable(true);
1435 configView->showPromptAction->setCheckable(true);
1436
1437 QAction *showDebugAction = new QAction( _("Show Debug Info"), this);
1438 showDebugAction->setCheckable(true);
1439 connect(showDebugAction, SIGNAL(toggled(bool)), helpText, SLOT(setShowDebug(bool)));
1440 showDebugAction->setChecked(helpText->showDebug());
1441
1442 QAction *showIntroAction = new QAction( _("Introduction"), this);
1443 connect(showIntroAction, SIGNAL(triggered(bool)), SLOT(showIntro()));
1444 QAction *showAboutAction = new QAction( _("About"), this);
1445 connect(showAboutAction, SIGNAL(triggered(bool)), SLOT(showAbout()));
1446
1447 // init tool bar
1448 toolBar->addAction(backAction);
1449 toolBar->addSeparator();
1450 toolBar->addAction(loadAction);
1451 toolBar->addAction(saveAction);
1452 toolBar->addSeparator();
1453 toolBar->addAction(singleViewAction);
1454 toolBar->addAction(splitViewAction);
1455 toolBar->addAction(fullViewAction);
1456
1457 // create config menu
1458 QMenu* config = menu->addMenu(_("&File"));
1459 config->addAction(loadAction);
1460 config->addAction(saveAction);
1461 config->addAction(saveAsAction);
1462 config->addSeparator();
1463 config->addAction(quitAction);
1464
1465 // create edit menu
1466 QMenu* editMenu = menu->addMenu(_("&Edit"));
1467 editMenu->addAction(searchAction);
1468
1469 // create options menu
1470 QMenu* optionMenu = menu->addMenu(_("&Option"));
1471 optionMenu->addAction(showNameAction);
1472 optionMenu->addAction(showRangeAction);
1473 optionMenu->addAction(showDataAction);
1474 optionMenu->addSeparator();
1475 optionMenu->addActions(optGroup->actions());
1476 optionMenu->addSeparator();
1477
1478 // create help menu
1479 menu->addSeparator();
1480 QMenu* helpMenu = menu->addMenu(_("&Help"));
1481 helpMenu->addAction(showIntroAction);
1482 helpMenu->addAction(showAboutAction);
1483
1484 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)));
1501 connect(helpText, SIGNAL(menuSelected(struct menu *)),
1502 SLOT(setMenuLink(struct menu *)));
1503
1504 QString listMode = configSettings->value("/listMode", "symbol").toString();
1505 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
1513 QList<int> sizes = configSettings->readSizes("/split1", &ok);
1514 if (ok)
1515 split1->setSizes(sizes);
1516
1517 sizes = configSettings->readSizes("/split2", &ok);
1518 if (ok)
1519 split2->setSizes(sizes);
1520}
1521
1522void ConfigMainWindow::loadConfig(void)
1523{
1524 QString s = QFileDialog::getOpenFileName(this, "", conf_get_configname());
1525 if (s.isNull())
1526 return;
1527 if (conf_read(QFile::encodeName(s)))
1528 QMessageBox::information(this, "qconf", _("Unable to load configuration!"));
1529 ConfigView::updateListAll();
1530}
1531
1532bool ConfigMainWindow::saveConfig(void)
1533{
1534 if (conf_write(NULL)) {
1535 QMessageBox::information(this, "qconf", _("Unable to save configuration!"));
1536 return false;
1537 }
1538 return true;
1539}
1540
1541void ConfigMainWindow::saveConfigAs(void)
1542{
1543 QString s = QFileDialog::getSaveFileName(this, "", conf_get_configname());
1544 if (s.isNull())
1545 return;
1546 saveConfig();
1547}
1548
1549void ConfigMainWindow::searchConfig(void)
1550{
1551 if (!searchWindow)
1552 searchWindow = new ConfigSearchWindow(this, "search");
1553 searchWindow->show();
1554}
1555
1556void ConfigMainWindow::changeMenu(struct menu *menu)
1557{
1558 configList->setRootMenu(menu);
1559 if (configList->rootEntry->parent == &rootmenu)
1560 backAction->setEnabled(false);
1561 else
1562 backAction->setEnabled(true);
1563}
1564
1565void ConfigMainWindow::setMenuLink(struct menu *menu)
1566{
1567 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 }
1615}
1616
1617void ConfigMainWindow::listFocusChanged(void)
1618{
1619 if (menuList->mode == menuMode)
1620 configList->clearSelection();
1621}
1622
1623void ConfigMainWindow::goBack(void)
1624{
1625 ConfigItem* item, *oldSelection;
1626
1627 configList->setParentMenu();
1628 if (configList->rootEntry == &rootmenu)
1629 backAction->setEnabled(false);
1630
1631 if (menuList->selectedItems().count() == 0)
1632 return;
1633
1634 item = (ConfigItem*)menuList->selectedItems().first();
1635 oldSelection = item;
1636 while (item) {
1637 if (item->menu == configList->rootEntry) {
1638 oldSelection->setSelected(false);
1639 item->setSelected(true);
1640 break;
1641 }
1642 item = (ConfigItem*)item->parent();
1643 }
1644}
1645
1646void ConfigMainWindow::showSingleView(void)
1647{
1648 singleViewAction->setEnabled(false);
1649 singleViewAction->setChecked(true);
1650 splitViewAction->setEnabled(true);
1651 splitViewAction->setChecked(false);
1652 fullViewAction->setEnabled(true);
1653 fullViewAction->setChecked(false);
1654
1655 menuView->hide();
1656 menuList->setRootMenu(0);
1657 configList->mode = singleMode;
1658 if (configList->rootEntry == &rootmenu)
1659 configList->updateListAll();
1660 else
1661 configList->setRootMenu(&rootmenu);
1662 configList->setFocus();
1663}
1664
1665void ConfigMainWindow::showSplitView(void)
1666{
1667 singleViewAction->setEnabled(true);
1668 singleViewAction->setChecked(false);
1669 splitViewAction->setEnabled(false);
1670 splitViewAction->setChecked(true);
1671 fullViewAction->setEnabled(true);
1672 fullViewAction->setChecked(false);
1673
1674 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);
1684 menuView->show();
1685 menuList->setFocus();
1686}
1687
1688void ConfigMainWindow::showFullView(void)
1689{
1690 singleViewAction->setEnabled(true);
1691 singleViewAction->setChecked(false);
1692 splitViewAction->setEnabled(true);
1693 splitViewAction->setChecked(false);
1694 fullViewAction->setEnabled(false);
1695 fullViewAction->setChecked(true);
1696
1697 menuView->hide();
1698 menuList->setRootMenu(0);
1699 configList->mode = fullMode;
1700 if (configList->rootEntry == &rootmenu)
1701 configList->updateListAll();
1702 else
1703 configList->setRootMenu(&rootmenu);
1704 configList->setFocus();
1705}
1706
1707/*
1708 * ask for saving configuration before quitting
1709 * TODO ask only when something changed
1710 */
1711void ConfigMainWindow::closeEvent(QCloseEvent* e)
1712{
1713 if (!conf_get_changed()) {
1714 e->accept();
1715 return;
1716 }
1717 QMessageBox mb("qconf", _("Save configuration?"), QMessageBox::Warning,
1718 QMessageBox::Yes | QMessageBox::Default, QMessageBox::No, QMessageBox::Cancel | QMessageBox::Escape);
1719 mb.setButtonText(QMessageBox::Yes, _("&Save Changes"));
1720 mb.setButtonText(QMessageBox::No, _("&Discard Changes"));
1721 mb.setButtonText(QMessageBox::Cancel, _("Cancel Exit"));
1722 switch (mb.exec()) {
1723 case QMessageBox::Yes:
1724 if (saveConfig())
1725 e->accept();
1726 else
1727 e->ignore();
1728 break;
1729 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{
1740 static const QString str = _("Welcome to the qconf graphical configuration tool.\n\n"
1741 "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"
1750 "which you can then match by examining other options.\n\n");
1751
1752 QMessageBox::information(this, "qconf", str);
1753}
1754
1755void ConfigMainWindow::showAbout(void)
1756{
1757 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"
1759 "Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n");
1760
1761 QMessageBox::information(this, "qconf", str);
1762}
1763
1764void ConfigMainWindow::saveSettings(void)
1765{
1766 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());
1770
1771 QString entry;
1772 switch(configList->mode) {
1773 case singleMode :
1774 entry = "single";
1775 break;
1776
1777 case symbolMode :
1778 entry = "split";
1779 break;
1780
1781 case fullMode :
1782 entry = "full";
1783 break;
1784
1785 default:
1786 break;
1787 }
1788 configSettings->setValue("/listMode", entry);
1789
1790 configSettings->writeSizes("/split1", split1->sizes());
1791 configSettings->writeSizes("/split2", split2->sizes());
1792}
1793
1794void ConfigMainWindow::conf_changed(void)
1795{
1796 if (saveAction)
1797 saveAction->setEnabled(conf_get_changed());
1798}
1799
1800void 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{
1820 printf(_("%s [-s] <config>\n").toLatin1().constData(), progname);
1821 exit(0);
1822}
1823
1824int main(int ac, char** av)
1825{
1826 ConfigMainWindow* v;
1827 const char *name;
1828
1829 bindtextdomain(PACKAGE, LOCALEDIR);
1830 textdomain(PACKAGE);
1831
1832 progname = av[0];
1833 configApp = new QApplication(ac, av);
1834 if (ac > 1 && av[1][0] == '-') {
1835 switch (av[1][1]) {
1836 case 's':
1837 conf_set_message_callback(NULL);
1838 break;
1839 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
1854 configSettings = new ConfigSettings();
1855 configSettings->beginGroup("/kconfig/qconf");
1856 v = new ConfigMainWindow();
1857
1858 //zconfdump(stdout);
1859 configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1860 configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
1861 v->show();
1862 configApp->exec();
1863
1864 configSettings->endGroup();
1865 delete configSettings;
1866 delete v;
1867 delete configApp;
1868
1869 return 0;
1870}
1/*
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
4 */
5
6#include <qglobal.h>
7
8#if QT_VERSION < 0x040000
9#include <qmainwindow.h>
10#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>
31#include <qdesktopwidget.h>
32#include <qtoolbar.h>
33#include <qlayout.h>
34#include <qsplitter.h>
35#include <qlineedit.h>
36#include <qlabel.h>
37#include <qpushbutton.h>
38#include <qmenubar.h>
39#include <qmessagebox.h>
40#include <qregexp.h>
41#include <qevent.h>
42
43#include <stdlib.h>
44
45#include "lkc.h"
46#include "qconf.h"
47
48#include "qconf.moc"
49#include "images.c"
50
51#ifdef _
52# undef _
53# define _ qgettext
54#endif
55
56static QApplication *configApp;
57static ConfigSettings *configSettings;
58
59Q3Action *ConfigMainWindow::saveAction;
60
61static inline QString qgettext(const char* str)
62{
63 return QString::fromLocal8Bit(gettext(str));
64}
65
66static inline QString qgettext(const QString& str)
67{
68 return QString::fromLocal8Bit(gettext(str.latin1()));
69}
70
71/**
72 * Reads a list of integer values from the application settings.
73 */
74Q3ValueList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
75{
76 Q3ValueList<int> result;
77 QStringList entryList = readListEntry(key, ok);
78 QStringList::Iterator it;
79
80 for (it = entryList.begin(); it != entryList.end(); ++it)
81 result.push_back((*it).toInt());
82
83 return result;
84}
85
86/**
87 * Writes a list of integer values to the application settings.
88 */
89bool ConfigSettings::writeSizes(const QString& key, const Q3ValueList<int>& value)
90{
91 QStringList stringList;
92 Q3ValueList<int>::ConstIterator it;
93
94 for (it = value.begin(); it != value.end(); ++it)
95 stringList.push_back(QString::number(*it));
96 return writeEntry(key, stringList);
97}
98
99
100/*
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());
108 listView()->updateList(this);
109}
110
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;
132 prompt = _(menu_get_prompt(menu));
133
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
158 setText(nameColIdx, QString::fromLocal8Bit(sym->name));
159
160 type = sym_get_type(sym);
161 switch (type) {
162 case S_BOOLEAN:
163 case S_TRISTATE:
164 char ch;
165
166 if (!sym_is_changable(sym) && list->optMode == normalOpt) {
167 setPixmap(promptColIdx, 0);
168 setText(noColIdx, QString::null);
169 setText(modColIdx, QString::null);
170 setText(yesColIdx, QString::null);
171 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);
212
213 int i = list->mapIdx(dataColIdx);
214 if (i >= 0)
215 setRenameEnabled(i, TRUE);
216 setText(dataColIdx, data);
217 if (type == S_STRING)
218 prompt = QString("%1: %2").arg(prompt).arg(data);
219 else
220 prompt = QString("(%2) %1").arg(prompt).arg(data);
221 break;
222 }
223 if (!sym_has_value(sym) && visible)
224 prompt += _(" (NEW)");
225set_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
293ConfigLineEdit::ConfigLineEdit(ConfigView* parent)
294 : Parent(parent)
295{
296 connect(this, SIGNAL(lostFocus()), SLOT(hide()));
297}
298
299void ConfigLineEdit::show(ConfigItem* i)
300{
301 item = i;
302 if (sym_get_string_value(item->menu->sym))
303 setText(QString::fromLocal8Bit(sym_get_string_value(item->menu->sym)));
304 else
305 setText(QString::null);
306 Parent::show();
307 setFocus();
308}
309
310void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
311{
312 switch (e->key()) {
313 case Qt::Key_Escape:
314 break;
315 case Qt::Key_Return:
316 case Qt::Key_Enter:
317 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
329ConfigList::ConfigList(ConfigView* p, const char *name)
330 : Parent(p, name),
331 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),
335 showName(false), showRange(false), showData(false), optMode(normalOpt),
336 rootEntry(0), headerPopup(0)
337{
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
350 if (name) {
351 configSettings->beginGroup(name);
352 showName = configSettings->readBoolEntry("/showName", false);
353 showRange = configSettings->readBoolEntry("/showRange", false);
354 showData = configSettings->readBoolEntry("/showData", false);
355 optMode = (enum optionMode)configSettings->readNumEntry("/optionMode", false);
356 configSettings->endGroup();
357 connect(configApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
358 }
359
360 for (i = 0; i < colNr; i++)
361 colMap[i] = colRevMap[i] = -1;
362 addColumn(promptColIdx, _("Option"));
363
364 reinit();
365}
366
367bool 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
378void ConfigList::reinit(void)
379{
380 removeColumn(dataColIdx);
381 removeColumn(yesColIdx);
382 removeColumn(modColIdx);
383 removeColumn(noColIdx);
384 removeColumn(nameColIdx);
385
386 if (showName)
387 addColumn(nameColIdx, _("Name"));
388 if (showRange) {
389 addColumn(noColIdx, "N");
390 addColumn(modColIdx, "M");
391 addColumn(yesColIdx, "Y");
392 }
393 if (showData)
394 addColumn(dataColIdx, _("Value"));
395
396 updateListAll();
397}
398
399void 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);
406 configSettings->writeEntry("/optionMode", (int)optMode);
407 configSettings->endGroup();
408 }
409}
410
411ConfigItem* 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
423void 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
432 menu = item->menu;
433 emit menuChanged(menu);
434 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
445 if (!rootEntry) {
446 if (mode != listMode)
447 goto update;
448 Q3ListViewItemIterator it(this);
449 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 }
459
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
484void 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:
543 if (colMap[dataColIdx] >= 0)
544 item->startRename(colMap[dataColIdx]);
545 else
546 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());
564 ensureItemVisible(currentItem());
565}
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
577 Q3ListViewItemIterator it(this);
578 for (; (item = (ConfigItem*)it.current()); it++) {
579 if (item->menu == oldroot) {
580 setCurrentItem(item);
581 ensureItemVisible(item);
582 break;
583 }
584 }
585}
586
587/*
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);
630 if (!menuSkip(child)) {
631 if (!child->sym && !child->list && !child->prompt)
632 continue;
633 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
657void ConfigList::keyPressEvent(QKeyEvent* ev)
658{
659 Q3ListViewItem* i = currentItem();
660 ConfigItem* item;
661 struct menu *menu;
662 enum prop_type type;
663
664 if (ev->key() == Qt::Key_Escape && mode != fullMode && mode != listMode) {
665 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()) {
677 case Qt::Key_Return:
678 case Qt::Key_Enter:
679 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 }
692 case Qt::Key_Space:
693 changeValue(item);
694 break;
695 case Qt::Key_N:
696 setValue(item, no);
697 break;
698 case Qt::Key_M:
699 setValue(item, mod);
700 break;
701 case Qt::Key_Y:
702 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{
809 struct menu *menu = NULL;
810
811 Parent::focusInEvent(e);
812
813 ConfigItem* item = (ConfigItem *)currentItem();
814 if (item) {
815 setSelected(item, TRUE);
816 menu = item->menu;
817 }
818 emit gotFocus(menu);
819}
820
821void ConfigList::contextMenuEvent(QContextMenuEvent *e)
822{
823 if (e->y() <= header()->geometry().bottom()) {
824 if (!headerPopup) {
825 Q3Action *action;
826
827 headerPopup = new Q3PopupMenu(this);
828 action = new Q3Action(NULL, _("Show Name"), 0, this);
829 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);
836 action = new Q3Action(NULL, _("Show Range"), 0, this);
837 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);
844 action = new Q3Action(NULL, _("Show Data"), 0, this);
845 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
859ConfigView*ConfigView::viewList;
860QAction *ConfigView::showNormalAction;
861QAction *ConfigView::showAllAction;
862QAction *ConfigView::showPromptAction;
863
864ConfigView::ConfigView(QWidget* parent, const char *name)
865 : Parent(parent, name)
866{
867 list = new ConfigList(this, name);
868 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
887void ConfigView::setOptionMode(QAction *act)
888{
889 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();
897}
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{
928 Q3ListViewItemIterator it(this);
929
930 for (; it.current(); it++)
931 it.current()->setOpen(open);
932}
933
934void 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
950ConfigInfoView::ConfigInfoView(QWidget* parent, const char *name)
951 : Parent(parent, name), sym(0), _menu(0)
952{
953 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 }
968}
969
970void ConfigInfoView::setShowDebug(bool b)
971{
972 if (_showDebug != b) {
973 _showDebug = b;
974 if (_menu)
975 menuInfo();
976 else if (sym)
977 symbolInfo();
978 emit showDebugChanged(b);
979 }
980}
981
982void ConfigInfoView::setInfo(struct menu *m)
983{
984 if (_menu == m)
985 return;
986 _menu = m;
987 sym = NULL;
988 if (!_menu)
989 clear();
990 else
991 menuInfo();
992}
993
994void 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
1010void ConfigInfoView::menuInfo(void)
1011{
1012 struct symbol* sym;
1013 QString head, debug, help;
1014
1015 sym = _menu->sym;
1016 if (sym) {
1017 if (_menu->prompt) {
1018 head += "<big><b>";
1019 head += print_filter(_(_menu->prompt->text));
1020 head += "</b></big>";
1021 if (sym->name) {
1022 head += " (";
1023 if (showDebug())
1024 head += QString().sprintf("<a href=\"s%p\">", sym);
1025 head += print_filter(sym->name);
1026 if (showDebug())
1027 head += "</a>";
1028 head += ")";
1029 }
1030 } else if (sym->name) {
1031 head += "<big><b>";
1032 if (showDebug())
1033 head += QString().sprintf("<a href=\"s%p\">", sym);
1034 head += print_filter(sym->name);
1035 if (showDebug())
1036 head += "</a>";
1037 head += "</b></big>";
1038 }
1039 head += "<br><br>";
1040
1041 if (showDebug())
1042 debug = debug_info(sym);
1043
1044 struct gstr help_gstr = str_new();
1045 menu_get_ext_help(_menu, &help_gstr);
1046 help = print_filter(str_get(&help_gstr));
1047 str_free(&help_gstr);
1048 } else if (_menu->prompt) {
1049 head += "<big><b>";
1050 head += print_filter(_(_menu->prompt->text));
1051 head += "</b></big><br><br>";
1052 if (showDebug()) {
1053 if (_menu->prompt->visible.expr) {
1054 debug += " dep: ";
1055 expr_print(_menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
1056 debug += "<br><br>";
1057 }
1058 }
1059 }
1060 if (showDebug())
1061 debug += QString().sprintf("defined at %s:%d<br><br>", _menu->file->name, _menu->lineno);
1062
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:
1084 debug += QString().sprintf("prompt: <a href=\"m%p\">", prop->menu);
1085 debug += print_filter(_(prop->text));
1086 debug += "</a><br>";
1087 break;
1088 case P_DEFAULT:
1089 case P_SELECT:
1090 case P_RANGE:
1091 case P_ENV:
1092 debug += prop_get_type_name(prop->type);
1093 debug += ": ";
1094 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;
1104 default:
1105 debug += "unknown property: ";
1106 debug += prop_get_type_name(prop->type);
1107 debug += "<br>";
1108 }
1109 if (prop->visible.expr) {
1110 debug += " 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, "<");
1128 i += 4;
1129 break;
1130 case '>':
1131 res.replace(i, 1, ">");
1132 i += 4;
1133 break;
1134 case '&':
1135 res.replace(i, 1, "&");
1136 i += 5;
1137 break;
1138 case '"':
1139 res.replace(i, 1, """);
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
1151void ConfigInfoView::expr_print_help(void *data, struct symbol *sym, const char *str)
1152{
1153 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;
1162}
1163
1164Q3PopupMenu* ConfigInfoView::createPopupMenu(const QPoint& pos)
1165{
1166 Q3PopupMenu* popup = Parent::createPopupMenu(pos);
1167 Q3Action* action = new Q3Action(NULL, _("Show Debug Info"), 0, popup);
1168 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
1182ConfigSearchWindow::ConfigSearchWindow(ConfigMainWindow* parent, const char *name)
1183 : Parent(parent, name), result(NULL)
1184{
1185 setCaption("Search Config");
1186
1187 QVBoxLayout* layout1 = new QVBoxLayout(this, 11, 6);
1188 QHBoxLayout* layout2 = new QHBoxLayout(0, 0, 6);
1189 layout2->addWidget(new QLabel(_("Find:"), this));
1190 editField = new QLineEdit(this);
1191 connect(editField, SIGNAL(returnPressed()), SLOT(search()));
1192 layout2->addWidget(editField);
1193 searchButton = new QPushButton(_("Search"), this);
1194 searchButton->setAutoDefault(FALSE);
1195 connect(searchButton, SIGNAL(clicked()), SLOT(search()));
1196 layout2->addWidget(searchButton);
1197 layout1->addLayout(layout2);
1198
1199 split = new QSplitter(this);
1200 split->setOrientation(Qt::Vertical);
1201 list = new ConfigView(split, name);
1202 list->list->mode = listMode;
1203 info = new ConfigInfoView(split, name);
1204 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1205 info, SLOT(setInfo(struct menu *)));
1206 connect(list->list, SIGNAL(menuChanged(struct menu *)),
1207 parent, SLOT(setMenuLink(struct menu *)));
1208
1209 layout1->addWidget(split);
1210
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);
1224 Q3ValueList<int> sizes = configSettings->readSizes("/split", &ok);
1225 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 }
1243}
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();
1253 info->clear();
1254
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
1265/*
1266 * Construct the complete config widget
1267 */
1268ConfigMainWindow::ConfigMainWindow(void)
1269 : searchWindow(0)
1270{
1271 QMenuBar* menu;
1272 bool ok;
1273 int x, y, width, height;
1274 char title[256];
1275
1276 QDesktopWidget *d = configApp->desktop();
1277 snprintf(title, sizeof(title), "%s%s",
1278 rootmenu.prompt->text,
1279#if QT_VERSION < 0x040000
1280 " (Qt3)"
1281#else
1282 ""
1283#endif
1284 );
1285 setCaption(title);
1286
1287 width = configSettings->readNumEntry("/window width", d->width() - 64);
1288 height = configSettings->readNumEntry("/window height", d->height() - 64);
1289 resize(width, height);
1290 x = configSettings->readNumEntry("/window x", 0, &ok);
1291 if (ok)
1292 y = configSettings->readNumEntry("/window y", 0, &ok);
1293 if (ok)
1294 move(x, y);
1295
1296 split1 = new QSplitter(this);
1297 split1->setOrientation(Qt::Horizontal);
1298 setCentralWidget(split1);
1299
1300 menuView = new ConfigView(split1, "menu");
1301 menuList = menuView->list;
1302
1303 split2 = new QSplitter(split1);
1304 split2->setOrientation(Qt::Vertical);
1305
1306 // create config tree
1307 configView = new ConfigView(split2, "config");
1308 configList = configView->list;
1309
1310 helpText = new ConfigInfoView(split2, "help");
1311 helpText->setTextFormat(Qt::RichText);
1312
1313 setTabOrder(configList, helpText);
1314 configList->setFocus();
1315
1316 menu = menuBar();
1317 toolBar = new Q3ToolBar("Tools", this);
1318
1319 backAction = new Q3Action("Back", QPixmap(xpm_back), _("Back"), 0, this);
1320 connect(backAction, SIGNAL(activated()), SLOT(goBack()));
1321 backAction->setEnabled(FALSE);
1322 Q3Action *quitAction = new Q3Action("Quit", _("&Quit"), Qt::CTRL + Qt::Key_Q, this);
1323 connect(quitAction, SIGNAL(activated()), SLOT(close()));
1324 Q3Action *loadAction = new Q3Action("Load", QPixmap(xpm_load), _("&Load"), Qt::CTRL + Qt::Key_L, this);
1325 connect(loadAction, SIGNAL(activated()), SLOT(loadConfig()));
1326 saveAction = new Q3Action("Save", QPixmap(xpm_save), _("&Save"), Qt::CTRL + Qt::Key_S, this);
1327 connect(saveAction, SIGNAL(activated()), SLOT(saveConfig()));
1328 conf_set_changed_callback(conf_changed);
1329 // Set saveAction's initial state
1330 conf_changed();
1331 Q3Action *saveAsAction = new Q3Action("Save As...", _("Save &As..."), 0, this);
1332 connect(saveAsAction, SIGNAL(activated()), SLOT(saveConfigAs()));
1333 Q3Action *searchAction = new Q3Action("Find", _("&Find"), Qt::CTRL + Qt::Key_F, this);
1334 connect(searchAction, SIGNAL(activated()), SLOT(searchConfig()));
1335 Q3Action *singleViewAction = new Q3Action("Single View", QPixmap(xpm_single_view), _("Single View"), 0, this);
1336 connect(singleViewAction, SIGNAL(activated()), SLOT(showSingleView()));
1337 Q3Action *splitViewAction = new Q3Action("Split View", QPixmap(xpm_split_view), _("Split View"), 0, this);
1338 connect(splitViewAction, SIGNAL(activated()), SLOT(showSplitView()));
1339 Q3Action *fullViewAction = new Q3Action("Full View", QPixmap(xpm_tree_view), _("Full View"), 0, this);
1340 connect(fullViewAction, SIGNAL(activated()), SLOT(showFullView()));
1341
1342 Q3Action *showNameAction = new Q3Action(NULL, _("Show Name"), 0, this);
1343 showNameAction->setToggleAction(TRUE);
1344 connect(showNameAction, SIGNAL(toggled(bool)), configView, SLOT(setShowName(bool)));
1345 connect(configView, SIGNAL(showNameChanged(bool)), showNameAction, SLOT(setOn(bool)));
1346 showNameAction->setOn(configView->showName());
1347 Q3Action *showRangeAction = new Q3Action(NULL, _("Show Range"), 0, this);
1348 showRangeAction->setToggleAction(TRUE);
1349 connect(showRangeAction, SIGNAL(toggled(bool)), configView, SLOT(setShowRange(bool)));
1350 connect(configView, SIGNAL(showRangeChanged(bool)), showRangeAction, SLOT(setOn(bool)));
1351 showRangeAction->setOn(configList->showRange);
1352 Q3Action *showDataAction = new Q3Action(NULL, _("Show Data"), 0, this);
1353 showDataAction->setToggleAction(TRUE);
1354 connect(showDataAction, SIGNAL(toggled(bool)), configView, SLOT(setShowData(bool)));
1355 connect(configView, SIGNAL(showDataChanged(bool)), showDataAction, SLOT(setOn(bool)));
1356 showDataAction->setOn(configList->showData);
1357
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
1365#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
1374 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
1381 Q3Action *showDebugAction = new Q3Action(NULL, _("Show Debug Info"), 0, this);
1382 showDebugAction->setToggleAction(TRUE);
1383 connect(showDebugAction, SIGNAL(toggled(bool)), helpText, SLOT(setShowDebug(bool)));
1384 connect(helpText, SIGNAL(showDebugChanged(bool)), showDebugAction, SLOT(setOn(bool)));
1385 showDebugAction->setOn(helpText->showDebug());
1386
1387 Q3Action *showIntroAction = new Q3Action(NULL, _("Introduction"), 0, this);
1388 connect(showIntroAction, SIGNAL(activated()), SLOT(showIntro()));
1389 Q3Action *showAboutAction = new Q3Action(NULL, _("About"), 0, this);
1390 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
1403 Q3PopupMenu* config = new Q3PopupMenu(this);
1404 menu->insertItem(_("&File"), config);
1405 loadAction->addTo(config);
1406 saveAction->addTo(config);
1407 saveAsAction->addTo(config);
1408 config->insertSeparator();
1409 quitAction->addTo(config);
1410
1411 // create edit menu
1412 Q3PopupMenu* editMenu = new Q3PopupMenu(this);
1413 menu->insertItem(_("&Edit"), editMenu);
1414 searchAction->addTo(editMenu);
1415
1416 // create options menu
1417 Q3PopupMenu* optionMenu = new Q3PopupMenu(this);
1418 menu->insertItem(_("&Option"), optionMenu);
1419 showNameAction->addTo(optionMenu);
1420 showRangeAction->addTo(optionMenu);
1421 showDataAction->addTo(optionMenu);
1422 optionMenu->insertSeparator();
1423 optGroup->addTo(optionMenu);
1424 optionMenu->insertSeparator();
1425
1426 // create help menu
1427 Q3PopupMenu* helpMenu = new Q3PopupMenu(this);
1428 menu->insertSeparator();
1429 menu->insertItem(_("&Help"), helpMenu);
1430 showIntroAction->addTo(helpMenu);
1431 showAboutAction->addTo(helpMenu);
1432
1433 connect(configList, SIGNAL(menuChanged(struct menu *)),
1434 helpText, SLOT(setInfo(struct menu *)));
1435 connect(configList, SIGNAL(menuSelected(struct menu *)),
1436 SLOT(changeMenu(struct menu *)));
1437 connect(configList, SIGNAL(parentSelected()),
1438 SLOT(goBack()));
1439 connect(menuList, SIGNAL(menuChanged(struct menu *)),
1440 helpText, SLOT(setInfo(struct menu *)));
1441 connect(menuList, SIGNAL(menuSelected(struct menu *)),
1442 SLOT(changeMenu(struct menu *)));
1443
1444 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 *)),
1449 SLOT(listFocusChanged(void)));
1450 connect(helpText, SIGNAL(menuSelected(struct menu *)),
1451 SLOT(setMenuLink(struct menu *)));
1452
1453 QString listMode = configSettings->readEntry("/listMode", "symbol");
1454 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
1462 Q3ValueList<int> sizes = configSettings->readSizes("/split1", &ok);
1463 if (ok)
1464 split1->setSizes(sizes);
1465
1466 sizes = configSettings->readSizes("/split2", &ok);
1467 if (ok)
1468 split2->setSizes(sizes);
1469}
1470
1471void ConfigMainWindow::loadConfig(void)
1472{
1473 QString s = Q3FileDialog::getOpenFileName(conf_get_configname(), NULL, this);
1474 if (s.isNull())
1475 return;
1476 if (conf_read(QFile::encodeName(s)))
1477 QMessageBox::information(this, "qconf", _("Unable to load configuration!"));
1478 ConfigView::updateListAll();
1479}
1480
1481bool ConfigMainWindow::saveConfig(void)
1482{
1483 if (conf_write(NULL)) {
1484 QMessageBox::information(this, "qconf", _("Unable to save configuration!"));
1485 return false;
1486 }
1487 return true;
1488}
1489
1490void ConfigMainWindow::saveConfigAs(void)
1491{
1492 QString s = Q3FileDialog::getSaveFileName(conf_get_configname(), NULL, this);
1493 if (s.isNull())
1494 return;
1495 saveConfig();
1496}
1497
1498void ConfigMainWindow::searchConfig(void)
1499{
1500 if (!searchWindow)
1501 searchWindow = new ConfigSearchWindow(this, "search");
1502 searchWindow->show();
1503}
1504
1505void ConfigMainWindow::changeMenu(struct menu *menu)
1506{
1507 configList->setRootMenu(menu);
1508 if (configList->rootEntry->parent == &rootmenu)
1509 backAction->setEnabled(FALSE);
1510 else
1511 backAction->setEnabled(TRUE);
1512}
1513
1514void ConfigMainWindow::setMenuLink(struct menu *menu)
1515{
1516 struct menu *parent;
1517 ConfigList* list = NULL;
1518 ConfigItem* item;
1519
1520 if (configList->menuSkip(menu))
1521 return;
1522
1523 switch (configList->mode) {
1524 case singleMode:
1525 list = configList;
1526 parent = menu_get_parent_menu(menu);
1527 if (!parent)
1528 return;
1529 list->setRootMenu(parent);
1530 break;
1531 case symbolMode:
1532 if (menu->flags & MENU_ROOT) {
1533 configList->setRootMenu(menu);
1534 configList->clearSelection();
1535 list = menuList;
1536 } else {
1537 list = configList;
1538 parent = menu_get_parent_menu(menu->parent);
1539 if (!parent)
1540 return;
1541 item = menuList->findConfigItem(parent);
1542 if (item) {
1543 menuList->setSelected(item, TRUE);
1544 menuList->ensureItemVisible(item);
1545 }
1546 list->setRootMenu(parent);
1547 }
1548 break;
1549 case fullMode:
1550 list = configList;
1551 break;
1552 default:
1553 break;
1554 }
1555
1556 if (list) {
1557 item = list->findConfigItem(menu);
1558 if (item) {
1559 list->setSelected(item, TRUE);
1560 list->ensureItemVisible(item);
1561 list->setFocus();
1562 }
1563 }
1564}
1565
1566void ConfigMainWindow::listFocusChanged(void)
1567{
1568 if (menuList->mode == menuMode)
1569 configList->clearSelection();
1570}
1571
1572void ConfigMainWindow::goBack(void)
1573{
1574 ConfigItem* item;
1575
1576 configList->setParentMenu();
1577 if (configList->rootEntry == &rootmenu)
1578 backAction->setEnabled(FALSE);
1579 item = (ConfigItem*)menuList->selectedItem();
1580 while (item) {
1581 if (item->menu == configList->rootEntry) {
1582 menuList->setSelected(item, TRUE);
1583 break;
1584 }
1585 item = (ConfigItem*)item->parent();
1586 }
1587}
1588
1589void ConfigMainWindow::showSingleView(void)
1590{
1591 menuView->hide();
1592 menuList->setRootMenu(0);
1593 configList->mode = singleMode;
1594 if (configList->rootEntry == &rootmenu)
1595 configList->updateListAll();
1596 else
1597 configList->setRootMenu(&rootmenu);
1598 configList->setAllOpen(TRUE);
1599 configList->setFocus();
1600}
1601
1602void ConfigMainWindow::showSplitView(void)
1603{
1604 configList->mode = symbolMode;
1605 if (configList->rootEntry == &rootmenu)
1606 configList->updateListAll();
1607 else
1608 configList->setRootMenu(&rootmenu);
1609 configList->setAllOpen(TRUE);
1610 configApp->processEvents();
1611 menuList->mode = menuMode;
1612 menuList->setRootMenu(&rootmenu);
1613 menuList->setAllOpen(TRUE);
1614 menuView->show();
1615 menuList->setFocus();
1616}
1617
1618void ConfigMainWindow::showFullView(void)
1619{
1620 menuView->hide();
1621 menuList->setRootMenu(0);
1622 configList->mode = fullMode;
1623 if (configList->rootEntry == &rootmenu)
1624 configList->updateListAll();
1625 else
1626 configList->setRootMenu(&rootmenu);
1627 configList->setAllOpen(FALSE);
1628 configList->setFocus();
1629}
1630
1631/*
1632 * ask for saving configuration before quitting
1633 * TODO ask only when something changed
1634 */
1635void ConfigMainWindow::closeEvent(QCloseEvent* e)
1636{
1637 if (!conf_get_changed()) {
1638 e->accept();
1639 return;
1640 }
1641 QMessageBox mb("qconf", _("Save configuration?"), QMessageBox::Warning,
1642 QMessageBox::Yes | QMessageBox::Default, QMessageBox::No, QMessageBox::Cancel | QMessageBox::Escape);
1643 mb.setButtonText(QMessageBox::Yes, _("&Save Changes"));
1644 mb.setButtonText(QMessageBox::No, _("&Discard Changes"));
1645 mb.setButtonText(QMessageBox::Cancel, _("Cancel Exit"));
1646 switch (mb.exec()) {
1647 case QMessageBox::Yes:
1648 if (saveConfig())
1649 e->accept();
1650 else
1651 e->ignore();
1652 break;
1653 case QMessageBox::No:
1654 e->accept();
1655 break;
1656 case QMessageBox::Cancel:
1657 e->ignore();
1658 break;
1659 }
1660}
1661
1662void ConfigMainWindow::showIntro(void)
1663{
1664 static const QString str = _("Welcome to the qconf graphical configuration tool.\n\n"
1665 "For each option, a blank box indicates the feature is disabled, a check\n"
1666 "indicates it is enabled, and a dot indicates that it is to be compiled\n"
1667 "as a module. Clicking on the box will cycle through the three states.\n\n"
1668 "If you do not see an option (e.g., a device driver) that you believe\n"
1669 "should be present, try turning on Show All Options under the Options menu.\n"
1670 "Although there is no cross reference yet to help you figure out what other\n"
1671 "options must be enabled to support the option you are interested in, you can\n"
1672 "still view the help of a grayed-out option.\n\n"
1673 "Toggling Show Debug Info under the Options menu will show the dependencies,\n"
1674 "which you can then match by examining other options.\n\n");
1675
1676 QMessageBox::information(this, "qconf", str);
1677}
1678
1679void ConfigMainWindow::showAbout(void)
1680{
1681 static const QString str = _("qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n\n"
1682 "Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n");
1683
1684 QMessageBox::information(this, "qconf", str);
1685}
1686
1687void ConfigMainWindow::saveSettings(void)
1688{
1689 configSettings->writeEntry("/window x", pos().x());
1690 configSettings->writeEntry("/window y", pos().y());
1691 configSettings->writeEntry("/window width", size().width());
1692 configSettings->writeEntry("/window height", size().height());
1693
1694 QString entry;
1695 switch(configList->mode) {
1696 case singleMode :
1697 entry = "single";
1698 break;
1699
1700 case symbolMode :
1701 entry = "split";
1702 break;
1703
1704 case fullMode :
1705 entry = "full";
1706 break;
1707
1708 default:
1709 break;
1710 }
1711 configSettings->writeEntry("/listMode", entry);
1712
1713 configSettings->writeSizes("/split1", split1->sizes());
1714 configSettings->writeSizes("/split2", split2->sizes());
1715}
1716
1717void ConfigMainWindow::conf_changed(void)
1718{
1719 if (saveAction)
1720 saveAction->setEnabled(conf_get_changed());
1721}
1722
1723void fixup_rootmenu(struct menu *menu)
1724{
1725 struct menu *child;
1726 static int menu_cnt = 0;
1727
1728 menu->flags |= MENU_ROOT;
1729 for (child = menu->list; child; child = child->next) {
1730 if (child->prompt && child->prompt->type == P_MENU) {
1731 menu_cnt++;
1732 fixup_rootmenu(child);
1733 menu_cnt--;
1734 } else if (!menu_cnt)
1735 fixup_rootmenu(child);
1736 }
1737}
1738
1739static const char *progname;
1740
1741static void usage(void)
1742{
1743 printf(_("%s <config>\n"), progname);
1744 exit(0);
1745}
1746
1747int main(int ac, char** av)
1748{
1749 ConfigMainWindow* v;
1750 const char *name;
1751
1752 bindtextdomain(PACKAGE, LOCALEDIR);
1753 textdomain(PACKAGE);
1754
1755 progname = av[0];
1756 configApp = new QApplication(ac, av);
1757 if (ac > 1 && av[1][0] == '-') {
1758 switch (av[1][1]) {
1759 case 'h':
1760 case '?':
1761 usage();
1762 }
1763 name = av[2];
1764 } else
1765 name = av[1];
1766 if (!name)
1767 usage();
1768
1769 conf_parse(name);
1770 fixup_rootmenu(&rootmenu);
1771 conf_read(NULL);
1772 //zconfdump(stdout);
1773
1774 configSettings = new ConfigSettings();
1775 configSettings->beginGroup("/kconfig/qconf");
1776 v = new ConfigMainWindow();
1777
1778 //zconfdump(stdout);
1779 configApp->setMainWidget(v);
1780 configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1781 configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
1782 v->show();
1783 configApp->exec();
1784
1785 configSettings->endGroup();
1786 delete configSettings;
1787
1788 return 0;
1789}