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