scripts/kconfig/qconf.cc

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