scripts/kconfig/qconf.cc

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