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