Public Slots | Signals | Public Member Functions
ThreadLauncher Class Reference

#include <ThreadLauncher.h>

List of all members.

Public Slots

void applyAllSelected ()
void clear ()
void dequeueAll ()
void importModels ()
InversionThread * newThread ()
void processFinished ()
void remove ()
void show (bool s)
void start ()
void stop ()

Signals

void setCurrentRuns (ThreadList tList)

Public Member Functions

bool assumeAllSelected (QString title, QString action)
bool isAnySelected ()
bool isQueued () const
QString processBaseName (QString str)
QString processCompleteName (QString str, int num)
int processNameRank (QString str)
 ThreadLauncher (QWidget *parent=0)
void wait ()
 ~ThreadLauncher ()

Constructor & Destructor Documentation

ThreadLauncher::ThreadLauncher ( QWidget *  parent = 0)

References applyAllSelected(), and TRACE.

    : QWidget(parent)
{
  TRACE;
  _runningProcess=0;

  setupUi(this);

  threadTable->setModel(new LaunchThreadItem(this) );
  LaunchThreadDelegate * del=new LaunchThreadDelegate(this);
  threadTable->setItemDelegate(del);
  threadTable->setSelectionBehavior(QAbstractItemView::SelectRows);
  threadTable->setSelectionMode(QAbstractItemView::ExtendedSelection);
  threadTable->setEditTriggers(QAbstractItemView::AllEditTriggers);
  threadTable->resizeColumnsToContents();
  Settings::columnWidth(threadTable, "ThreadLauncher");

  connect(del, SIGNAL(dataChanged()), this, SLOT(applyAllSelected()) );
  connect(threadTable->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection & )),
          this, SLOT(selectionChanged()));
}
ThreadLauncher::~ThreadLauncher ( )

References TRACE.

{
  TRACE;
  Settings::setColumnWidth(threadTable, "ThreadLauncher");
}

Member Function Documentation

void ThreadLauncher::applyAllSelected ( ) [slot]

References TRACE.

Referenced by ThreadLauncher().

{
  TRACE;
  QAbstractItemModel& model=*threadTable->model();
  QModelIndex curIndex=threadTable->currentIndex();
  QModelIndexList l=threadTable->selectionModel()->selectedRows();
  if(l.count()>1) {
    QVariant val=model.data(curIndex);
    QModelIndex index;
    foreach(index, l) {
      model.setData(model.index(index.row(), curIndex.column()), val);
    }
  }
}
bool ThreadLauncher::assumeAllSelected ( QString  title,
QString  action 
)

Prompt user if he wants to slect all of them. Return true if so. The processes are not really selected.

References MSG_ID, QGpCoreTools::tr(), and TRACE.

Referenced by clear(), remove(), start(), and stop().

{
  TRACE;
  if(Message::question(MSG_ID, title,
                              tr( "No run selected, do you want to %1 all of them?" ).arg(action),
                              Message::yes(), Message::cancel())==Message::Answer1) {
    return false;
  }
  return true;
}
void ThreadLauncher::clear ( ) [slot]

References assumeAllSelected(), dinverGui, isAnySelected(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  bool selectAll;
  if( !isAnySelected()) {
    if(assumeAllSelected( tr( "Clearing inversion run" ), tr("clear")) )
      selectAll=true;
    else
      return;
  } else selectAll=false;

  int n=dinverGui->threads().count();
  for(int i=0;i < n;i++ ) {
    if(selectAll || threadTable->isThreadSelected(i)) {
      dinverGui->clearThread(dinverGui->threads().at(i));
    }
  }
  dinverGui->setModified(true);
  dinverGui->bigBen().synchronize();
}
void ThreadLauncher::dequeueAll ( ) [inline, slot]

Referenced by DinverGui::stopAll().

{_processToStart.clear();}
void ThreadLauncher::importModels ( ) [slot]

References dinverGui, InversionThread::importModels(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  InversionThread * t=threadTable->currentEditableThread();
  if(t) {
    QString reportName=Message::getOpenFileName(tr("Importing models"),
                                                   tr("Inversion report file (*.report)"));
    if(!reportName.isEmpty() && !t->isRunning()) {
      t->importModels(reportName);
      dinverGui->status()->synchronize();
    }
  }
}
bool ThreadLauncher::isAnySelected ( )

Return true is at least one process is selected

References TRACE.

Referenced by clear(), remove(), start(), and stop().

{
  TRACE;
  QModelIndexList l=threadTable->selectionModel()->selectedIndexes();
  return !l.isEmpty();
}
bool ThreadLauncher::isQueued ( ) const [inline]

Referenced by DinverGui::stopAll().

{return !_processToStart.isEmpty();}
InversionThread * ThreadLauncher::newThread ( ) [slot]

References DinverCore::RealSpace::adjustRanges(), DinverCore::AbstractForward::clone(), dinverGui, DinverCore::RealSpace::humanInfo(), MSG_ID, DinverCore::AbstractForward::parameterSpace(), processBaseName(), processCompleteName(), processNameRank(), InversionThread::setForward(), InversionThread::setObjectName(), InversionThread::setReportDir(), InversionThread::setStorage(), InversionThread::setTuningParameters(), DinverCore::RealSpace::setVariableParameters(), str, QGpCoreTools::tr(), TRACE, and DinverCore::RealSpace::variableParameterCount().

{
  TRACE;
  int i=dinverGui->threads().count();
  QString runName;
  InversionThread * lastT=0;
  if(i==0) {
    runName="run_01";
  } else {
    lastT=dinverGui->threads().at(i-1);
    QString str=lastT->objectName();
    runName=processCompleteName(processBaseName( str), processNameRank(str) + 1);
  }
  InversionThread * t=new InversionThread;
  t->setObjectName(runName);
  dinverGui->logs()->setViewName(t, runName);
  StreamRedirection sr(&App::stream(t));
  AbstractForward * forwardTemplate=dinverGui->plugin()->createForward();
  if(!dinverGui->plugin()->initForward(forwardTemplate)) {
    Message::warning(MSG_ID, tr("New thread"), tr("Error creating a new inversion thread.\n\n%1")
                  .arg(dinverGui->logs()->text(t)), Message::ok());
    delete forwardTemplate;
    delete t;
    return 0;
  }
  AbstractForward * forward=forwardTemplate->clone();
  delete forwardTemplate;
  RealSpace& parameterSpace=forward->parameterSpace();
  parameterSpace.setVariableParameters();
  if(parameterSpace.variableParameterCount()<=0) {
    Message::warning(MSG_ID, tr("New thread"), tr("No variable parameters, check parameterization.\n\n%1")
                .arg(dinverGui->logs()->text(t)), Message::ok());
    delete forward;
    delete t;
    return 0;
  }
  if(!parameterSpace.adjustRanges()) {
    Message::warning(MSG_ID, tr("New thread"), tr("Error creating a new inversion thread.\n\n%1")
                .arg(dinverGui->logs()->text(t)), Message::ok());
    delete forward;
    delete t;
    return 0;
  }
  parameterSpace.humanInfo();
  t->setForward(forward);
  t->setStorage();
  t->setReportDir(dinverGui->currentReportDir());
  if(lastT) t->setTuningParameters(lastT);
  dinverGui->addThread(t);
  dinverGui->setModified(true);
  return t;
}
QString ThreadLauncher::processBaseName ( QString  str)

References str, and TRACE.

Referenced by newThread().

{
  TRACE;
  if(str.contains( "_" )) {
    bool ok;
    QString sufix=str.section( '_', -1);
    sufix.toInt(&ok);
    if(ok) return str.left(str.length() - sufix.length() - 1);
  }
  return str;
}
QString ThreadLauncher::processCompleteName ( QString  str,
int  num 
)

References TRACE.

Referenced by newThread().

{
  TRACE;
  if(num < 10) {
    str += "_0%1";
    return str.arg(num);
  } else {
    str += "_%1";
    return str.arg(num);
  }
}
void ThreadLauncher::processFinished ( ) [slot]

References DinverCore::dinverCore, QGpCoreTools::endl(), DinverCore::DinverCoreObject::showMessage(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  InversionThread * t=qobject_cast<InversionThread *>(sender());
  _runningProcess--;
  QString msg=tr(":-) Process %1 finished, %2 are running, %3 are queued")
              .arg(t ? t->objectName() : QString::null)
                          .arg(_runningProcess)
                          .arg(_processToStart.count());
  App::stream() << msg << endl;
  dinverCore->showMessage(msg);
  startQueued();
}
int ThreadLauncher::processNameRank ( QString  str)

References TRACE.

Referenced by newThread().

{
  TRACE;
  if(str.contains( "_" )) {
    bool ok;
    int num=str.section( '_', -1).toInt(&ok);
    if(ok) return num;
  }
  return 1;
}
void ThreadLauncher::remove ( ) [slot]

References assumeAllSelected(), dinverGui, isAnySelected(), InversionThread::terminate(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  if( !isAnySelected()) {
    if(assumeAllSelected( tr( "Removing inversion run" ), tr("remove")) ) {
      if(!dinverGui->closeAllPSViewers()) return;
      for(int i=dinverGui->threads().count()-1;i >= 0 ;i-- ) {
          dinverGui->removeThread(dinverGui->threads().at(i));
      }
    }
  } else {
    if(!dinverGui->closeAllPSViewers()) return;

    QModelIndexList l=threadTable->selectionModel()->selectedRows();
    // First store pointers to remove
    QList<InversionThread *> tList;
    for(int i=l.count()-1; i>=0; i-- ) {
      tList.append(dinverGui->threads().at(l.at(i).row()));
    }
    for(int i=tList.count()-1; i>=0; i-- ) {
      InversionThread * t=tList.at(i);
      if(t->isRunning()) {
        t->terminate();
      }
      int indexToStart=_processToStart.indexOf(t);
      if(indexToStart>=0) {
        _processToStart.removeAt(indexToStart);
      }
      dinverGui->removeThread(t);
    }
  }
  dinverGui->setModified(true);
}
void ThreadLauncher::setCurrentRuns ( ThreadList  tList) [signal]
void ThreadLauncher::show ( bool  s) [slot]

References TRACE.

{
  TRACE;
  selectionChanged();
}
void ThreadLauncher::start ( ) [slot]

References assumeAllSelected(), dinverGui, isAnySelected(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  bool selectAll;
  if( !isAnySelected()) {
    if(assumeAllSelected( tr( "Starting inversion run" ), tr("start")) )
      selectAll=true;
    else
      return;
  } else selectAll=false;

  MessageContext mc;
  int n=dinverGui->threads().count();
  for(int i=0;i < n;i++ ) {
    if(selectAll || threadTable->isThreadSelected(i) ) {
      InversionThread * t=dinverGui->threads().at(i);
      start(t);
    }
  }
  startQueued();
}
void ThreadLauncher::stop ( ) [slot]

References assumeAllSelected(), dinverGui, isAnySelected(), InversionThread::terminate(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  bool selectAll;
  if( !isAnySelected()) {
    if(assumeAllSelected(tr("Stoping inversion run"), tr("stop")))
      selectAll=true;
    else
      return;
  } else selectAll=false;

  int n=dinverGui->threads().count();
  for(int i=0;i < n;i++ ) {
    if(selectAll || threadTable->isThreadSelected(i)) {
      InversionThread * t=dinverGui->threads().at(i);
      t->terminate();
      for(int i=0; i<_processToStart.count();) {
        if(_processToStart.at(i)==t) {
          _processToStart.removeAt(i);
        } else {
          i++;
        }
      }
    }
  }
  startQueued();
}
void ThreadLauncher::wait ( )

Wait until all processes are finished (even the queued ones).

References TRACE.

{
  TRACE;
  while(_runningProcess>0 || !_processToStart.empty()) {
    App::sleep(1000);
    QCoreApplication::processEvents();
  }
}
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines

Modified 2013-10-22

Valid CSS! Valid XHTML 1.0!