Linux-2.6.12-rc2
[linux-2.6.git] / scripts / kconfig / qconf.cc
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 <qapplication.h>
7 #include <qmainwindow.h>
8 #include <qtoolbar.h>
9 #include <qvbox.h>
10 #include <qsplitter.h>
11 #include <qlistview.h>
12 #include <qtextview.h>
13 #include <qlineedit.h>
14 #include <qmenubar.h>
15 #include <qmessagebox.h>
16 #include <qaction.h>
17 #include <qheader.h>
18 #include <qfiledialog.h>
19 #include <qregexp.h>
20
21 #include <stdlib.h>
22
23 #include "lkc.h"
24 #include "qconf.h"
25
26 #include "qconf.moc"
27 #include "images.c"
28
29 static QApplication *configApp;
30
31 ConfigSettings::ConfigSettings()
32         : showAll(false), showName(false), showRange(false), showData(false)
33 {
34 }
35
36 #if QT_VERSION >= 300
37 /**
38  * Reads the list column settings from the application settings.
39  */
40 void ConfigSettings::readListSettings()
41 {
42         showAll = readBoolEntry("/kconfig/qconf/showAll", false);
43         showName = readBoolEntry("/kconfig/qconf/showName", false);
44         showRange = readBoolEntry("/kconfig/qconf/showRange", false);
45         showData = readBoolEntry("/kconfig/qconf/showData", false);
46 }
47
48 /**
49  * Reads a list of integer values from the application settings.
50  */
51 QValueList<int> ConfigSettings::readSizes(const QString& key, bool *ok)
52 {
53         QValueList<int> result;
54         QStringList entryList = readListEntry(key, ok);
55         if (ok) {
56                 QStringList::Iterator it;
57                 for (it = entryList.begin(); it != entryList.end(); ++it)
58                         result.push_back((*it).toInt());
59         }
60
61         return result;
62 }
63
64 /**
65  * Writes a list of integer values to the application settings.
66  */
67 bool ConfigSettings::writeSizes(const QString& key, const QValueList<int>& value)
68 {
69         QStringList stringList;
70         QValueList<int>::ConstIterator it;
71
72         for (it = value.begin(); it != value.end(); ++it)
73                 stringList.push_back(QString::number(*it));
74         return writeEntry(key, stringList);
75 }
76 #endif
77
78
79 /*
80  * update all the children of a menu entry
81  *   removes/adds the entries from the parent widget as necessary
82  *
83  * parent: either the menu list widget or a menu entry widget
84  * menu: entry to be updated
85  */
86 template <class P>
87 void ConfigList::updateMenuList(P* parent, struct menu* menu)
88 {
89         struct menu* child;
90         ConfigItem* item;
91         ConfigItem* last;
92         bool visible;
93         enum prop_type type;
94
95         if (!menu) {
96                 while ((item = parent->firstChild()))
97                         delete item;
98                 return;
99         }
100
101         last = parent->firstChild();
102         if (last && !last->goParent)
103                 last = 0;
104         for (child = menu->list; child; child = child->next) {
105                 item = last ? last->nextSibling() : parent->firstChild();
106                 type = child->prompt ? child->prompt->type : P_UNKNOWN;
107
108                 switch (mode) {
109                 case menuMode:
110                         if (!(child->flags & MENU_ROOT))
111                                 goto hide;
112                         break;
113                 case symbolMode:
114                         if (child->flags & MENU_ROOT)
115                                 goto hide;
116                         break;
117                 default:
118                         break;
119                 }
120
121                 visible = menu_is_visible(child);
122                 if (showAll || visible) {
123                         if (!item || item->menu != child)
124                                 item = new ConfigItem(parent, last, child, visible);
125                         else
126                                 item->testUpdateMenu(visible);
127
128                         if (mode == fullMode || mode == menuMode || type != P_MENU)
129                                 updateMenuList(item, child);
130                         else
131                                 updateMenuList(item, 0);
132                         last = item;
133                         continue;
134                 }
135         hide:
136                 if (item && item->menu == child) {
137                         last = parent->firstChild();
138                         if (last == item)
139                                 last = 0;
140                         else while (last->nextSibling() != item)
141                                 last = last->nextSibling();
142                         delete item;
143                 }
144         }
145 }
146
147 #if QT_VERSION >= 300
148 /*
149  * set the new data
150  * TODO check the value
151  */
152 void ConfigItem::okRename(int col)
153 {
154         Parent::okRename(col);
155         sym_set_string_value(menu->sym, text(dataColIdx).latin1());
156 }
157 #endif
158
159 /*
160  * update the displayed of a menu entry
161  */
162 void ConfigItem::updateMenu(void)
163 {
164         ConfigList* list;
165         struct symbol* sym;
166         struct property *prop;
167         QString prompt;
168         int type;
169         tristate expr;
170
171         list = listView();
172         if (goParent) {
173                 setPixmap(promptColIdx, list->menuBackPix);
174                 prompt = "..";
175                 goto set_prompt;
176         }
177
178         sym = menu->sym;
179         prop = menu->prompt;
180         prompt = menu_get_prompt(menu);
181
182         if (prop) switch (prop->type) {
183         case P_MENU:
184                 if (list->mode == singleMode || list->mode == symbolMode) {
185                         /* a menuconfig entry is displayed differently
186                          * depending whether it's at the view root or a child.
187                          */
188                         if (sym && list->rootEntry == menu)
189                                 break;
190                         setPixmap(promptColIdx, list->menuPix);
191                 } else {
192                         if (sym)
193                                 break;
194                         setPixmap(promptColIdx, 0);
195                 }
196                 goto set_prompt;
197         case P_COMMENT:
198                 setPixmap(promptColIdx, 0);
199                 goto set_prompt;
200         default:
201                 ;
202         }
203         if (!sym)
204                 goto set_prompt;
205
206         setText(nameColIdx, sym->name);
207
208         type = sym_get_type(sym);
209         switch (type) {
210         case S_BOOLEAN:
211         case S_TRISTATE:
212                 char ch;
213
214                 if (!sym_is_changable(sym) && !list->showAll) {
215                         setPixmap(promptColIdx, 0);
216                         setText(noColIdx, 0);
217                         setText(modColIdx, 0);
218                         setText(yesColIdx, 0);
219                         break;
220                 }
221                 expr = sym_get_tristate_value(sym);
222                 switch (expr) {
223                 case yes:
224                         if (sym_is_choice_value(sym) && type == S_BOOLEAN)
225                                 setPixmap(promptColIdx, list->choiceYesPix);
226                         else
227                                 setPixmap(promptColIdx, list->symbolYesPix);
228                         setText(yesColIdx, "Y");
229                         ch = 'Y';
230                         break;
231                 case mod:
232                         setPixmap(promptColIdx, list->symbolModPix);
233                         setText(modColIdx, "M");
234                         ch = 'M';
235                         break;
236                 default:
237                         if (sym_is_choice_value(sym) && type == S_BOOLEAN)
238                                 setPixmap(promptColIdx, list->choiceNoPix);
239                         else
240                                 setPixmap(promptColIdx, list->symbolNoPix);
241                         setText(noColIdx, "N");
242                         ch = 'N';
243                         break;
244                 }
245                 if (expr != no)
246                         setText(noColIdx, sym_tristate_within_range(sym, no) ? "_" : 0);
247                 if (expr != mod)
248                         setText(modColIdx, sym_tristate_within_range(sym, mod) ? "_" : 0);
249                 if (expr != yes)
250                         setText(yesColIdx, sym_tristate_within_range(sym, yes) ? "_" : 0);
251
252                 setText(dataColIdx, QChar(ch));
253                 break;
254         case S_INT:
255         case S_HEX:
256         case S_STRING:
257                 const char* data;
258
259                 data = sym_get_string_value(sym);
260 #if QT_VERSION >= 300
261                 int i = list->mapIdx(dataColIdx);
262                 if (i >= 0)
263                         setRenameEnabled(i, TRUE);
264 #endif
265                 setText(dataColIdx, data);
266                 if (type == S_STRING)
267                         prompt.sprintf("%s: %s", prompt.latin1(), data);
268                 else
269                         prompt.sprintf("(%s) %s", data, prompt.latin1());
270                 break;
271         }
272         if (!sym_has_value(sym) && visible)
273                 prompt += " (NEW)";
274 set_prompt:
275         setText(promptColIdx, prompt);
276 }
277
278 void ConfigItem::testUpdateMenu(bool v)
279 {
280         ConfigItem* i;
281
282         visible = v;
283         if (!menu)
284                 return;
285
286         sym_calc_value(menu->sym);
287         if (menu->flags & MENU_CHANGED) {
288                 /* the menu entry changed, so update all list items */
289                 menu->flags &= ~MENU_CHANGED;
290                 for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
291                         i->updateMenu();
292         } else if (listView()->updateAll)
293                 updateMenu();
294 }
295
296 void ConfigItem::paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align)
297 {
298         ConfigList* list = listView();
299
300         if (visible) {
301                 if (isSelected() && !list->hasFocus() && list->mode == menuMode)
302                         Parent::paintCell(p, list->inactivedColorGroup, column, width, align);
303                 else
304                         Parent::paintCell(p, cg, column, width, align);
305         } else
306                 Parent::paintCell(p, list->disabledColorGroup, column, width, align);
307 }
308
309 /*
310  * construct a menu entry
311  */
312 void ConfigItem::init(void)
313 {
314         if (menu) {
315                 ConfigList* list = listView();
316                 nextItem = (ConfigItem*)menu->data;
317                 menu->data = this;
318
319                 if (list->mode != fullMode)
320                         setOpen(TRUE);
321                 sym_calc_value(menu->sym);
322         }
323         updateMenu();
324 }
325
326 /*
327  * destruct a menu entry
328  */
329 ConfigItem::~ConfigItem(void)
330 {
331         if (menu) {
332                 ConfigItem** ip = (ConfigItem**)&menu->data;
333                 for (; *ip; ip = &(*ip)->nextItem) {
334                         if (*ip == this) {
335                                 *ip = nextItem;
336                                 break;
337                         }
338                 }
339         }
340 }
341
342 void ConfigLineEdit::show(ConfigItem* i)
343 {
344         item = i;
345         if (sym_get_string_value(item->menu->sym))
346                 setText(sym_get_string_value(item->menu->sym));
347         else
348                 setText(0);
349         Parent::show();
350         setFocus();
351 }
352
353 void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
354 {
355         switch (e->key()) {
356         case Key_Escape:
357                 break;
358         case Key_Return:
359         case Key_Enter:
360                 sym_set_string_value(item->menu->sym, text().latin1());
361                 parent()->updateList(item);
362                 break;
363         default:
364                 Parent::keyPressEvent(e);
365                 return;
366         }
367         e->accept();
368         parent()->list->setFocus();
369         hide();
370 }
371
372 ConfigList::ConfigList(ConfigView* p, ConfigMainWindow* cv, ConfigSettings* configSettings)
373         : Parent(p), cview(cv),
374           updateAll(false),
375           symbolYesPix(xpm_symbol_yes), symbolModPix(xpm_symbol_mod), symbolNoPix(xpm_symbol_no),
376           choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no),
377           menuPix(xpm_menu), menuInvPix(xpm_menu_inv), menuBackPix(xpm_menuback), voidPix(xpm_void),
378           showAll(false), showName(false), showRange(false), showData(false),
379           rootEntry(0)
380 {
381         int i;
382
383         setSorting(-1);
384         setRootIsDecorated(TRUE);
385         disabledColorGroup = palette().active();
386         disabledColorGroup.setColor(QColorGroup::Text, palette().disabled().text());
387         inactivedColorGroup = palette().active();
388         inactivedColorGroup.setColor(QColorGroup::Highlight, palette().disabled().highlight());
389
390         connect(this, SIGNAL(selectionChanged(void)),
391                 SLOT(updateSelection(void)));
392
393         if (configSettings) {
394                 showAll = configSettings->showAll;
395                 showName = configSettings->showName;
396                 showRange = configSettings->showRange;
397                 showData = configSettings->showData;
398         }
399
400         for (i = 0; i < colNr; i++)
401                 colMap[i] = colRevMap[i] = -1;
402         addColumn(promptColIdx, "Option");
403
404         reinit();
405 }
406
407 void ConfigList::reinit(void)
408 {
409         removeColumn(dataColIdx);
410         removeColumn(yesColIdx);
411         removeColumn(modColIdx);
412         removeColumn(noColIdx);
413         removeColumn(nameColIdx);
414
415         if (showName)
416                 addColumn(nameColIdx, "Name");
417         if (showRange) {
418                 addColumn(noColIdx, "N");
419                 addColumn(modColIdx, "M");
420                 addColumn(yesColIdx, "Y");
421         }
422         if (showData)
423                 addColumn(dataColIdx, "Value");
424
425         updateListAll();
426 }
427
428 void ConfigList::updateSelection(void)
429 {
430         struct menu *menu;
431         enum prop_type type;
432
433         ConfigItem* item = (ConfigItem*)selectedItem();
434         if (!item)
435                 return;
436
437         cview->setHelp(item);
438
439         menu = item->menu;
440         if (!menu)
441                 return;
442         type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
443         if (mode == menuMode && type == P_MENU)
444                 emit menuSelected(menu);
445 }
446
447 void ConfigList::updateList(ConfigItem* item)
448 {
449         ConfigItem* last = 0;
450
451         if (!rootEntry)
452                 goto update;
453
454         if (rootEntry != &rootmenu && (mode == singleMode ||
455             (mode == symbolMode && rootEntry->parent != &rootmenu))) {
456                 item = firstChild();
457                 if (!item)
458                         item = new ConfigItem(this, 0, true);
459                 last = item;
460         }
461         if ((mode == singleMode || (mode == symbolMode && !(rootEntry->flags & MENU_ROOT))) &&
462             rootEntry->sym && rootEntry->prompt) {
463                 item = last ? last->nextSibling() : firstChild();
464                 if (!item)
465                         item = new ConfigItem(this, last, rootEntry, true);
466                 else
467                         item->testUpdateMenu(true);
468
469                 updateMenuList(item, rootEntry);
470                 triggerUpdate();
471                 return;
472         }
473 update:
474         updateMenuList(this, rootEntry);
475         triggerUpdate();
476 }
477
478 void ConfigList::setAllOpen(bool open)
479 {
480         QListViewItemIterator it(this);
481
482         for (; it.current(); it++)
483                 it.current()->setOpen(open);
484 }
485
486 void ConfigList::setValue(ConfigItem* item, tristate val)
487 {
488         struct symbol* sym;
489         int type;
490         tristate oldval;
491
492         sym = item->menu ? item->menu->sym : 0;
493         if (!sym)
494                 return;
495
496         type = sym_get_type(sym);
497         switch (type) {
498         case S_BOOLEAN:
499         case S_TRISTATE:
500                 oldval = sym_get_tristate_value(sym);
501
502                 if (!sym_set_tristate_value(sym, val))
503                         return;
504                 if (oldval == no && item->menu->list)
505                         item->setOpen(TRUE);
506                 parent()->updateList(item);
507                 break;
508         }
509 }
510
511 void ConfigList::changeValue(ConfigItem* item)
512 {
513         struct symbol* sym;
514         struct menu* menu;
515         int type, oldexpr, newexpr;
516
517         menu = item->menu;
518         if (!menu)
519                 return;
520         sym = menu->sym;
521         if (!sym) {
522                 if (item->menu->list)
523                         item->setOpen(!item->isOpen());
524                 return;
525         }
526
527         type = sym_get_type(sym);
528         switch (type) {
529         case S_BOOLEAN:
530         case S_TRISTATE:
531                 oldexpr = sym_get_tristate_value(sym);
532                 newexpr = sym_toggle_tristate_value(sym);
533                 if (item->menu->list) {
534                         if (oldexpr == newexpr)
535                                 item->setOpen(!item->isOpen());
536                         else if (oldexpr == no)
537                                 item->setOpen(TRUE);
538                 }
539                 if (oldexpr != newexpr)
540                         parent()->updateList(item);
541                 break;
542         case S_INT:
543         case S_HEX:
544         case S_STRING:
545 #if QT_VERSION >= 300
546                 if (colMap[dataColIdx] >= 0)
547                         item->startRename(colMap[dataColIdx]);
548                 else
549 #endif
550                         parent()->lineEdit->show(item);
551                 break;
552         }
553 }
554
555 void ConfigList::setRootMenu(struct menu *menu)
556 {
557         enum prop_type type;
558
559         if (rootEntry == menu)
560                 return;
561         type = menu && menu->prompt ? menu->prompt->type : P_UNKNOWN;
562         if (type != P_MENU)
563                 return;
564         updateMenuList(this, 0);
565         rootEntry = menu;
566         updateListAll();
567         setSelected(currentItem(), hasFocus());
568 }
569
570 void ConfigList::setParentMenu(void)
571 {
572         ConfigItem* item;
573         struct menu *oldroot;
574
575         oldroot = rootEntry;
576         if (rootEntry == &rootmenu)
577                 return;
578         setRootMenu(menu_get_parent_menu(rootEntry->parent));
579
580         QListViewItemIterator it(this);
581         for (; (item = (ConfigItem*)it.current()); it++) {
582                 if (item->menu == oldroot) {
583                         setCurrentItem(item);
584                         ensureItemVisible(item);
585                         break;
586                 }
587         }
588 }
589
590 void ConfigList::keyPressEvent(QKeyEvent* ev)
591 {
592         QListViewItem* i = currentItem();
593         ConfigItem* item;
594         struct menu *menu;
595         enum prop_type type;
596
597         if (ev->key() == Key_Escape && mode != fullMode) {
598                 emit parentSelected();
599                 ev->accept();
600                 return;
601         }
602
603         if (!i) {
604                 Parent::keyPressEvent(ev);
605                 return;
606         }
607         item = (ConfigItem*)i;
608
609         switch (ev->key()) {
610         case Key_Return:
611         case Key_Enter:
612                 if (item->goParent) {
613                         emit parentSelected();
614                         break;
615                 }
616                 menu = item->menu;
617                 if (!menu)
618                         break;
619                 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
620                 if (type == P_MENU && rootEntry != menu &&
621                     mode != fullMode && mode != menuMode) {
622                         emit menuSelected(menu);
623                         break;
624                 }
625         case Key_Space:
626                 changeValue(item);
627                 break;
628         case Key_N:
629                 setValue(item, no);
630                 break;
631         case Key_M:
632                 setValue(item, mod);
633                 break;
634         case Key_Y:
635                 setValue(item, yes);
636                 break;
637         default:
638                 Parent::keyPressEvent(ev);
639                 return;
640         }
641         ev->accept();
642 }
643
644 void ConfigList::contentsMousePressEvent(QMouseEvent* e)
645 {
646         //QPoint p(contentsToViewport(e->pos()));
647         //printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
648         Parent::contentsMousePressEvent(e);
649 }
650
651 void ConfigList::contentsMouseReleaseEvent(QMouseEvent* e)
652 {
653         QPoint p(contentsToViewport(e->pos()));
654         ConfigItem* item = (ConfigItem*)itemAt(p);
655         struct menu *menu;
656         enum prop_type ptype;
657         const QPixmap* pm;
658         int idx, x;
659
660         if (!item)
661                 goto skip;
662
663         menu = item->menu;
664         x = header()->offset() + p.x();
665         idx = colRevMap[header()->sectionAt(x)];
666         switch (idx) {
667         case promptColIdx:
668                 pm = item->pixmap(promptColIdx);
669                 if (pm) {
670                         int off = header()->sectionPos(0) + itemMargin() +
671                                 treeStepSize() * (item->depth() + (rootIsDecorated() ? 1 : 0));
672                         if (x >= off && x < off + pm->width()) {
673                                 if (item->goParent) {
674                                         emit parentSelected();
675                                         break;
676                                 } else if (!menu)
677                                         break;
678                                 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
679                                 if (ptype == P_MENU && rootEntry != menu &&
680                                     mode != fullMode && mode != menuMode)
681                                         emit menuSelected(menu);
682                                 else
683                                         changeValue(item);
684                         }
685                 }
686                 break;
687         case noColIdx:
688                 setValue(item, no);
689                 break;
690         case modColIdx:
691                 setValue(item, mod);
692                 break;
693         case yesColIdx:
694                 setValue(item, yes);
695                 break;
696         case dataColIdx:
697                 changeValue(item);
698                 break;
699         }
700
701 skip:
702         //printf("contentsMouseReleaseEvent: %d,%d\n", p.x(), p.y());
703         Parent::contentsMouseReleaseEvent(e);
704 }
705
706 void ConfigList::contentsMouseMoveEvent(QMouseEvent* e)
707 {
708         //QPoint p(contentsToViewport(e->pos()));
709         //printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
710         Parent::contentsMouseMoveEvent(e);
711 }
712
713 void ConfigList::contentsMouseDoubleClickEvent(QMouseEvent* e)
714 {
715         QPoint p(contentsToViewport(e->pos()));
716         ConfigItem* item = (ConfigItem*)itemAt(p);
717         struct menu *menu;
718         enum prop_type ptype;
719
720         if (!item)
721                 goto skip;
722         if (item->goParent) {
723                 emit parentSelected();
724                 goto skip;
725         }
726         menu = item->menu;
727         if (!menu)
728                 goto skip;
729         ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
730         if (ptype == P_MENU && (mode == singleMode || mode == symbolMode))
731                 emit menuSelected(menu);
732         else if (menu->sym)
733                 changeValue(item);
734
735 skip:
736         //printf("contentsMouseDoubleClickEvent: %d,%d\n", p.x(), p.y());
737         Parent::contentsMouseDoubleClickEvent(e);
738 }
739
740 void ConfigList::focusInEvent(QFocusEvent *e)
741 {
742         Parent::focusInEvent(e);
743
744         QListViewItem* item = currentItem();
745         if (!item)
746                 return;
747
748         setSelected(item, TRUE);
749         emit gotFocus();
750 }
751
752 ConfigView* ConfigView::viewList;
753
754 ConfigView::ConfigView(QWidget* parent, ConfigMainWindow* cview,
755                        ConfigSettings *configSettings)
756         : Parent(parent)
757 {
758         list = new ConfigList(this, cview, configSettings);
759         lineEdit = new ConfigLineEdit(this);
760         lineEdit->hide();
761
762         this->nextView = viewList;
763         viewList = this;
764 }
765
766 ConfigView::~ConfigView(void)
767 {
768         ConfigView** vp;
769
770         for (vp = &viewList; *vp; vp = &(*vp)->nextView) {
771                 if (*vp == this) {
772                         *vp = nextView;
773                         break;
774                 }
775         }
776 }
777
778 void ConfigView::updateList(ConfigItem* item)
779 {
780         ConfigView* v;
781
782         for (v = viewList; v; v = v->nextView)
783                 v->list->updateList(item);
784 }
785
786 void ConfigView::updateListAll(void)
787 {
788         ConfigView* v;
789
790         for (v = viewList; v; v = v->nextView)
791                 v->list->updateListAll();
792 }
793
794 /*
795  * Construct the complete config widget
796  */
797 ConfigMainWindow::ConfigMainWindow(void)
798 {
799         QMenuBar* menu;
800         bool ok;
801         int x, y, width, height;
802
803         QWidget *d = configApp->desktop();
804
805         ConfigSettings* configSettings = new ConfigSettings();
806 #if QT_VERSION >= 300
807         width = configSettings->readNumEntry("/kconfig/qconf/window width", d->width() - 64);
808         height = configSettings->readNumEntry("/kconfig/qconf/window height", d->height() - 64);
809         resize(width, height);
810         x = configSettings->readNumEntry("/kconfig/qconf/window x", 0, &ok);
811         if (ok)
812                 y = configSettings->readNumEntry("/kconfig/qconf/window y", 0, &ok);
813         if (ok)
814                 move(x, y);
815         showDebug = configSettings->readBoolEntry("/kconfig/qconf/showDebug", false);
816
817         // read list settings into configSettings, will be used later for ConfigList setup
818         configSettings->readListSettings();
819 #else
820         width = d->width() - 64;
821         height = d->height() - 64;
822         resize(width, height);
823         showDebug = false;
824 #endif
825
826         split1 = new QSplitter(this);
827         split1->setOrientation(QSplitter::Horizontal);
828         setCentralWidget(split1);
829
830         menuView = new ConfigView(split1, this, configSettings);
831         menuList = menuView->list;
832
833         split2 = new QSplitter(split1);
834         split2->setOrientation(QSplitter::Vertical);
835
836         // create config tree
837         configView = new ConfigView(split2, this, configSettings);
838         configList = configView->list;
839
840         helpText = new QTextView(split2);
841         helpText->setTextFormat(Qt::RichText);
842
843         setTabOrder(configList, helpText);
844         configList->setFocus();
845
846         menu = menuBar();
847         toolBar = new QToolBar("Tools", this);
848
849         backAction = new QAction("Back", QPixmap(xpm_back), "Back", 0, this);
850           connect(backAction, SIGNAL(activated()), SLOT(goBack()));
851           backAction->setEnabled(FALSE);
852         QAction *quitAction = new QAction("Quit", "&Quit", CTRL+Key_Q, this);
853           connect(quitAction, SIGNAL(activated()), SLOT(close()));
854         QAction *loadAction = new QAction("Load", QPixmap(xpm_load), "&Load", CTRL+Key_L, this);
855           connect(loadAction, SIGNAL(activated()), SLOT(loadConfig()));
856         QAction *saveAction = new QAction("Save", QPixmap(xpm_save), "&Save", CTRL+Key_S, this);
857           connect(saveAction, SIGNAL(activated()), SLOT(saveConfig()));
858         QAction *saveAsAction = new QAction("Save As...", "Save &As...", 0, this);
859           connect(saveAsAction, SIGNAL(activated()), SLOT(saveConfigAs()));
860         QAction *singleViewAction = new QAction("Single View", QPixmap(xpm_single_view), "Split View", 0, this);
861           connect(singleViewAction, SIGNAL(activated()), SLOT(showSingleView()));
862         QAction *splitViewAction = new QAction("Split View", QPixmap(xpm_split_view), "Split View", 0, this);
863           connect(splitViewAction, SIGNAL(activated()), SLOT(showSplitView()));
864         QAction *fullViewAction = new QAction("Full View", QPixmap(xpm_tree_view), "Full View", 0, this);
865           connect(fullViewAction, SIGNAL(activated()), SLOT(showFullView()));
866
867         QAction *showNameAction = new QAction(NULL, "Show Name", 0, this);
868           showNameAction->setToggleAction(TRUE);
869           showNameAction->setOn(configList->showName);
870           connect(showNameAction, SIGNAL(toggled(bool)), SLOT(setShowName(bool)));
871         QAction *showRangeAction = new QAction(NULL, "Show Range", 0, this);
872           showRangeAction->setToggleAction(TRUE);
873           showRangeAction->setOn(configList->showRange);
874           connect(showRangeAction, SIGNAL(toggled(bool)), SLOT(setShowRange(bool)));
875         QAction *showDataAction = new QAction(NULL, "Show Data", 0, this);
876           showDataAction->setToggleAction(TRUE);
877           showDataAction->setOn(configList->showData);
878           connect(showDataAction, SIGNAL(toggled(bool)), SLOT(setShowData(bool)));
879         QAction *showAllAction = new QAction(NULL, "Show All Options", 0, this);
880           showAllAction->setToggleAction(TRUE);
881           showAllAction->setOn(configList->showAll);
882           connect(showAllAction, SIGNAL(toggled(bool)), SLOT(setShowAll(bool)));
883         QAction *showDebugAction = new QAction(NULL, "Show Debug Info", 0, this);
884           showDebugAction->setToggleAction(TRUE);
885           showDebugAction->setOn(showDebug);
886           connect(showDebugAction, SIGNAL(toggled(bool)), SLOT(setShowDebug(bool)));
887
888         QAction *showIntroAction = new QAction(NULL, "Introduction", 0, this);
889           connect(showIntroAction, SIGNAL(activated()), SLOT(showIntro()));
890         QAction *showAboutAction = new QAction(NULL, "About", 0, this);
891           connect(showAboutAction, SIGNAL(activated()), SLOT(showAbout()));
892
893         // init tool bar
894         backAction->addTo(toolBar);
895         toolBar->addSeparator();
896         loadAction->addTo(toolBar);
897         saveAction->addTo(toolBar);
898         toolBar->addSeparator();
899         singleViewAction->addTo(toolBar);
900         splitViewAction->addTo(toolBar);
901         fullViewAction->addTo(toolBar);
902
903         // create config menu
904         QPopupMenu* config = new QPopupMenu(this);
905         menu->insertItem("&File", config);
906         loadAction->addTo(config);
907         saveAction->addTo(config);
908         saveAsAction->addTo(config);
909         config->insertSeparator();
910         quitAction->addTo(config);
911
912         // create options menu
913         QPopupMenu* optionMenu = new QPopupMenu(this);
914         menu->insertItem("&Option", optionMenu);
915         showNameAction->addTo(optionMenu);
916         showRangeAction->addTo(optionMenu);
917         showDataAction->addTo(optionMenu);
918         optionMenu->insertSeparator();
919         showAllAction->addTo(optionMenu);
920         showDebugAction->addTo(optionMenu);
921
922         // create help menu
923         QPopupMenu* helpMenu = new QPopupMenu(this);
924         menu->insertSeparator();
925         menu->insertItem("&Help", helpMenu);
926         showIntroAction->addTo(helpMenu);
927         showAboutAction->addTo(helpMenu);
928
929         connect(configList, SIGNAL(menuSelected(struct menu *)),
930                 SLOT(changeMenu(struct menu *)));
931         connect(configList, SIGNAL(parentSelected()),
932                 SLOT(goBack()));
933         connect(menuList, SIGNAL(menuSelected(struct menu *)),
934                 SLOT(changeMenu(struct menu *)));
935
936         connect(configList, SIGNAL(gotFocus(void)),
937                 SLOT(listFocusChanged(void)));
938         connect(menuList, SIGNAL(gotFocus(void)),
939                 SLOT(listFocusChanged(void)));
940
941 #if QT_VERSION >= 300
942         QString listMode = configSettings->readEntry("/kconfig/qconf/listMode", "symbol");
943         if (listMode == "single")
944                 showSingleView();
945         else if (listMode == "full")
946                 showFullView();
947         else /*if (listMode == "split")*/
948                 showSplitView();
949
950         // UI setup done, restore splitter positions
951         QValueList<int> sizes = configSettings->readSizes("/kconfig/qconf/split1", &ok);
952         if (ok)
953                 split1->setSizes(sizes);
954
955         sizes = configSettings->readSizes("/kconfig/qconf/split2", &ok);
956         if (ok)
957                 split2->setSizes(sizes);
958 #else
959         showSplitView();
960 #endif
961         delete configSettings;
962 }
963
964 static QString print_filter(const char *str)
965 {
966         QRegExp re("[<>&\"\\n]");
967         QString res = str;
968         for (int i = 0; (i = res.find(re, i)) >= 0;) {
969                 switch (res[i].latin1()) {
970                 case '<':
971                         res.replace(i, 1, "&lt;");
972                         i += 4;
973                         break;
974                 case '>':
975                         res.replace(i, 1, "&gt;");
976                         i += 4;
977                         break;
978                 case '&':
979                         res.replace(i, 1, "&amp;");
980                         i += 5;
981                         break;
982                 case '"':
983                         res.replace(i, 1, "&quot;");
984                         i += 6;
985                         break;
986                 case '\n':
987                         res.replace(i, 1, "<br>");
988                         i += 4;
989                         break;
990                 }
991         }
992         return res;
993 }
994
995 static void expr_print_help(void *data, const char *str)
996 {
997         ((QString*)data)->append(print_filter(str));
998 }
999
1000 /*
1001  * display a new help entry as soon as a new menu entry is selected
1002  */
1003 void ConfigMainWindow::setHelp(QListViewItem* item)
1004 {
1005         struct symbol* sym;
1006         struct menu* menu = 0;
1007
1008         configList->parent()->lineEdit->hide();
1009         if (item)
1010                 menu = ((ConfigItem*)item)->menu;
1011         if (!menu) {
1012                 helpText->setText(NULL);
1013                 return;
1014         }
1015
1016         QString head, debug, help;
1017         menu = ((ConfigItem*)item)->menu;
1018         sym = menu->sym;
1019         if (sym) {
1020                 if (menu->prompt) {
1021                         head += "<big><b>";
1022                         head += print_filter(menu->prompt->text);
1023                         head += "</b></big>";
1024                         if (sym->name) {
1025                                 head += " (";
1026                                 head += print_filter(sym->name);
1027                                 head += ")";
1028                         }
1029                 } else if (sym->name) {
1030                         head += "<big><b>";
1031                         head += print_filter(sym->name);
1032                         head += "</b></big>";
1033                 }
1034                 head += "<br><br>";
1035
1036                 if (showDebug) {
1037                         debug += "type: ";
1038                         debug += print_filter(sym_type_name(sym->type));
1039                         if (sym_is_choice(sym))
1040                                 debug += " (choice)";
1041                         debug += "<br>";
1042                         if (sym->rev_dep.expr) {
1043                                 debug += "reverse dep: ";
1044                                 expr_print(sym->rev_dep.expr, expr_print_help, &debug, E_NONE);
1045                                 debug += "<br>";
1046                         }
1047                         for (struct property *prop = sym->prop; prop; prop = prop->next) {
1048                                 switch (prop->type) {
1049                                 case P_PROMPT:
1050                                 case P_MENU:
1051                                         debug += "prompt: ";
1052                                         debug += print_filter(prop->text);
1053                                         debug += "<br>";
1054                                         break;
1055                                 case P_DEFAULT:
1056                                         debug += "default: ";
1057                                         expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1058                                         debug += "<br>";
1059                                         break;
1060                                 case P_CHOICE:
1061                                         if (sym_is_choice(sym)) {
1062                                                 debug += "choice: ";
1063                                                 expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1064                                                 debug += "<br>";
1065                                         }
1066                                         break;
1067                                 case P_SELECT:
1068                                         debug += "select: ";
1069                                         expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1070                                         debug += "<br>";
1071                                         break;
1072                                 case P_RANGE:
1073                                         debug += "range: ";
1074                                         expr_print(prop->expr, expr_print_help, &debug, E_NONE);
1075                                         debug += "<br>";
1076                                         break;
1077                                 default:
1078                                         debug += "unknown property: ";
1079                                         debug += prop_get_type_name(prop->type);
1080                                         debug += "<br>";
1081                                 }
1082                                 if (prop->visible.expr) {
1083                                         debug += "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
1084                                         expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
1085                                         debug += "<br>";
1086                                 }
1087                         }
1088                         debug += "<br>";
1089                 }
1090
1091                 help = print_filter(sym->help);
1092         } else if (menu->prompt) {
1093                 head += "<big><b>";
1094                 head += print_filter(menu->prompt->text);
1095                 head += "</b></big><br><br>";
1096                 if (showDebug) {
1097                         if (menu->prompt->visible.expr) {
1098                                 debug += "&nbsp;&nbsp;dep: ";
1099                                 expr_print(menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
1100                                 debug += "<br><br>";
1101                         }
1102                 }
1103         }
1104         if (showDebug)
1105                 debug += QString().sprintf("defined at %s:%d<br><br>", menu->file->name, menu->lineno);
1106         helpText->setText(head + debug + help);
1107 }
1108
1109 void ConfigMainWindow::loadConfig(void)
1110 {
1111         QString s = QFileDialog::getOpenFileName(".config", NULL, this);
1112         if (s.isNull())
1113                 return;
1114         if (conf_read(s.latin1()))
1115                 QMessageBox::information(this, "qconf", "Unable to load configuration!");
1116         ConfigView::updateListAll();
1117 }
1118
1119 void ConfigMainWindow::saveConfig(void)
1120 {
1121         if (conf_write(NULL))
1122                 QMessageBox::information(this, "qconf", "Unable to save configuration!");
1123 }
1124
1125 void ConfigMainWindow::saveConfigAs(void)
1126 {
1127         QString s = QFileDialog::getSaveFileName(".config", NULL, this);
1128         if (s.isNull())
1129                 return;
1130         if (conf_write(s.latin1()))
1131                 QMessageBox::information(this, "qconf", "Unable to save configuration!");
1132 }
1133
1134 void ConfigMainWindow::changeMenu(struct menu *menu)
1135 {
1136         configList->setRootMenu(menu);
1137         backAction->setEnabled(TRUE);
1138 }
1139
1140 void ConfigMainWindow::listFocusChanged(void)
1141 {
1142         if (menuList->hasFocus()) {
1143                 if (menuList->mode == menuMode)
1144                         configList->clearSelection();
1145                 setHelp(menuList->selectedItem());
1146         } else if (configList->hasFocus()) {
1147                 setHelp(configList->selectedItem());
1148         }
1149 }
1150
1151 void ConfigMainWindow::goBack(void)
1152 {
1153         ConfigItem* item;
1154
1155         configList->setParentMenu();
1156         if (configList->rootEntry == &rootmenu)
1157                 backAction->setEnabled(FALSE);
1158         item = (ConfigItem*)menuList->selectedItem();
1159         while (item) {
1160                 if (item->menu == configList->rootEntry) {
1161                         menuList->setSelected(item, TRUE);
1162                         break;
1163                 }
1164                 item = (ConfigItem*)item->parent();
1165         }
1166 }
1167
1168 void ConfigMainWindow::showSingleView(void)
1169 {
1170         menuView->hide();
1171         menuList->setRootMenu(0);
1172         configList->mode = singleMode;
1173         if (configList->rootEntry == &rootmenu)
1174                 configList->updateListAll();
1175         else
1176                 configList->setRootMenu(&rootmenu);
1177         configList->setAllOpen(TRUE);
1178         configList->setFocus();
1179 }
1180
1181 void ConfigMainWindow::showSplitView(void)
1182 {
1183         configList->mode = symbolMode;
1184         if (configList->rootEntry == &rootmenu)
1185                 configList->updateListAll();
1186         else
1187                 configList->setRootMenu(&rootmenu);
1188         configList->setAllOpen(TRUE);
1189         configApp->processEvents();
1190         menuList->mode = menuMode;
1191         menuList->setRootMenu(&rootmenu);
1192         menuList->setAllOpen(TRUE);
1193         menuView->show();
1194         menuList->setFocus();
1195 }
1196
1197 void ConfigMainWindow::showFullView(void)
1198 {
1199         menuView->hide();
1200         menuList->setRootMenu(0);
1201         configList->mode = fullMode;
1202         if (configList->rootEntry == &rootmenu)
1203                 configList->updateListAll();
1204         else
1205                 configList->setRootMenu(&rootmenu);
1206         configList->setAllOpen(FALSE);
1207         configList->setFocus();
1208 }
1209
1210 void ConfigMainWindow::setShowAll(bool b)
1211 {
1212         if (configList->showAll == b)
1213                 return;
1214         configList->showAll = b;
1215         configList->updateListAll();
1216         menuList->showAll = b;
1217         menuList->updateListAll();
1218 }
1219
1220 void ConfigMainWindow::setShowDebug(bool b)
1221 {
1222         if (showDebug == b)
1223                 return;
1224         showDebug = b;
1225 }
1226
1227 void ConfigMainWindow::setShowName(bool b)
1228 {
1229         if (configList->showName == b)
1230                 return;
1231         configList->showName = b;
1232         configList->reinit();
1233         menuList->showName = b;
1234         menuList->reinit();
1235 }
1236
1237 void ConfigMainWindow::setShowRange(bool b)
1238 {
1239         if (configList->showRange == b)
1240                 return;
1241         configList->showRange = b;
1242         configList->reinit();
1243         menuList->showRange = b;
1244         menuList->reinit();
1245 }
1246
1247 void ConfigMainWindow::setShowData(bool b)
1248 {
1249         if (configList->showData == b)
1250                 return;
1251         configList->showData = b;
1252         configList->reinit();
1253         menuList->showData = b;
1254         menuList->reinit();
1255 }
1256
1257 /*
1258  * ask for saving configuration before quitting
1259  * TODO ask only when something changed
1260  */
1261 void ConfigMainWindow::closeEvent(QCloseEvent* e)
1262 {
1263         if (!sym_change_count) {
1264                 e->accept();
1265                 return;
1266         }
1267         QMessageBox mb("qconf", "Save configuration?", QMessageBox::Warning,
1268                         QMessageBox::Yes | QMessageBox::Default, QMessageBox::No, QMessageBox::Cancel | QMessageBox::Escape);
1269         mb.setButtonText(QMessageBox::Yes, "&Save Changes");
1270         mb.setButtonText(QMessageBox::No, "&Discard Changes");
1271         mb.setButtonText(QMessageBox::Cancel, "Cancel Exit");
1272         switch (mb.exec()) {
1273         case QMessageBox::Yes:
1274                 conf_write(NULL);
1275         case QMessageBox::No:
1276                 e->accept();
1277                 break;
1278         case QMessageBox::Cancel:
1279                 e->ignore();
1280                 break;
1281         }
1282 }
1283
1284 void ConfigMainWindow::showIntro(void)
1285 {
1286         static char str[] = "Welcome to the qconf graphical kernel configuration tool for Linux.\n\n"
1287                 "For each option, a blank box indicates the feature is disabled, a check\n"
1288                 "indicates it is enabled, and a dot indicates that it is to be compiled\n"
1289                 "as a module.  Clicking on the box will cycle through the three states.\n\n"
1290                 "If you do not see an option (e.g., a device driver) that you believe\n"
1291                 "should be present, try turning on Show All Options under the Options menu.\n"
1292                 "Although there is no cross reference yet to help you figure out what other\n"
1293                 "options must be enabled to support the option you are interested in, you can\n"
1294                 "still view the help of a grayed-out option.\n\n"
1295                 "Toggling Show Debug Info under the Options menu will show the dependencies,\n"
1296                 "which you can then match by examining other options.\n\n";
1297
1298         QMessageBox::information(this, "qconf", str);
1299 }
1300
1301 void ConfigMainWindow::showAbout(void)
1302 {
1303         static char str[] = "qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n\n"
1304                 "Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n";
1305
1306         QMessageBox::information(this, "qconf", str);
1307 }
1308
1309 void ConfigMainWindow::saveSettings(void)
1310 {
1311 #if QT_VERSION >= 300
1312         ConfigSettings *configSettings = new ConfigSettings;
1313         configSettings->writeEntry("/kconfig/qconf/window x", pos().x());
1314         configSettings->writeEntry("/kconfig/qconf/window y", pos().y());
1315         configSettings->writeEntry("/kconfig/qconf/window width", size().width());
1316         configSettings->writeEntry("/kconfig/qconf/window height", size().height());
1317         configSettings->writeEntry("/kconfig/qconf/showName", configList->showName);
1318         configSettings->writeEntry("/kconfig/qconf/showRange", configList->showRange);
1319         configSettings->writeEntry("/kconfig/qconf/showData", configList->showData);
1320         configSettings->writeEntry("/kconfig/qconf/showAll", configList->showAll);
1321         configSettings->writeEntry("/kconfig/qconf/showDebug", showDebug);
1322
1323         QString entry;
1324         switch(configList->mode) {
1325         case singleMode :
1326                 entry = "single";
1327                 break;
1328
1329         case symbolMode :
1330                 entry = "split";
1331                 break;
1332
1333         case fullMode :
1334                 entry = "full";
1335                 break;
1336         }
1337         configSettings->writeEntry("/kconfig/qconf/listMode", entry);
1338
1339         configSettings->writeSizes("/kconfig/qconf/split1", split1->sizes());
1340         configSettings->writeSizes("/kconfig/qconf/split2", split2->sizes());
1341
1342         delete configSettings;
1343 #endif
1344 }
1345
1346 void fixup_rootmenu(struct menu *menu)
1347 {
1348         struct menu *child;
1349         static int menu_cnt = 0;
1350
1351         menu->flags |= MENU_ROOT;
1352         for (child = menu->list; child; child = child->next) {
1353                 if (child->prompt && child->prompt->type == P_MENU) {
1354                         menu_cnt++;
1355                         fixup_rootmenu(child);
1356                         menu_cnt--;
1357                 } else if (!menu_cnt)
1358                         fixup_rootmenu(child);
1359         }
1360 }
1361
1362 static const char *progname;
1363
1364 static void usage(void)
1365 {
1366         printf("%s <config>\n", progname);
1367         exit(0);
1368 }
1369
1370 int main(int ac, char** av)
1371 {
1372         ConfigMainWindow* v;
1373         const char *name;
1374
1375 #ifndef LKC_DIRECT_LINK
1376         kconfig_load();
1377 #endif
1378
1379         progname = av[0];
1380         configApp = new QApplication(ac, av);
1381         if (ac > 1 && av[1][0] == '-') {
1382                 switch (av[1][1]) {
1383                 case 'h':
1384                 case '?':
1385                         usage();
1386                 }
1387                 name = av[2];
1388         } else
1389                 name = av[1];
1390         if (!name)
1391                 usage();
1392
1393         conf_parse(name);
1394         fixup_rootmenu(&rootmenu);
1395         conf_read(NULL);
1396         //zconfdump(stdout);
1397
1398         v = new ConfigMainWindow();
1399
1400         //zconfdump(stdout);
1401         v->show();
1402         configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
1403         configApp->connect(configApp, SIGNAL(aboutToQuit()), v, SLOT(saveSettings()));
1404         configApp->exec();
1405
1406         return 0;
1407 }