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

source code of linux/scripts/kconfig/qconf.cc