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