git.sur5r.net Git - bacula/bacula/blob - bacula/src/qt-console/mainwin.cpp

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2007-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28
  29 /*
  30  *   Version $Id$
  31  *
  32  *  Main Window control for bat (qt-console)
  33  *
  34  *   Kern Sibbald, January MMVII
  35  *
  36  */
  37
  38 #include "bat.h"
  39 #include "joblist/joblist.h"
  40 #include "storage/storage.h"
  41 #include "fileset/fileset.h"
  42 #include "label/label.h"
  43 #include "run/run.h"
  44 #include "pages.h"
  45 #include "restore/restore.h"
  46 #include "medialist/medialist.h"
  47 #include "joblist/joblist.h"
  48 #include "clients/clients.h"
  49 #include "restore/restoretree.h"
  50 #include "help/help.h"
  51 #include "jobs/jobs.h"
  52 #include "jobgraphs/jobplot.h"
  53
  54 /*
  55  * Daemon message callback
  56  */
  57 void message_callback(int /* type */, char *msg)
  58 {
  59    QMessageBox::warning(mainWin, "Bat", msg, QMessageBox::Ok);
  60 }
  61
  62 MainWin::MainWin(QWidget *parent) : QMainWindow(parent)
  63 {
  64    m_isClosing = false;
  65    m_dtformat = "yyyy-MM-dd HH:mm:ss";
  66    mainWin = this;
  67    setupUi(this);                     /* Setup UI defined by main.ui (designer) */
  68    register_message_callback(message_callback);
  69    readPreferences();
  70    treeWidget->clear();
  71    treeWidget->setColumnCount(1);
  72    treeWidget->setHeaderLabel("Select Page");
  73    treeWidget->setContextMenuPolicy(Qt::ActionsContextMenu);
  74
  75    createPages();
  76
  77    resetFocus();
  78
  79    createConnections();
  80
  81    this->show();
  82
  83    readSettings();
  84
  85    foreach(Console *console, m_consoleHash) {
  86       console->connect_dir();
  87    }
  88    m_currentConsole = (Console*)getFromHash(m_firstItem);
  89    m_currentConsole->setCurrent();
  90    if (m_miscDebug) {
  91       QString directoryResourceName;
  92       m_currentConsole->getDirResName(directoryResourceName);
  93       Pmsg1(000, "Setting initial window to %s\n", directoryResourceName.toUtf8().data());
  94    }
  95 }
  96
  97 void MainWin::createPages()
  98 {
  99    DIRRES *dir;
 100    QTreeWidgetItem *item, *topItem;
 101    m_firstItem = NULL;
 102
 103    LockRes();
 104    foreach_res(dir, R_DIRECTOR) {
 105
 106       /* Create console tree stacked widget item */
 107       m_currentConsole = new Console(stackedWidget);
 108       m_currentConsole->setDirRes(dir);
 109       m_currentConsole->readSettings();
 110
 111       /* The top tree item representing the director */
 112       topItem = new QTreeWidgetItem(treeWidget);
 113       topItem->setText(0, dir->name());
 114       topItem->setIcon(0, QIcon(":images/server.png"));
 115       /* Set background to grey for ease of identification of inactive Director */
 116       QBrush greyBrush(Qt::lightGray);
 117       topItem->setBackground(0, greyBrush);
 118       m_currentConsole->setDirectorTreeItem(topItem);
 119       m_consoleHash.insert(topItem, m_currentConsole);
 120
 121       /* Create Tree Widget Item */
 122       item = new QTreeWidgetItem(topItem);
 123       item->setText(0, "Console");
 124       if (!m_firstItem){ m_firstItem = item; }
 125       item->setIcon(0,QIcon(QString::fromUtf8(":images/utilities-terminal.svg")));
 126
 127       /* insert the cosole and tree widget item into the hashes */
 128       hashInsert(item, m_currentConsole);
 129
 130       /* Set Color of treeWidgetItem for the console
 131       * It will be set to green in the console class if the connection is made.
 132       */
 133       QBrush redBrush(Qt::red);
 134       item->setForeground(0, redBrush);
 135       m_currentConsole->dockPage();
 136
 137       /*
 138        * Create instances in alphabetic order of the rest
 139        *  of the classes that will by default exist under each Director.
 140        */
 141 //      new bRestore();
 142       new Clients();
 143       new FileSet();
 144       new Jobs();
 145       createPageJobList("", "", "", "", NULL);
 146       new MediaList();
 147       new Storage();
 148       new restoreTree();
 149       JobPlotPass pass;
 150       pass.use = false;
 151       new JobPlot(NULL, pass);
 152
 153       treeWidget->expandItem(topItem);
 154       stackedWidget->setCurrentWidget(m_currentConsole);
 155    }
 156    UnlockRes();
 157 }
 158
 159 /*
 160  * create an instance of the the joblist class on the stack
 161  */
 162 void MainWin::createPageJobList(const QString &media, const QString &client,
 163               const QString &job, const QString &fileset, QTreeWidgetItem *parentTreeWidgetItem)
 164 {
 165    QTreeWidgetItem *holdItem;
 166
 167    /* save current tree widget item in case query produces no results */
 168    holdItem = treeWidget->currentItem();
 169    JobList* joblist = new JobList(media, client, job, fileset, parentTreeWidgetItem);
 170    /* If this is a query of jobs on a specific media */
 171    if ((media != "") || (client != "") || (job != "") || (fileset != "")) {
 172       joblist->setCurrent();
 173       /* did query produce results, if not close window and set back to hold */
 174       if (joblist->m_resultCount == 0) {
 175          joblist->closeStackPage();
 176          treeWidget->setCurrentItem(holdItem);
 177       }
 178    }
 179 }
 180
 181 /*
 182  * Handle up and down arrow keys for the command line
 183  *  history.
 184  */
 185 void MainWin::keyPressEvent(QKeyEvent *event)
 186 {
 187    if (m_cmd_history.size() == 0) {
 188       event->ignore();
 189       return;
 190    }
 191    switch (event->key()) {
 192    case Qt::Key_Down:
 193       if (m_cmd_last < 0 || m_cmd_last >= (m_cmd_history.size()-1)) {
 194          event->ignore();
 195          return;
 196       }
 197       m_cmd_last++;
 198       break;
 199    case Qt::Key_Up:
 200       if (m_cmd_last == 0) {
 201          event->ignore();
 202          return;
 203       }
 204       if (m_cmd_last < 0 || m_cmd_last > (m_cmd_history.size()-1)) {
 205          m_cmd_last = m_cmd_history.size() - 1;
 206       } else {
 207          m_cmd_last--;
 208       }
 209       break;
 210    default:
 211       event->ignore();
 212       return;
 213    }
 214    lineEdit->setText(m_cmd_history[m_cmd_last]);
 215 }
 216
 217 void MainWin::createConnections()
 218 {
 219    /* Connect signals to slots */
 220    connect(lineEdit, SIGNAL(returnPressed()), this, SLOT(input_line()));
 221    connect(actionAbout_bat, SIGNAL(triggered()), this, SLOT(about()));
 222    connect(actionBat_Help, SIGNAL(triggered()), this, SLOT(help()));
 223    connect(treeWidget, SIGNAL(itemClicked(QTreeWidgetItem *, int)), this,
 224            SLOT(treeItemClicked(QTreeWidgetItem *, int)));
 225    connect(treeWidget, SIGNAL(
 226            currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)),
 227            this, SLOT(treeItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)));
 228    connect(stackedWidget, SIGNAL(currentChanged(int)),
 229            this, SLOT(stackItemChanged(int)));
 230    connect(actionQuit, SIGNAL(triggered()), app, SLOT(closeAllWindows()));
 231    connect(actionLabel, SIGNAL(triggered()), this,  SLOT(labelButtonClicked()));
 232    connect(actionRun, SIGNAL(triggered()), this,  SLOT(runButtonClicked()));
 233    connect(actionEstimate, SIGNAL(triggered()), this,  SLOT(estimateButtonClicked()));
 234    connect(actionBrowse, SIGNAL(triggered()), this,  SLOT(browseButtonClicked()));
 235    connect(actionJobPlot, SIGNAL(triggered()), this,  SLOT(jobPlotButtonClicked()));
 236    connect(actionRestore, SIGNAL(triggered()), this,  SLOT(restoreButtonClicked()));
 237    connect(actionUndock, SIGNAL(triggered()), this,  SLOT(undockWindowButton()));
 238    connect(actionToggleDock, SIGNAL(triggered()), this,  SLOT(toggleDockContextWindow()));
 239    connect(actionClosePage, SIGNAL(triggered()), this,  SLOT(closePage()));
 240    connect(actionPreferences, SIGNAL(triggered()), this,  SLOT(setPreferences()));
 241 }
 242
 243 /*
 244  * Reimplementation of QWidget closeEvent virtual function
 245  */
 246 void MainWin::closeEvent(QCloseEvent *event)
 247 {
 248    m_isClosing = true;
 249    writeSettings();
 250    /* close all non console pages, this will call settings in destructors */
 251    foreach(Pages *page, m_pagehash) {
 252       if (page !=  page->console()) {
 253          page->console()->setCurrent();
 254          page->closeStackPage();
 255       }
 256    }
 257    /* close the console pages and terminate connection */
 258    foreach(Console *console, m_consoleHash){
 259       console->writeSettings();
 260       console->terminate();
 261       console->closeStackPage();
 262    }
 263    event->accept();
 264 }
 265
 266 void MainWin::writeSettings()
 267 {
 268    QSettings settings("bacula.org", "bat");
 269
 270    settings.beginGroup("MainWin");
 271    settings.setValue("winSize", size());
 272    settings.setValue("winPos", pos());
 273    settings.setValue("state", saveState());
 274    settings.endGroup();
 275 }
 276
 277 void MainWin::readSettings()
 278 {
 279    QSettings settings("bacula.org", "bat");
 280
 281    settings.beginGroup("MainWin");
 282    resize(settings.value("winSize", QSize(1041, 801)).toSize());
 283    move(settings.value("winPos", QPoint(200, 150)).toPoint());
 284    restoreState(settings.value("state").toByteArray());
 285    settings.endGroup();
 286 }
 287
 288 /*
 289  * This subroutine is called with an item in the Page Selection window
 290  *   is clicked
 291  */
 292 void MainWin::treeItemClicked(QTreeWidgetItem *item, int /*column*/)
 293 {
 294    /* Is this a page that has been inserted into the hash  */
 295    if (getFromHash(item)) {
 296       Pages* page = getFromHash(item);
 297       int stackindex=stackedWidget->indexOf(page);
 298
 299       if (stackindex >= 0) {
 300          stackedWidget->setCurrentWidget(page);
 301       }
 302       /* run the virtual function in case this class overrides it */
 303       page->PgSeltreeWidgetClicked();
 304    }
 305 }
 306
 307 /*
 308  * Called with a change of the highlighed tree widget item in the page selector.
 309  */
 310 void MainWin::treeItemChanged(QTreeWidgetItem *currentitem, QTreeWidgetItem *previousitem)
 311 {
 312    if (m_isClosing) return; /* if closing the application, do nothing here */
 313
 314    Pages *previousPage, *nextPage;
 315    Console *previousConsole, *nextConsole;
 316
 317    /* remove all actions before adding actions appropriate for new page */
 318    foreach(QAction* pageAction, treeWidget->actions()) {
 319       treeWidget->removeAction(pageAction);
 320    }
 321
 322    /* first determine the next item */
 323
 324    /* knowing the treeWidgetItem, get the page from the hash */
 325    nextPage = getFromHash(currentitem);
 326    nextConsole = m_consoleHash.value(currentitem);
 327    /* Is this a page that has been inserted into the hash  */
 328    if (nextPage) {
 329       nextConsole = nextPage->console();
 330       /* then is it a treeWidgetItem representing a director */
 331    } else if (nextConsole) {
 332       /* let the next page BE the console */
 333       nextPage = nextConsole;
 334    } else {
 335       /* Should never get here */
 336       nextPage = NULL;
 337       nextConsole = NULL;
 338    }
 339
 340    /* The Previous item */
 341
 342    /* this condition prevents a segfault.  The first time there is no previousitem*/
 343    if (previousitem) {
 344       /* knowing the treeWidgetItem, get the page from the hash */
 345       previousPage = getFromHash(previousitem);
 346       previousConsole = m_consoleHash.value(previousitem);
 347       if (previousPage) {
 348          previousConsole = previousPage->console();
 349       } else if (previousConsole) {
 350          previousPage = previousConsole;
 351       }
 352       if ((previousPage) || (previousConsole)) {
 353          if (nextConsole != previousConsole) {
 354             /* remove connections to the current console */
 355             disconnect(actionConnect, SIGNAL(triggered()), previousConsole, SLOT(connect_dir()));
 356             disconnect(actionStatusDir, SIGNAL(triggered()), previousConsole, SLOT(status_dir()));
 357             disconnect(actionMessages, SIGNAL(triggered()), previousConsole, SLOT(messages()));
 358             disconnect(actionSelectFont, SIGNAL(triggered()), previousConsole, SLOT(set_font()));
 359             QTreeWidgetItem *dirItem = previousConsole->directorTreeItem();
 360             QBrush greyBrush(Qt::lightGray);
 361             dirItem->setBackground(0, greyBrush);
 362          }
 363       }
 364    }
 365
 366    /* process the current (next) item */
 367
 368    if ((nextPage) || (nextConsole)) {
 369       if (nextConsole != previousConsole) {
 370          /* make connections to the current console */
 371          m_currentConsole = nextConsole;
 372          connect(actionConnect, SIGNAL(triggered()), m_currentConsole, SLOT(connect_dir()));
 373          connect(actionSelectFont, SIGNAL(triggered()), m_currentConsole, SLOT(set_font()));
 374          connect(actionStatusDir, SIGNAL(triggered()), m_currentConsole, SLOT(status_dir()));
 375          connect(actionMessages, SIGNAL(triggered()), m_currentConsole, SLOT(messages()));
 376          /* Set director's tree widget background to magenta for ease of identification */
 377          QTreeWidgetItem *dirItem = m_currentConsole->directorTreeItem();
 378          QBrush magentaBrush(Qt::magenta);
 379          dirItem->setBackground(0, magentaBrush);
 380       }
 381       /* set the value for the currently active console */
 382       int stackindex = stackedWidget->indexOf(nextPage);
 383
 384       /* Is this page currently on the stack or is it undocked */
 385       if (stackindex >= 0) {
 386          /* put this page on the top of the stack */
 387          stackedWidget->setCurrentIndex(stackindex);
 388       } else {
 389          /* it is undocked, raise it to the front */
 390          nextPage->raise();
 391       }
 392       /* for the page selectors menu action to dock or undock, set the text */
 393       nextPage->setContextMenuDockText();
 394
 395       treeWidget->addAction(actionToggleDock);
 396       /* if this page is closeable, and it has no childern, then add that action */
 397       if ((nextPage->isCloseable()) && (currentitem->child(0) == NULL))
 398          treeWidget->addAction(actionClosePage);
 399
 400       /* Add the actions to the Page Selectors tree widget that are part of the
 401        * current items list of desired actions regardless of whether on top of stack*/
 402       treeWidget->addActions(nextPage->m_contextActions);
 403    }
 404 }
 405
 406 void MainWin::labelButtonClicked()
 407 {
 408    new labelPage();
 409 }
 410
 411 void MainWin::runButtonClicked()
 412 {
 413    new runPage("");
 414 }
 415
 416 void MainWin::estimateButtonClicked()
 417 {
 418    new estimatePage();
 419 }
 420
 421 void MainWin::browseButtonClicked()
 422 {
 423    new restoreTree();
 424 }
 425
 426 void MainWin::restoreButtonClicked()
 427 {
 428    new prerestorePage();
 429 }
 430
 431 void MainWin::jobPlotButtonClicked()
 432 {
 433    JobPlotPass pass;
 434    pass.use = false;
 435    new JobPlot(NULL, pass);
 436 }
 437
 438 /*
 439  * The user just finished typing a line in the command line edit box
 440  */
 441 void MainWin::input_line()
 442 {
 443    QString cmdStr = lineEdit->text();    /* Get the text */
 444    lineEdit->clear();                    /* clear the lineEdit box */
 445    if (m_currentConsole->is_connected()) {
 446       /* Use consoleInput to allow typing anything */
 447       m_currentConsole->consoleInput(cmdStr);
 448    } else {
 449       set_status("Director not connected. Click on connect button.");
 450    }
 451    m_cmd_history.append(cmdStr);
 452    m_cmd_last = -1;
 453    if (treeWidget->currentItem() != getFromHash(m_currentConsole))
 454       m_currentConsole->setCurrent();
 455 }
 456
 457
 458 void MainWin::about()
 459 {
 460    QMessageBox::about(this, tr("About bat"),
 461       tr("<br><h2>bat 1.0, by Dirk H Bartley and Kern Sibbald</h2>"
 462          "<p>Copyright &copy; " BYEAR " Free Software Foundation Europe e.V."
 463          "<p>The <b>bat</b> is an administrative console"
 464          " interface to the Director."));
 465 }
 466
 467 void MainWin::help()
 468 {
 469    Help::displayFile("index.html");
 470 }
 471
 472 void MainWin::set_statusf(const char *fmt, ...)
 473 {
 474    va_list arg_ptr;
 475    char buf[1000];
 476    int len;
 477    va_start(arg_ptr, fmt);
 478    len = bvsnprintf(buf, sizeof(buf), fmt, arg_ptr);
 479    va_end(arg_ptr);
 480    set_status(buf);
 481 }
 482
 483 void MainWin::set_status_ready()
 484 {
 485    set_status(" Ready");
 486 }
 487
 488 void MainWin::set_status(const char *buf)
 489 {
 490    statusBar()->showMessage(buf);
 491 }
 492
 493 /*
 494  * Function to respond to the button bar button to undock
 495  */
 496 void MainWin::undockWindowButton()
 497 {
 498    Pages* page = (Pages*)stackedWidget->currentWidget();
 499    page->togglePageDocking();
 500 }
 501
 502 /*
 503  * Function to respond to action on page selector context menu to toggle the
 504  * dock status of the window associated with the page selectors current
 505  * tree widget item.
 506  */
 507 void MainWin::toggleDockContextWindow()
 508 {
 509    QTreeWidgetItem *currentitem = treeWidget->currentItem();
 510
 511    /* Is this a page that has been inserted into the hash  */
 512    if (getFromHash(currentitem)) {
 513       Pages* page = getFromHash(currentitem);
 514       page->togglePageDocking();
 515    }
 516 }
 517
 518 /*
 519  * This function is called when the stack item is changed.  Call
 520  * the virtual function here.  Avoids a window being undocked leaving
 521  * a window at the top of the stack unpopulated.
 522  */
 523 void MainWin::stackItemChanged(int)
 524 {
 525    if (m_isClosing) return; /* if closing the application, do nothing here */
 526    Pages* page = (Pages*)stackedWidget->currentWidget();
 527    /* run the virtual function in case this class overrides it */
 528    page->currentStackItem();
 529 }
 530
 531 /*
 532  * Function to simplify insertion of QTreeWidgetItem <-> Page association
 533  * into a double direction hash.
 534  */
 535 void MainWin::hashInsert(QTreeWidgetItem *item, Pages *page)
 536 {
 537    m_pagehash.insert(item, page);
 538    m_widgethash.insert(page, item);
 539 }
 540
 541 /*
 542  * Function to simplify removal of QTreeWidgetItem <-> Page association
 543  * into a double direction hash.
 544  */
 545 void MainWin::hashRemove(QTreeWidgetItem *item, Pages *page)
 546 {
 547    /* I had all sorts of return status checking code here.  Do we have a log
 548     * level capability in bat.  I would have left it in but it used printf's
 549     * and it should really be some kind of log level facility ???
 550     * ******FIXME********/
 551    m_pagehash.remove(item);
 552    m_widgethash.remove(page);
 553 }
 554
 555 /*
 556  * Function to retrieve a Page* when the item in the page selector's tree is
 557  * known.
 558  */
 559 Pages* MainWin::getFromHash(QTreeWidgetItem *item)
 560 {
 561    return m_pagehash.value(item);
 562 }
 563
 564 /*
 565  * Function to retrieve the page selectors tree widget item when the page is
 566  * known.
 567  */
 568 QTreeWidgetItem* MainWin::getFromHash(Pages *page)
 569 {
 570    return m_widgethash.value(page);
 571 }
 572
 573 /*
 574  * Function to respond to action on page selector context menu to close the
 575  * current window.
 576  */
 577 void MainWin::closePage()
 578 {
 579    QTreeWidgetItem *currentitem = treeWidget->currentItem();
 580
 581    /* Is this a page that has been inserted into the hash  */
 582    if (getFromHash(currentitem)) {
 583       Pages* page = getFromHash(currentitem);
 584       if (page->isCloseable()) {
 585          page->closeStackPage();
 586       }
 587    }
 588 }
 589
 590 /* Quick function to return the current console */
 591 Console *MainWin::currentConsole()
 592 {
 593    return m_currentConsole;
 594 }
 595 /* Quick function to return the tree item for the director */
 596 QTreeWidgetItem *MainWin::currentTopItem()
 597 {
 598    return m_currentConsole->directorTreeItem();
 599 }
 600
 601 /* Preferences menu item clicked */
 602 void MainWin::setPreferences()
 603 {
 604    prefsDialog prefs;
 605    prefs.commDebug->setCheckState(m_commDebug ? Qt::Checked : Qt::Unchecked);
 606    prefs.displayAll->setCheckState(m_displayAll ? Qt::Checked : Qt::Unchecked);
 607    prefs.sqlDebug->setCheckState(m_sqlDebug ? Qt::Checked : Qt::Unchecked);
 608    prefs.commandDebug->setCheckState(m_commandDebug ? Qt::Checked : Qt::Unchecked);
 609    prefs.miscDebug->setCheckState(m_miscDebug ? Qt::Checked : Qt::Unchecked);
 610    prefs.recordLimit->setCheckState(m_recordLimitCheck ? Qt::Checked : Qt::Unchecked);
 611    prefs.recordSpinBox->setValue(m_recordLimitVal);
 612    prefs.daysLimit->setCheckState(m_daysLimitCheck ? Qt::Checked : Qt::Unchecked);
 613    prefs.daysSpinBox->setValue(m_daysLimitVal);
 614    prefs.checkMessages->setCheckState(m_checkMessages ? Qt::Checked : Qt::Unchecked);
 615    prefs.checkMessagesSpin->setValue(m_checkMessagesInterval);
 616    prefs.executeLongCheckBox->setCheckState(m_longList ? Qt::Checked : Qt::Unchecked);
 617
 618    prefs.exec();
 619 }
 620
 621 /* Preferences dialog */
 622 prefsDialog::prefsDialog()
 623 {
 624    setupUi(this);
 625 }
 626
 627 void prefsDialog::accept()
 628 {
 629    this->hide();
 630    mainWin->m_commDebug = this->commDebug->checkState() == Qt::Checked;
 631    mainWin->m_displayAll = this->displayAll->checkState() == Qt::Checked;
 632    mainWin->m_sqlDebug = this->sqlDebug->checkState() == Qt::Checked;
 633    mainWin->m_commandDebug = this->commandDebug->checkState() == Qt::Checked;
 634    mainWin->m_miscDebug = this->miscDebug->checkState() == Qt::Checked;
 635    mainWin->m_recordLimitCheck = this->recordLimit->checkState() == Qt::Checked;
 636    mainWin->m_recordLimitVal = this->recordSpinBox->value();
 637    mainWin->m_daysLimitCheck = this->daysLimit->checkState() == Qt::Checked;
 638    mainWin->m_daysLimitVal = this->daysSpinBox->value();
 639    mainWin->m_checkMessages = this->checkMessages->checkState() == Qt::Checked;
 640    mainWin->m_checkMessagesInterval = this->checkMessagesSpin->value();
 641    mainWin->m_longList = this->executeLongCheckBox->checkState() == Qt::Checked;
 642    QSettings settings("www.bacula.org", "bat");
 643    settings.beginGroup("Debug");
 644    settings.setValue("commDebug", mainWin->m_commDebug);
 645    settings.setValue("displayAll", mainWin->m_displayAll);
 646    settings.setValue("sqlDebug", mainWin->m_sqlDebug);
 647    settings.setValue("commandDebug", mainWin->m_commandDebug);
 648    settings.setValue("miscDebug", mainWin->m_miscDebug);
 649    settings.endGroup();
 650    settings.beginGroup("JobList");
 651    settings.setValue("recordLimitCheck", mainWin->m_recordLimitCheck);
 652    settings.setValue("recordLimitVal", mainWin->m_recordLimitVal);
 653    settings.setValue("daysLimitCheck", mainWin->m_daysLimitCheck);
 654    settings.setValue("daysLimitVal", mainWin->m_daysLimitVal);
 655    settings.endGroup();
 656    settings.beginGroup("Messages");
 657    settings.setValue("checkMessages", mainWin->m_checkMessages);
 658    settings.setValue("checkMessagesInterval", mainWin->m_checkMessagesInterval);
 659    settings.endGroup();
 660    settings.beginGroup("Misc");
 661    settings.setValue("longList", mainWin->m_longList);
 662    settings.endGroup();
 663    foreach(Console *console, mainWin->m_consoleHash) {
 664       console->startTimer();
 665    }
 666 }
 667
 668 void prefsDialog::reject()
 669 {
 670    this->hide();
 671    mainWin->set_status("Canceled");
 672 }
 673
 674 /* read preferences for the prefences dialog box */
 675 void MainWin::readPreferences()
 676 {
 677    QSettings settings("www.bacula.org", "bat");
 678    settings.beginGroup("Debug");
 679    m_commDebug = settings.value("commDebug", false).toBool();
 680    m_displayAll = settings.value("displayAll", false).toBool();
 681    m_sqlDebug = settings.value("sqlDebug", false).toBool();
 682    m_commandDebug = settings.value("commandDebug", false).toBool();
 683    m_miscDebug = settings.value("miscDebug", false).toBool();
 684    settings.endGroup();
 685    settings.beginGroup("JobList");
 686    m_recordLimitCheck = settings.value("recordLimitCheck", true).toBool();
 687    m_recordLimitVal = settings.value("recordLimitVal", 150).toInt();
 688    m_daysLimitCheck = settings.value("daysLimitCheck", false).toBool();
 689    m_daysLimitVal = settings.value("daysLimitVal", 28).toInt();
 690    settings.endGroup();
 691    settings.beginGroup("Messages");
 692    m_checkMessages = settings.value("checkMessages", false).toBool();
 693    m_checkMessagesInterval = settings.value("checkMessagesInterval", 28).toInt();
 694    settings.endGroup();
 695    settings.beginGroup("Misc");
 696    m_longList = settings.value("longList", false).toBool();
 697    settings.endGroup();
 698 }