scripts/kconfig/qconf.cc

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