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