Ksetiwatch API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Related Pages

analysis.cpp

Go to the documentation of this file.

/***************************************************************************/
#include <kapp.h>
#include <klocale.h>
#include <kiconloader.h>
#include <kmessagebox.h>
#include <kaudioplayer.h>

#include <qcursor.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qheader.h>
#include <qlist.h>
#include <qdir.h>
#include <qpushbutton.h>
#include <qpopupmenu.h>
#include <qcombobox.h>
#include <qtooltip.h>
#include <qlabel.h>
#include <qtimer.h>
#include <qbitmap.h>
#include <qpainter.h>

#include "setiloc.h"
#include "ksetiwatch.h"
#include "analysis.h"
#include "addsetilocdlg.h"
#include "sigmsg.h"
#include "poplistview.h"

/*------------------------------------------------------------------------ */
QString AnalysisListViewItem::key(int column, bool) const
{
// return value must be static
static QString ret;
QString val;
double tmp;

if(column == 2 || column == 3 || (column >= 6 && column <= 8))
  {
  val = text(column);
  tmp = val.toDouble();
  val.sprintf("%f", tmp);
  ret = val.rightJustify(32, '0');
  }
else if(column == 4 || column == 5)
  {
  int colon;
  int d(0), h(0), m(0), s(0);

  val = text(column);
  colon = val.contains(':');
  if(colon == 2)
    {
    sscanf(text(column), "%d:%d:%d", &h, &m, &s);
    }
  else if(colon == 3)
    {
    sscanf(text(column), "%dd:%d:%d:%d", &d, &h, &m, &s);
    }
  tmp = 86400*d + 3600*h + 60*m + s;
  ret.sprintf("%032d", (int)tmp);
  }
else if(column == 9)
  {
  if(text(column).isEmpty())
    tmp = 0.0;
  else
    sscanf(text(column), " scr=%lf", &tmp);
  val.sprintf("%f", tmp);
  ret = val.rightJustify(32, '0');
  }
else if(column == 1)
  {
  SetiLoc* loc = Ksetiwatch::getLocation(this->text(0));
  ret.sprintf("%d", loc->clientState());
  }
else
  {
  ret = text(column);
  }

return(ret);
}

/***************************************************************************/

Analysis::Analysis(QWidget *parent, const char *name) : QWidget(parent,name)
{
Ksetiwatch::TableColumn antc[] =
  {
  {i18n("Location"), -1, AlignLeft},
  {i18n("Status"), -1, AlignCenter},
  {i18n("Chirp Rate"), -1, AlignRight},
  {i18n("% Done"), -1, AlignRight},
  {i18n("CPU Time"), 65, AlignRight},
  {i18n("Time Left"), 60, AlignRight},
  {i18n("%/CPU Hour"), -1, AlignRight},
  {i18n("MFlops"), -1, AlignRight},
  {i18n("Spike"), 55, AlignRight},
  {i18n("Strongest Gaussian"), -1, AlignLeft},
  {i18n("Strongest Pulse"), -1, AlignLeft},
  {i18n("Strongest Triplet"), -1, AlignLeft}
  };

const QStringList statusfilterList = QStringList() << i18n("All")
                                                   << i18n("Stopped")
                                                   << i18n("Running")
                                                   << i18n("Finished")
                                                   << i18n("Loading")
                                                   << i18n("Running+Finished");

// Set up the list view with popup menu.
LocListView = new popListView(this, globalopts->DrawGrid);
LocListView->setShowSortIndicator(false);
LocListView->popupSetTitle(i18n("Location"));
LocListView->insertPopupItem(SmallIcon("mini-setiadd"),
                             i18n("Add...   "), PopupAdd);
LocListView->setAccel(CTRL + Key_Plus, PopupAdd);
LocListView->insertPopupItem(SmallIcon("configure"),
                             i18n("Edit..."), PopupEdit);
LocListView->setAccel(CTRL + Key_Enter, PopupEdit);
LocListView->insertPopupItem(SmallIcon("mini-setiremove"),
                             i18n("Delete"), PopupDelete);
LocListView->setAccel(CTRL + Key_Minus, PopupDelete);
LocListView->insertSeparator();
LocListView->insertPopupItem(SmallIcon("mini-setirunning"),
                             i18n("Start Client"), PopupStart);
LocListView->setAccel(CTRL + Key_R, PopupStart);
LocListView->insertPopupItem(SmallIcon("mini-setistopped"),
                             i18n("Stop Client"), PopupStop);
LocListView->setAccel(CTRL + Key_S, PopupStop);
LocListView->insertSeparator();
showOptions = new QPopupMenu(this);
showOptions->insertItem(QIconSet(SmallIcon("mini-gaussian"), QIconSet::Small),
                        i18n("Gaussian"), SetiLoc::GaussianGraph);
showOptions->insertItem(QIconSet(SmallIcon("mini-pulse"), QIconSet::Small),
                             i18n("Pulse"), SetiLoc::PulseGraph);
showOptions->insertItem(QIconSet(SmallIcon("mini-triplet"), QIconSet::Small),
                             i18n("Triplet"), SetiLoc::TripletGraph);
showOptions->insertSeparator();
showOptions->insertItem(QIconSet(SmallIcon("leftjust"), QIconSet::Small),
                        i18n("Client Output"), SetiLoc::ClientOutput);
LocListView->insertPopupItem(i18n("Show..."), showOptions, PopupShow);
LocListView->setPopupStyle(popListView::ShowAnywhere);
LocListView->move(5,1);
connect(showOptions, SIGNAL(activated(int)),
               this, SLOT(handleShowPopupCommand(int)));
connect(LocListView->popupMenu(), SIGNAL(activated(int)),
                            this, SLOT(handlePopupCommand(int)));
connect(LocListView->popupMenu(), SIGNAL(aboutToShow()),
                            this, SLOT(checkPopupStatus()));
connect(LocListView->header(), SIGNAL(sectionClicked(int)),
                         this, SLOT(toggleSorting(int)));
sortingorder = true;
connect(LocListView, SIGNAL(selectionChanged(QListViewItem*)),
               this, SLOT(handleNewSelection(QListViewItem*)));
connect(LocListView->header(), SIGNAL(sizeChange(int, int, int)),
                         this, SLOT(slotAdjustAllStatusIcons(int, int, int)));
               
LocListViewHidden = new QListView(this);
LocListViewHidden->hide();

// Add the columns to the list view.
for(int i=0; i<(int)(sizeof(antc)/sizeof(antc[0])); i++)
  {
  LocListView->addColumn(antc[i].text, -1);
  LocListViewHidden->addColumn(antc[i].text, -1);
  if(antc[i].width != -1)
    LocListView->setColumnWidth(i, antc[i].width);
  LocListView->setColumnAlignment(i, antc[i].alignment);
  }

// Create the control widgets at the bottom of this tab.
StartAllBtn = new QPushButton(this);
StartAllBtn->resize(35, 27);
StartAllBtn->setPixmap(SmallIcon("mini-setirunning"));
QToolTip::add(StartAllBtn, i18n("Start All"));
connect(StartAllBtn, SIGNAL(clicked()), SLOT(slotStartAll()));

RefreshBtn = new QPushButton(this);
RefreshBtn->resize(35, 27);
RefreshBtn->setPixmap(SmallIcon("reload"));
QToolTip::add(RefreshBtn, i18n("Refresh"));
connect(RefreshBtn, SIGNAL(clicked()), SLOT(refreshList()));

StopAllBtn = new QPushButton(this);
StopAllBtn->resize(35, 27);
StopAllBtn->setPixmap(SmallIcon("mini-setistopped"));
QToolTip::add(StopAllBtn, i18n("Stop All"));
connect(StopAllBtn, SIGNAL(clicked()), SLOT(slotStopAll()));

HelpBtn = new QPushButton(this);
HelpBtn->setMinimumSize(HelpBtn->sizeHint().width() + 20, 27);
HelpBtn->resize(HelpBtn->sizeHint());
HelpBtn->setText(i18n("Help"));
connect(HelpBtn, SIGNAL(clicked()), SLOT(slotShowHelp()) );

// Create a pushbutton with an icon. Doesn't work with all KDE themes!
HomepageBtn = new QPushButton(i18n("Homepage"), this);
HomepageBtn->setIconSet(SmallIconSet("ksetiwatch"));
HomepageBtn->setMinimumSize(HomepageBtn->sizeHint().width(), 27);
HomepageBtn->resize(HomepageBtn->sizeHint().width(), 27);
connect(HomepageBtn, SIGNAL(clicked()), SLOT(openBrowser()) );

StatusFilter = new QComboBox(false, this);
StatusFilter->insertStringList(statusfilterList);
StatusFilter->setMinimumSize(StatusFilter->sizeHint().width(), 27);
StatusFilter->resize(StatusFilter->sizeHint().width(), 27);
ComboLabel = new QLabel(this);
ComboLabel->setAutoResize(true);
ComboLabel->setAlignment(AlignRight);
ComboLabel->setText(i18n("Show:"));
connect(StatusFilter, SIGNAL(activated(int)), SLOT(modifyStatusFilter(int)));

// Load the status icons.
StatusIcon[0] = SmallIcon("mini-setistopped");
StatusIcon[1] = SmallIcon("mini-setirunning");  
StatusIcon[2] = SmallIcon("mini-setifinished");
StatusIcon[3] = SmallIcon("mini-setiloading");
StatusIcon[4] = SmallIcon("connect_creating");

// Single-shot timer in order to display a message box in case no location
// is configured.
QTimer::singleShot(1500, this, SLOT(slotAskForLocation()));

// Fill the list.
refreshList();
}

/*------------------------------------------------------------------------ */
Analysis::~Analysis()
{
}

/*------------------------------------------------------------------------ */
void Analysis::resizeEvent(QResizeEvent*)
{
LocListView->resize(this->width()-10,
                    this->height()-HelpBtn->height()-5);
StartAllBtn->move(5, LocListView->y()+LocListView->height()+
                     (HelpBtn->height()-StartAllBtn->height())/2+2);
RefreshBtn->move(10+StartAllBtn->width(), LocListView->y()+
                 LocListView->height()+
                 (HelpBtn->height()-RefreshBtn->height())/2+2);
StopAllBtn->move(15+StartAllBtn->width()+RefreshBtn->width(),
                  LocListView->y()+LocListView->height()+
                  (HelpBtn->height()-StopAllBtn->height())/2+2);
ComboLabel->move(StopAllBtn->x()+StopAllBtn->width()+16,
                 LocListView->y()+LocListView->height()+
                 (HelpBtn->height()-ComboLabel->height())/2+2);
StatusFilter->move(ComboLabel->x()+ComboLabel->width()+4,
                   LocListView->y()+LocListView->height()+2);
HomepageBtn->move(width()-HomepageBtn->width()-5,
               LocListView->y()+LocListView->height()+2);
HelpBtn->move(width()-HomepageBtn->width()-HelpBtn->width()-15,
           LocListView->y()+LocListView->height()+2);
}

/*------------------------------------------------------------------------ */
void Analysis::paintEvent(QPaintEvent* e)
{
LocListView->setGridEnabled(globalopts->DrawGrid);
QWidget::paintEvent(e);
}

/*------------------------------------------------------------------------ */
void Analysis::handlePopupCommand(int id)
{
SetiLoc* loc = getLocation(selectedItem());

switch(id)
  {
  case PopupAdd: // add a new SETI location
    {
    AddSetiLocDlg dlg(topLevelWidget());
    dlg.setCaption(i18n("Add SETI@home Location..."));
    if(dlg.exec() == QDialog::Accepted)
      {
      LocSettings ls = dlg.options();
      SetiLoc* loc = new SetiLoc(dlg.setiDirectory());
      loc->setOptions(ls);
      // Notifies the main Ksetiwatch object, which maintains the list of locations,
      // of the change.
      emit listChangeRequested(loc, Ksetiwatch::ListAdd);
      }
    break;
    }
  case PopupEdit: // edit an existing SETI location
    {
    if(loc)
      {
      // create the dialog and fill it with the corresponding data
      AddSetiLocDlg dlg(topLevelWidget());
      dlg.setCaption(i18n("Edit SETI@home Location..."));
      dlg.setOptions(loc->options());
      if(dlg.exec() == QDialog::Accepted)
        {
        loc->setOptions(dlg.options());
        // Notifies the main Ksetiwatch object, which maintains the list of locations,
        // of the change.
        emit listChangeRequested(loc, Ksetiwatch::ListEdit);
        }
      }
    break;
    }
  case PopupDelete: // remove a SETI location
    {
    if(loc)
      {
      emit selectionChanged(0);
      // Notifies the main Ksetiwatch object, which maintains the list of locations,
      // of the change.
      emit listChangeRequested(loc, Ksetiwatch::ListDelete);
      }
    break;
    }
  case PopupStart: // start the client
    {
    if(loc)
      loc->startClient();
    break;
    }
  case PopupStop: // stop the client
    {
    if(loc)
      loc->stopClient();
    break;
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::checkPopupStatus()
{
// convert global coords to local widget coords and subtract header height
QPoint p = LocListView->mapFromGlobal(QCursor::pos()) -
           QPoint(0, LocListView->header()->height());
// is an item below the mouse pointer? If so, enable Edit and Delete
if(LocListView->itemAt(p))
  {
  LocListView->popupMenu()->setItemEnabled(PopupEdit, true);
  LocListView->popupMenu()->setItemEnabled(PopupDelete, true);
  // get the status of the clients and enable or disable the Start/Stop
  // menu items
  LocListView->popupMenu()->setItemEnabled(PopupStart, false);
  LocListView->popupMenu()->setItemEnabled(PopupStop, false);
  SetiLoc* loc = getLocation(static_cast<AnalysisListViewItem*>(LocListView->currentItem()));
  if(loc)
    {
    switch(loc->clientState())
      {
      case SetiLoc::Running:
      case SetiLoc::Loading:
      case SetiLoc::Connecting:
        {
        // enable stop
        LocListView->popupMenu()->setItemEnabled(PopupStop, true);
        break;
        }
      case SetiLoc::Stopped:
        {
        // enable start
        LocListView->popupMenu()->setItemEnabled(PopupStart, true);
        break;
        }
      case SetiLoc::Finished:
        {
        if(loc->isClientRunning() == true)
          LocListView->popupMenu()->setItemEnabled(PopupStop, true);
        else
          LocListView->popupMenu()->setItemEnabled(PopupStart, true);
        break;
        }
      }
    LocListView->popupMenu()->setItemEnabled(PopupShow, true);
    // enable Gaussian display only when a Gaussian has been found
    WUScore max = loc->wuScore();
    if(max.gaussian.score > 0.0 && loc->clientVersion() > 100)
      showOptions->setItemEnabled(soGaussian, true);
    else
      showOptions->setItemEnabled(soGaussian, false);
    // enable pulse display only when a pulse has been found
    if(max.pulse.score > 0.0 && loc->clientVersion() >= 300)
      showOptions->setItemEnabled(soPulse, true);
    else
      showOptions->setItemEnabled(soPulse, false);
    // enable triplet display only when a triplet has been found
    if(max.triplet.score > 0.0 && loc->clientVersion() >= 300)
      showOptions->setItemEnabled(soTriplet, true);
    else
      showOptions->setItemEnabled(soTriplet, false);
    }
  }
else // disable everything except Add
  {
  LocListView->popupMenu()->setItemEnabled(PopupEdit, false);
  LocListView->popupMenu()->setItemEnabled(PopupDelete, false);
  LocListView->popupMenu()->setItemEnabled(PopupStart, false);
  LocListView->popupMenu()->setItemEnabled(PopupStop, false);
  LocListView->popupMenu()->setItemEnabled(PopupShow, false);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::handleShowPopupCommand(int id)
{
AnalysisListViewItem *it = selectedItem();
SetiLoc* loc = getLocation(it);

if(loc)
  loc->showGraph(id);
}

/*------------------------------------------------------------------------ */
void Analysis::refreshList()
{
QList<SetiLoc> seli = Ksetiwatch::locationList();

for(SetiLoc* loc=seli.first(); loc != 0; loc=seli.next())
  {
  AnalysisListViewItem* it = locationItemById(loc->id());
  if(it == 0)
    slotUpdateList(loc, Ksetiwatch::ListAdd);
  else
    refreshListItem(loc);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::refreshListItem(SetiLoc* loc)
{
updateStateIcon(loc, loc->clientState(), 0);
updateListItemTimeData(loc);
updateListItemSpikeData(loc);
updateListItemGaussianData(loc);
updateListItemPulseData(loc);
updateListItemTripletData(loc);
}

/*------------------------------------------------------------------------ */
void Analysis::slotUpdateList(SetiLoc* loc, int type)
{
AnalysisListViewItem* it;

switch(type)
  {
  case Ksetiwatch::ListAdd:
    {
    it = lvDictHidden[loc->id()];
    if(it)
      {
      lvDictHidden.remove(loc->id());
      lvDict.insert(loc->id(), it);
      LocListViewHidden->takeItem(it);
      LocListView->insertItem(it);
      centerStatusIcon(it, loc->clientState());
      }
    else
      {
      it = new AnalysisListViewItem(LocListView);
      if(it)
        {
        lvDict.insert(loc->id(), it);
        connect(loc,  SIGNAL(stateChanged(int,int)),
                this, SLOT(slotShowNewState(int,int)));
        connect(loc,  SIGNAL(progressIncreased()),
                this, SLOT(slotUpdateAnalysisTimeData()));
        connect(loc,  SIGNAL(newSpike(SpikeScore)),
                this, SLOT(slotUpdateAnalysisSpikeData(SpikeScore)));   
        connect(loc,  SIGNAL(newGaussian(GaussianScore)),
                this, SLOT(slotUpdateAnalysisGaussianData(GaussianScore))); 
        connect(loc,  SIGNAL(newPulse(PulseScore)),
                this, SLOT(slotUpdateAnalysisPulseData(PulseScore)));   
        connect(loc,  SIGNAL(newTriplet(TripletScore)),
                this, SLOT(slotUpdateAnalysisTripletData(TripletScore)));
        loc->initMaxScore();
        refreshListItem(loc);
        }
      }
    break;
    }
  case Ksetiwatch::ListEdit:
    {
    refreshListItem(loc);
    break;
    }
  case Ksetiwatch::ListDelete:
    {
    disconnect(loc,  SIGNAL(stateChanged(int,int)),
               this, SLOT(slotShowNewState(int,int)));
    disconnect(loc,  SIGNAL(progressIncreased()),
               this, SLOT(slotUpdateAnalysisTimeData()));
    disconnect(loc,  SIGNAL(newSpike(SpikeScore)),
               this, SLOT(slotUpdateAnalysisSpikeData(SpikeScore)));    
    disconnect(loc,  SIGNAL(newGaussian(GaussianScore)),
               this, SLOT(slotUpdateAnalysisGaussianData(GaussianScore)));  
    disconnect(loc,  SIGNAL(newPulse(PulseScore)),
               this, SLOT(slotUpdateAnalysisPulseData(PulseScore)));    
    disconnect(loc,  SIGNAL(newTriplet(TripletScore)),
               this, SLOT(slotUpdateAnalysisTripletData(TripletScore)));
    it = lvDict[loc->id()];
    if(it)
      {
      lvDict.remove(loc->id());
      delete it;
      }
    break;
    }
  case Ksetiwatch::ListRemove:
    {
    it = lvDict[loc->id()];
    if(it)
      {
      LocListView->takeItem(it);
      LocListViewHidden->insertItem(it);
      lvDict.remove(loc->id());
      lvDictHidden.insert(loc->id(), it);
      }
    break;
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateListItemTimeData(SetiLoc* loc)
{
AnalysisListViewItem* it;

if(loc && (it = locationItemById(loc->id())))
  {
  // set location text
  it->setText(ColLocation, loc->description());

  if(loc->exists(SetiLoc::SC_StateFile))
    {
    if(loc->clientState() != SetiLoc::Finished &&
       loc->clientState() != SetiLoc::Connecting)
      {
      // set the actual chirp rate
      it->setText(ColChirpRate, QString::number(loc->chirpRate(), 'f', 4));
      // set the progress in %
      it->setText(ColProgress, QString::number(loc->progress(), 'f', 3));
      // calculate and set the time required to finish this work unit
      it->setText(ColTimeLeft, (loc->remainingTime() > 0.0) ?
                     loc->convertTime(loc->remainingTime(), globalopts->hms) : QString::null);
      }
    // set the elapsed CPU time     
    it->setText(ColCpuTime, loc->convertTime(loc->cpuTime(), globalopts->hms));
    // calculate and set the progress rate
    it->setText(ColProgressRate, QString::number(loc->progressRate(), 'f', 5));
    // MFlops
    it->setText(ColMFlops, QString::number(loc->megaFlopsPerSecond(), 'f', 2));
    }
  else
    {
    it->setText(ColChirpRate,    QString::null);
    it->setText(ColProgress,     QString::null);
    it->setText(ColCpuTime,      QString::null);
    it->setText(ColTimeLeft,     QString::null);
    it->setText(ColProgressRate, QString::null);
    it->setText(ColMFlops,       QString::null);
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateListItemSpikeData(SetiLoc* loc)
{
AnalysisListViewItem* it;

if(loc && (it = locationItemById(loc->id())))
  {
  WUScore max = loc->wuScore();
  // update the list view item
  if(loc->exists(SetiLoc::SC_StateFile) && max.spike.power > 0.0)
    it->setText(ColSpike, " " + ((max.spike.power > 1.0e6) ?
                          QString::number(max.spike.power, 'e', 6) :
                          QString::number(max.spike.power, 'f', 3)));
  else
    it->setText(ColSpike, QString::null);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateListItemGaussianData(SetiLoc* loc)
{
AnalysisListViewItem* it;

if(loc && (it = locationItemById(loc->id())))
  {
  WUScore max = loc->wuScore();
  // update the list view item
  if(loc->exists(SetiLoc::SC_StateFile) && max.gaussian.score > 0.0)
    it->setText(ColGaussian, QString(" scr=%1, pwr=%2, fit=%3")
                             .arg(max.gaussian.score, 0, 'f', 4)
                             .arg(max.gaussian.power, 0, 'f', 2)
                             .arg(max.gaussian.chisq, 0, 'f', 2));
  else
    it->setText(9, QString::null);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateListItemPulseData(SetiLoc* loc)
{
AnalysisListViewItem* it;

if(loc && (it = locationItemById(loc->id())))
  {
  WUScore max = loc->wuScore();
  // update the list view item
  if(loc->exists(SetiLoc::SC_StateFile) && max.pulse.score > 0.0)
    it->setText(ColPulse, QString(" scr=%1, pwr=%2, prd=%3")
                          .arg(max.pulse.score, 0, 'f', 4)
                          .arg(max.pulse.power, 0, 'f', 2)
                          .arg(max.pulse.period, 0, 'f', 4));
  else
    it->setText(ColPulse, QString::null);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateListItemTripletData(SetiLoc* loc)
{
AnalysisListViewItem* it;

if(loc && (it = locationItemById(loc->id())))
  {
  WUScore max = loc->wuScore();
  // update the list view item
  if(loc->exists(SetiLoc::SC_StateFile) && max.triplet.score > 0.0)
    it->setText(ColTriplet, QString(" scr=%1, prd=%2")
                            .arg(max.triplet.score, 0, 'f', 4)
                            .arg(max.triplet.period, 0, 'f', 4));
  else
    it->setText(ColTriplet, QString::null);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateMaxScore(SetiLoc* loc, const SpikeScore& newspike)
{
WUScore max = loc->maxScore();
// Display a message if a new record is found.
if(globalopts->ReportSpike &&
   newspike.power > globalopts->Record.spike.power)
  {
  // play a sound if the option is enabled;
  if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
    KAudioPlayer::play(globalopts->HighSignalSound);
  // display a message box
  QString msgbuf, title;
  msgbuf.sprintf(i18n("<b>New record spike:</b><br>"
                      "peak = %.3lf at %.4lf Hz/s,<br>"
                      "found in WU %s.<br><br>"
                      "<b>Previous spike:</b><br>"
                      "peak = %.3lf at %.4lf Hz/s,<br>"
                      "found in WU %s."),
                      newspike.power, newspike.chirprate,
                      (const char*)newspike.wu_name,
                      globalopts->Record.spike.power,
                      globalopts->Record.spike.chirprate,
                      (const char*)globalopts->Record.spike.wu_name);
  title = i18n("New Record Spike for %1").arg(loc->description());
  SigMsg* sm = new SigMsg(newspike, msgbuf, 0, "New Signal");
  sm->setCaption(title);
  sm->show();
  }

// Display a message if a new high signal is found. Checking mymax for -1
// ensures that the message is not shown when starting Ksetiwatch.
if(!globalopts->ShowRecords && globalopts->ReportSpike &&
   max.spike.power != -1.0)
  {
  if(newspike.power > max.spike.power &&
     newspike.power <= globalopts->Record.spike.power)
    {
    // play a sound if the option is enabled;
    if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
      KAudioPlayer::play(globalopts->HighSignalSound);
    // display a message box
    QString msgbuf, title;
    msgbuf.sprintf(i18n("<b>New high spike in the current WU:</b><br>"
                        "peak = %.3lf at %.4lf Hz/s.<br><br>"
                        "<b>Previous spike:</b><br>"
                        "peak = %.3lf at %.4lf Hz/s."),
                        newspike.power, newspike.chirprate,
                        max.spike.power, max.spike.chirprate);
    title = i18n("New High Spike for %1").arg(loc->description());
    SigMsg* sm = new SigMsg(newspike, msgbuf, 0, "New Signal");
    sm->setCaption(title);
    sm->show();
    }
  }

// update highscores
if(newspike.power > max.spike.power || max.spike.power == -1.0)
  {
  // only update if state.sah exists
  if(loc->exists(SetiLoc::SC_StateFile))
    {
    max.spike = newspike;
    loc->setMaxScore(max);
    }
  }
if(newspike.power > globalopts->Record.spike.power)
  {
  globalopts->Record.spike = newspike;
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateMaxScore(SetiLoc* loc, const GaussianScore& newgaussian)
{
WUScore max = loc->maxScore();
// Display a message if a new record is found.
if(globalopts->ReportGaussian &&
   newgaussian.score > globalopts->Record.gaussian.score)
  {
  // play a sound if the option is enabled;
  if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
    KAudioPlayer::play(globalopts->HighSignalSound);
  // display a message box
  QString msgbuf, title;
  msgbuf.sprintf(i18n("<b>New record gaussian:</b><br>"
    "scr = %.4lf, pwr = %.2lf, fit = %.2lf at %.4lf Hz/s,<br>"
    "found in WU %s.<br><br>"
    "<b>Previous record gaussian:</b><br>"
    "scr = %.4lf, pwr = %.2lf, fit = %.2lf at %.4lf Hz/s,<br>"
    "found in WU %s."),
    newgaussian.score, newgaussian.power, newgaussian.chisq,
    newgaussian.chirprate, (const char*)newgaussian.wu_name,
    globalopts->Record.gaussian.score,
    globalopts->Record.gaussian.power,
    globalopts->Record.gaussian.chisq,
    globalopts->Record.gaussian.chirprate,
    (const char*)globalopts->Record.gaussian.wu_name);
  title = i18n("New Record Gaussian for %1").arg(loc->description());
  SigMsg* sm = new SigMsg(newgaussian, msgbuf, 0, "New Signal");
  sm->setCaption(title);
  sm->show();
  }

// Display a message if a new high signal is found. Checking mymax for -1
// ensures that the message is not shown when starting Ksetiwatch.
if(!globalopts->ShowRecords && globalopts->ReportGaussian &&
   max.gaussian.score != -1.0)
  {
  if(newgaussian.score > max.gaussian.score &&
     newgaussian.score <= globalopts->Record.gaussian.score)
    {
    // play a sound if the option is enabled;
    if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
      KAudioPlayer::play(globalopts->HighSignalSound);
    // display a message box
    QString msgbuf, title;
    msgbuf.sprintf(i18n("<b>New high gaussian in the current WU:</b><br>"
      "scr = %.4lf, pwr = %.2lf, fit = %.2lf at %.4lf Hz/s.<br><br>"
      "<b>Previous gaussian:</b><br>"
      "scr = %.4lf, pwr = %.2lf, fit = %.2lf at %.4lf Hz/s."),
      newgaussian.score, newgaussian.power, newgaussian.chisq,
      newgaussian.chirprate,
      max.gaussian.score, max.gaussian.power, max.gaussian.chisq,
      max.gaussian.chirprate);
    title = i18n("New High Gaussian for %1").arg(loc->description());
    SigMsg* sm = new SigMsg(newgaussian, msgbuf, 0, "New Signal");
    sm->setCaption(title);
    sm->show();
    }
  }

// update highscores
if(newgaussian.score > max.gaussian.score || max.gaussian.score == -1.0)
  {
  // only update if state.sah exists
  if(loc->exists(SetiLoc::SC_StateFile))
    {
    max.gaussian = newgaussian;
    loc->setMaxScore(max);
    }
  }
if(newgaussian.score > globalopts->Record.gaussian.score)
  {
  globalopts->Record.gaussian = newgaussian;
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateMaxScore(SetiLoc* loc, const PulseScore& newpulse)
{
WUScore max = loc->maxScore();
// Display a message if a new record is found.
if(globalopts->ReportPulse &&
   newpulse.score > globalopts->Record.pulse.score)
  {
  // play a sound if the option is enabled;
  if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
    KAudioPlayer::play(globalopts->HighSignalSound);
  // display a message box
  QString msgbuf, title;
  msgbuf.sprintf(i18n("<b>New record pulse:</b><br>"
    "scr = %.4lf, pwr = %.2lf, prd = %.4lf at %.4lf Hz/s,<br>"
    "found in WU %s.<br><br>"
    "<b>Previous record pulse:</b><br>"
    "scr = %.4lf, pwr = %.2lf, prd = %.4lf at %.4lf Hz/s,<br>"
    "found in WU %s."),
    newpulse.score, newpulse.power, newpulse.period,
    newpulse.chirprate, (const char*)newpulse.wu_name,
    globalopts->Record.pulse.score,
    globalopts->Record.pulse.power,
    globalopts->Record.pulse.period,
    globalopts->Record.pulse.chirprate,
    (const char*)globalopts->Record.pulse.wu_name);
  title = i18n("New Record Pulse for %1").arg(loc->description());
  SigMsg* sm = new SigMsg(newpulse, msgbuf, 0, "New Signal");
  sm->setCaption(title);
  sm->show();
  }

// Display a message if a new high signal is found. Checking mymax for -1
// ensures that the message is not shown when starting Ksetiwatch.
if(!globalopts->ShowRecords && globalopts->ReportPulse &&
   max.pulse.score != -1.0)
  {
  if(newpulse.score > max.pulse.score &&
     newpulse.score <= globalopts->Record.pulse.score)
    {
    // play a sound if the option is enabled;
    if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
      KAudioPlayer::play(globalopts->HighSignalSound);
    // display a message box
    QString msgbuf, title;
    msgbuf.sprintf(i18n("<b>New high pulse in the current WU:</b><br>"
      "scr = %.4lf, pwr = %.2lf, prd = %.4lf at %.4lf Hz/s.<br><br>"
      "<b>Previous pulse:</b><br>"
      "scr = %.4lf, pwr = %.2lf, prd = %.4lf at %.4lf Hz/s."),
      newpulse.score, newpulse.power, newpulse.period,
      newpulse.chirprate,
      max.pulse.score, max.pulse.power, max.pulse.period,
      max.pulse.chirprate);
    title = i18n("New High Pulse for %1").arg(loc->description());
    SigMsg* sm = new SigMsg(newpulse, msgbuf, 0, "New Signal");
    sm->setCaption(title);
    sm->show();
    }
  }

// update highscores
if(newpulse.score > max.pulse.score || max.pulse.score == -1.0)
  {
  // only update if state.sah exists
  if(loc->exists(SetiLoc::SC_StateFile))
    {
    max.pulse = newpulse;
    loc->setMaxScore(max);
    }
  }
if(newpulse.score > globalopts->Record.pulse.score)
  {
  globalopts->Record.pulse = newpulse;
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateMaxScore(SetiLoc* loc, const TripletScore& newtriplet)
{
WUScore max = loc->maxScore();
// Display a message if a new record is found.
if(globalopts->ReportTriplet &&
   newtriplet.score > globalopts->Record.triplet.score)
  {
  // play a sound if the option is enabled;
  if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
    KAudioPlayer::play(globalopts->HighSignalSound);
  // display a message box
  QString msgbuf, title;
  msgbuf.sprintf(i18n("<b>New record triplet:</b><br>"
    "scr = %.4lf, prd = %.4lf at %.4lf Hz/s,<br>"
    "found in WU %s.<br><br>"
    "<b>Previous triplet:</b><br>"
    "scr = %.4lf, prd = %.4lf at %.4lf Hz/s,<br>"
    "found in WU %s."),
    newtriplet.score, newtriplet.period, newtriplet.chirprate,
    (const char*)newtriplet.wu_name,
    globalopts->Record.triplet.score,
    globalopts->Record.triplet.period,
    globalopts->Record.triplet.chirprate,
    (const char*)globalopts->Record.triplet.wu_name);
  title = i18n("New Record Triplet for %1").arg(loc->description());
  SigMsg* sm = new SigMsg(newtriplet, msgbuf, 0, "New Signal");
  sm->setCaption(title);
  sm->show();
  }

// Display a message if a new high signal is found. Checking mymax for -1
// ensures that the message is not shown when starting Ksetiwatch.
if(!globalopts->ShowRecords && globalopts->ReportTriplet &&
   max.triplet.score != -1.0)
  {
  if(newtriplet.score > max.triplet.score &&
     newtriplet.score <= globalopts->Record.triplet.score)
    {
    // play a sound if the option is enabled;
    if(globalopts->PlaySound && !globalopts->HighSignalSound.isEmpty())
      KAudioPlayer::play(globalopts->HighSignalSound);
    // display a message box
    QString msgbuf, title;
    msgbuf.sprintf(i18n("<b>New high triplet in the current WU:</b><br>"
      "scr = %.4lf, prd = %.4lf at %.4lf Hz/s.<br><br>"
      "<b>Previous triplet:</b><br>"
      "scr = %.4lf, prd = %.4lf at %.4lf Hz/s."),
      newtriplet.score, newtriplet.period, newtriplet.chirprate,
      max.triplet.score, max.triplet.period, max.triplet.chirprate);
    title = i18n("New High Triplet for %1").arg(loc->description());
    SigMsg* sm = new SigMsg(newtriplet, msgbuf, 0, "New Signal");
    sm->setCaption(title);
    sm->show();
    }
  }

// update highscores
if(newtriplet.score > max.triplet.score || max.triplet.score == -1.0)
  {
  // only update if state.sah exists
  if(loc->exists(SetiLoc::SC_StateFile))
    {
    // store the triplet data to merge them into the logs later
    if(max.triplet.score != -1.0) loc->storeTripletData(newtriplet);
    max.triplet = newtriplet;
    loc->setMaxScore(max);
    }
  }
if(newtriplet.score > globalopts->Record.triplet.score)
  {
  globalopts->Record.triplet = newtriplet;
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotUpdateAnalysisTimeData()
{
SetiLoc* loc = (SetiLoc*)(sender());
if(loc)
  updateListItemTimeData(loc);
}

/*------------------------------------------------------------------------ */
void Analysis::slotUpdateAnalysisSpikeData(SpikeScore newspike)
{
SetiLoc* loc = (SetiLoc*)(sender());

if(loc)
  {
  updateMaxScore(loc, newspike);
  updateListItemSpikeData(loc);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotUpdateAnalysisGaussianData(GaussianScore newgaussian)
{
SetiLoc* loc = (SetiLoc*)(sender());

if(loc)
  {
  updateMaxScore(loc, newgaussian);
  updateListItemGaussianData(loc);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotUpdateAnalysisPulseData(PulseScore newpulse)
{
SetiLoc* loc = (SetiLoc*)(sender());

if(loc)
  {
  updateMaxScore(loc, newpulse);
  updateListItemPulseData(loc);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotUpdateAnalysisTripletData(TripletScore newtriplet)
{
SetiLoc* loc = (SetiLoc*)(sender());

if(loc)
  {
  updateMaxScore(loc, newtriplet);
  updateListItemTripletData(loc);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::updateStateIcon(SetiLoc* loc, int state, int loadsize)
{
AnalysisListViewItem* it;

if(loc)
  {
  updateAnalysisList(loc);
  it = locationItemById(loc->id());
  }
if(loc && it)
  {
  // log the WU if necessary
  if(state == SetiLoc::Finished)
    {
    loc->checkWUStatus();
    }

  // first change the icon
  centerStatusIcon(it, state);
  
  // modify the columns in accordance to the new state
  switch(state)
    {
    case SetiLoc::Stopped:
      // Restart the client if the option is set and the client has crashed.
      if(loc->optionKeepClientAlive() && !loc->isStoppedNormally())
        loc->startClient();
      // Fallthrough
    case SetiLoc::Running:
      updateListItemTimeData(loc);
      updateListItemSpikeData(loc);
      updateListItemGaussianData(loc);
      updateListItemPulseData(loc);
      updateListItemTripletData(loc);
      break;
    case SetiLoc::Finished:
      updateListItemTimeData(loc);
      it->setText(ColChirpRate, QString::null);
      it->setText(ColProgress, "100.000");
      it->setText(ColTimeLeft, QString::null);
      break;
    case SetiLoc::Connecting:
      loadsize = 0;
      // Fallthrough
    case SetiLoc::Loading:
      it->setText(ColChirpRate,    QString::null);
      it->setText(ColProgress,     QString("%1 %").arg(loadsize));
      it->setText(ColCpuTime,      QString::null);
      it->setText(ColTimeLeft,     QString::null);
      it->setText(ColProgressRate, QString::null);
      it->setText(ColMFlops,       QString::null);
      it->setText(ColSpike,        QString::null);
      it->setText(ColGaussian,     QString::null);
      it->setText(ColPulse,        QString::null);
      it->setText(ColTriplet,      QString::null);
      break;
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotShowNewState(int state, int loadsize)
{
SetiLoc* loc = (SetiLoc*)(sender());
updateStateIcon(loc, state, loadsize);
}

/*------------------------------------------------------------------------ */
void Analysis::updateAnalysisList(SetiLoc* loc)
{
AnalysisListViewItem* it = lvDict[loc->id()];
switch(globalopts->StatusFilterValue)
  {
  case 0: // All
    {
    if(it == 0)
      slotUpdateList(loc, Ksetiwatch::ListAdd);
    break;
    }
  case 5: // Running + Finished
    {
    if(it && (loc->clientState() != SetiLoc::Running &&
       loc->clientState() != SetiLoc::Finished))
      {
      if(it->isSelected())
        {
        LocListView->setSelected(LocListView->currentItem(), false);
        emit selectionChanged(0);
        }
      slotUpdateList(loc, Ksetiwatch::ListRemove);
      }
    else if(it == 0 && (loc->clientState() == SetiLoc::Running ||
            loc->clientState() == SetiLoc::Finished))
      {
      slotUpdateList(loc, Ksetiwatch::ListAdd);
      }
    break;
    }
  default: // Stopped, Running, Finished, Loading
    {
    if(it && loc->clientState() != globalopts->StatusFilterValue-1)
      {
      if(it->isSelected())
        {
        LocListView->setSelected(LocListView->currentItem(), false);
        emit selectionChanged(0);
        }
      slotUpdateList(loc, Ksetiwatch::ListRemove);
      }
    else if(it == 0 && loc->clientState() == globalopts->StatusFilterValue-1)
      {
      slotUpdateList(loc, Ksetiwatch::ListAdd);
      }
    break;
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::modifyStatusFilter(int sel)
{
globalopts->StatusFilterValue = sel;
// Add or remove items according to the new filter selection.
for(SetiLoc* loc=Ksetiwatch::locationList().first(); loc != 0;
    loc=Ksetiwatch::locationList().next())
  {
  updateAnalysisList(loc);
  }
}

/*------------------------------------------------------------------------ */
void Analysis::toggleSorting(int column)
{
sortingorder = !sortingorder;
LocListView->setSorting(column, sortingorder);
}

/*------------------------------------------------------------------------ */
void Analysis::slotShowHelp()
{
kapp->invokeHelp();
}

/*------------------------------------------------------------------------ */
void Analysis::openBrowser()
{
kapp->invokeBrowser("http://ksetiwatch.sourceforge.net");
}

/*------------------------------------------------------------------------ */
AnalysisListViewItem* Analysis::selectedItem()
{
QListViewItem* it = LocListView->currentItem();

if(LocListView->isSelected(it))
  return(static_cast<AnalysisListViewItem*>(it));
else
  return(0);
}

/*------------------------------------------------------------------------ */
AnalysisListViewItem* Analysis::locationItemByName(const QString& locName)
{
QListViewItem* it;

// identify corresponding SetiLoc item
for(it=LocListView->firstChild(); it != 0; it=it->nextSibling() )
  {
  if(it->text(ColLocation) == locName) break;
  }

return( static_cast<AnalysisListViewItem*>(it) );
}

/*------------------------------------------------------------------------ */
AnalysisListViewItem* Analysis::locationItemById(const QString& locId)
{
AnalysisListViewItem* it;

it = lvDict[locId];
if(it == 0)
  it = lvDictHidden[locId];

return(it);
}

/*------------------------------------------------------------------------ */
SetiLoc* Analysis::getLocation(AnalysisListViewItem* it)
{
SetiLoc* loc = 0;

if(it)
  loc = Ksetiwatch::getLocation(it->text(ColLocation));

return( loc );
}

/*------------------------------------------------------------------------ */
SetiLoc* Analysis::selectedLocation()
{
return(getLocation(selectedItem()));
}

/*------------------------------------------------------------------------ */
void Analysis::handleNewSelection(QListViewItem* it)
{
SetiLoc* loc(0);

if(it) loc = getLocation((AnalysisListViewItem*)it);
emit selectionChanged(loc);
}

/*------------------------------------------------------------------------ */
void Analysis::setSelectedLocation(const QString& lid)
{
AnalysisListViewItem* it = lvDict[lid];
if(it) LocListView->setSelected(it, true);
}

/*------------------------------------------------------------------------ */
void Analysis::slotAskForLocation()
{
int retval;

if(Ksetiwatch::locationList().count() == 0)
  {
  retval = KMessageBox::questionYesNo(this,
                             i18n("It appears that you haven't configured\n"
                                  "a SETI@home location. Would you like\n"
                                  "to add one to the list?"));
  if(retval == KMessageBox::Yes)
    {
    handlePopupCommand(PopupAdd);
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotStartAll()
{
for(SetiLoc* loc=Ksetiwatch::locationList().first(); loc != 0;
    loc=Ksetiwatch::locationList().next())
  {
  if(loc->isClientRunning(true) == false) loc->startClient();
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotStopAll()
{
for(SetiLoc* loc=Ksetiwatch::locationList().first(); loc != 0;
    loc=Ksetiwatch::locationList().next())
  {
  if(loc->isClientRunning(true)) loc->stopClient();
  }
}

/*------------------------------------------------------------------------ */
void Analysis::slotAdjustAllStatusIcons(int col, int, int)
{
if(col == ColStatus)
  {
  for(SetiLoc* loc=Ksetiwatch::locationList().first(); loc != 0;
      loc=Ksetiwatch::locationList().next())
    {  
    centerStatusIcon(locationItemById(loc->id()), loc->clientState());
    }
  }
}

/*------------------------------------------------------------------------ */
void Analysis::centerStatusIcon(QListViewItem* it, int state)
{
if(it)
  {
  // center the pixmap in the column (why can't Qt handle this?)
  int cw = it->listView()->columnWidth(ColStatus);
  if(cw < 24)
    cw = 24;

  QPixmap stpix((cw + StatusIcon[state].width())/2, 16);
  QPainter p(&stpix);
  p.fillRect(0, 0, (cw + StatusIcon[state].width())/2, 16, white);
  p.drawPixmap((cw - StatusIcon[state].width())/2, 0, StatusIcon[state]);
  p.end();

  stpix.setMask( stpix.createHeuristicMask() );
  it->setPixmap(ColStatus, stpix);
  }
}

#include "analysis.moc"

This file is part of the documentation for Ksetiwatch API Version 2.6.1.

Documentation copyright © 2000-2003 Gordon Machel.
Generated on Fri Jun 6 00:28:13 2003 by doxygen 1.2.18, written by Dimitri van Heesch, © 1997-2002