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