void
PlayerConnection::onStopped()
{
m_track = Track();
if (m_state == Stopped)
{
qWarning() << "Already stopped";
}
else
{
m_state = Stopped;
m_elapsed = 0;
emit stopped();
}
}
void PlaceSoundModel::onChildSoundStopped(){
SoundModel* senderSound = ((SoundModel*)QObject::sender());
if( senderSound->type() != SoundModel::TYPE_ONE_SHOT ){
--m_playingChildrenSounds;
qDebug() << "Place : Sound Stopped : " << senderSound->name() << " (" << m_playingChildrenSounds << ")";
if( senderSound == m_mainSound ){
m_mainSound = NULL;
}
// Check for stopped signal
if(m_playingChildrenSounds < 1){
emit stopped();
}
}
}
/**
Updates the gyro bias raw values
*/
void GyroBiasCalibrationModel::getSample(UAVObject *obj)
{
QMutexLocker lock(&sensorsUpdateLock);
switch (obj->getObjID()) {
case GyroState::OBJID:
{
GyroState::DataFields gyroStateData = gyroState->getData();
gyro_state_accum_x.append(gyroStateData.x);
gyro_state_accum_y.append(gyroStateData.y);
gyro_state_accum_z.append(gyroStateData.z);
break;
}
case GyroSensor::OBJID:
{
GyroSensor::DataFields gyroSensorData = gyroSensor->getData();
gyro_accum_x.append(gyroSensorData.x);
gyro_accum_y.append(gyroSensorData.y);
gyro_accum_z.append(gyroSensorData.z);
break;
}
default:
Q_ASSERT(0);
}
// Work out the progress based on whichever has less
double p1 = (double)gyro_state_accum_x.size() / (double)LEVEL_SAMPLES;
double p2 = (double)gyro_accum_y.size() / (double)LEVEL_SAMPLES;
progressChanged(((p1 > p2) ? p1 : p2) * 100);
if ((gyro_accum_y.size() >= LEVEL_SAMPLES || (gyro_accum_y.size() == 0 && gyro_state_accum_y.size() >= LEVEL_SAMPLES)) &&
collectingData == true) {
collectingData = false;
m_dirty = true;
disconnect(gyroSensor, SIGNAL(objectUpdated(UAVObject *)), this, SLOT(getSample(UAVObject *)));
disconnect(gyroState, SIGNAL(objectUpdated(UAVObject *)), this, SLOT(getSample(UAVObject *)));
gyroState->setMetadata(memento.gyroStateMetadata);
gyroSensor->setMetadata(memento.gyroSensorMetadata);
revoCalibration->setData(memento.revoCalibrationData);
attitudeSettings->setData(memento.attitudeSettingsData);
stopped();
displayInstructions(tr("Gyroscope calibration completed successfully."), WizardModel::Success);
displayVisualHelp(CALIBRATION_HELPER_IMAGE_EMPTY);
}
PlaybackControlsWidget::PlaybackControlsWidget(QWidget *parent) :
StylableWidget(parent),
ui(new Ui::PlaybackControlsWidget),
m_scrobbleTrack( false )
{
ui->setupUi(this);
ui->play->setAttribute( Qt::WA_LayoutUsesWidgetRect );
ui->ban->setAttribute( Qt::WA_LayoutUsesWidgetRect );
ui->love->setAttribute( Qt::WA_LayoutUsesWidgetRect );
ui->skip->setAttribute( Qt::WA_LayoutUsesWidgetRect );
ui->play->setAttribute( Qt::WA_MacNoClickThrough );
ui->ban->setAttribute( Qt::WA_MacNoClickThrough );
ui->love->setAttribute( Qt::WA_MacNoClickThrough );
ui->skip->setAttribute( Qt::WA_MacNoClickThrough );
// If the actions are triggered we should do something
// love is dealt with by the application
connect( aApp->banAction(), SIGNAL(triggered(bool)), SLOT(onBanClicked()) );
connect( aApp->playAction(), SIGNAL(triggered(bool)), SLOT(onPlayClicked(bool)) );
connect( aApp->skipAction(), SIGNAL(triggered(bool)), SLOT(onSkipClicked()) );
m_playAction = new QAction( tr( "Play" ), aApp );
connect( m_playAction, SIGNAL(triggered(bool)), aApp->playAction(), SLOT(trigger()) );
connect( aApp->playAction(), SIGNAL(toggled(bool)), m_playAction, SLOT(setChecked(bool)) );
// make sure this widget updates if the actions are changed elsewhere
connect( aApp->loveAction(), SIGNAL(changed()), SLOT(onActionsChanged()) );
connect( aApp->banAction(), SIGNAL(changed()), SLOT(onActionsChanged()) );
connect( aApp->playAction(), SIGNAL(changed()), SLOT(onActionsChanged()) );
connect( aApp->skipAction(), SIGNAL(changed()), SLOT(onActionsChanged()) );
connect( &RadioService::instance(), SIGNAL(tuningIn(RadioStation)), SLOT(onTuningIn(RadioStation)));
connect( &RadioService::instance(), SIGNAL(error(int,QVariant)), SLOT(onError(int, QVariant)));
connect( &ScrobbleService::instance(), SIGNAL(trackStarted(Track,Track)), SLOT(onTrackStarted(Track,Track)) );
connect( &ScrobbleService::instance(), SIGNAL(stopped()), SLOT(onStopped()));
connect( &ScrobbleService::instance(), SIGNAL(scrobblingOnChanged(bool)), SLOT(update()));
onActionsChanged();
// if our buttons are pressed we should trigger the actions
connect( ui->love, SIGNAL(clicked()), aApp->loveAction(), SLOT(trigger()));
connect( ui->ban, SIGNAL(clicked()), aApp->banAction(), SLOT(trigger()));
connect( ui->play, SIGNAL(clicked()), aApp->playAction(), SLOT(trigger()));
connect( ui->skip, SIGNAL(clicked()), aApp->skipAction(), SLOT(trigger()));
}
void Player::connectTransport(const TransportControllable* receiver)
{
if (receiver == m_currentTransport) return;
if (m_currentTransport)
disconnect(m_currentTransport);
m_currentTransport = receiver;
connect(this, SIGNAL(played(double)), receiver, SLOT(play(double)));
connect(this, SIGNAL(paused()), receiver, SLOT(pause()));
connect(this, SIGNAL(stopped()), receiver, SLOT(stop()));
connect(this, SIGNAL(seeked(int)), receiver, SLOT(seek(int)));
connect(this, SIGNAL(rewound()), receiver, SLOT(rewind()));
connect(this, SIGNAL(fastForwarded()), receiver, SLOT(fastForward()));
connect(this, SIGNAL(previousSought(int)), receiver, SLOT(previous(int)));
connect(this, SIGNAL(nextSought(int)), receiver, SLOT(next(int)));
connect(this, SIGNAL(inChanged(int)), receiver, SLOT(setIn(int)));
connect(this, SIGNAL(outChanged(int)), receiver, SLOT(setOut(int)));
}
// Signals the service stopped if the stopped condition is met.
//
void checkStopped (ScopedLock const& lock)
{
// We are stopped when all of the following are true:
//
// 1. A stop notification was received
// 2. All Stoppable children have stopped
// 3. There are no executing calls to processTask
// 4. There are no remaining Jobs in the job set
//
if (isStopping() &&
areChildrenStopped() &&
(m_processCount == 0) &&
m_jobSet.empty())
{
stopped();
}
}
void SimpleDesk::initPlaybackSliders()
{
qDebug() << Q_FUNC_INFO;
for (uint i = 0; i < m_playbacksPerPage; i++)
{
PlaybackSlider* slider = new PlaybackSlider(m_playbackGroup);
m_playbackGroup->layout()->addWidget(slider);
slider->setLabel(QString::number(i + 1));
slider->setProperty(PROP_PLAYBACK, uint(i));
m_playbackSliders << slider;
connect(slider, SIGNAL(selected()), this, SLOT(slotPlaybackSelected()));
connect(slider, SIGNAL(started()), this, SLOT(slotPlaybackStarted()));
connect(slider, SIGNAL(stopped()), this, SLOT(slotPlaybackStopped()));
connect(slider, SIGNAL(flashing(bool)), this, SLOT(slotPlaybackFlashing(bool)));
connect(slider, SIGNAL(valueChanged(uchar)), this, SLOT(slotPlaybackValueChanged(uchar)));
}
}
bool VideoHttpBuffer::startBuffering()
{
Q_ASSERT(!media);
media = bcApp->mediaDownloadManager()->acquireMediaDownload(m_url);
connect(media, SIGNAL(fileSizeChanged(uint)), SLOT(fileSizeChanged(uint)), Qt::DirectConnection);
connect(media, SIGNAL(finished()), SIGNAL(bufferingFinished()));
connect(media, SIGNAL(stopped()), SIGNAL(bufferingStopped()));
connect(media, SIGNAL(error(QString)), SLOT(sendStreamError(QString)));
media->start();
qDebug("VideoHttpBuffer: started");
emit bufferingStarted();
return true;
}
void run ()
{
m_journal.debug << "Started";
init ();
while (! this->threadShouldExit())
{
this->wait ();
if (! this->threadShouldExit())
{
doLedgerCleaner();
}
}
stopped();
}
void run ()
{
m_journal.debug << "started";
init ();
while (! this->threadshouldexit())
{
this->wait ();
if (! this->threadshouldexit())
{
doledgercleaner();
}
}
stopped();
}
void Gdb::parse(const QByteArray& inputs)
{
foreach(const QByteArray& input, inputs.split('\n')) {
qWarning() << "line" << input;
if(input.startsWith("~")) { if(m_responder) { m_responder->writeDebugState(cString(input.data(), 1)); } }
else if(input.startsWith("^error")) { if(m_responder) { m_responder->writeStderr(cString(input.data(), after(input.data(), "msg="))); } }
else if(input.startsWith("^done,stack=")) stack(input.data());
else if(input.startsWith("^done,stack-args=")) stackArgs(input.data());
else if(input.startsWith("^done,locals=")) locals(input.data());
else if(input.startsWith("^done,BreakpointTable=")) breakpointTable(input.data());
else if(input.startsWith("^done,bkpt="));
else if(input.startsWith("^done")) { if(m_responder) { m_responder->writeDebugState(cString(input.data(), after(input.data(), "reason="))); } }
else if(input.startsWith("*stopped")) stopped(input.data());
else if(input.startsWith("=shlibs-added")) m_libs += shlibsAdded(input.data());
}
if(m_responder) m_responder->update();
}
virtual void stop() {
ThreadPool::stop();
while (stopped() == false) {
std::this_thread::yield();
_in.advanceWritePos();
_in.signalNonEmpty();
}
_stopManager = true;
while (_managerStopped == false) {
std::this_thread::yield();
_in.advanceWritePos();
_in.signalNonEmpty();
_endSignaled++;
_ended.notify_one();
}
}
void
EIBNetIPRouter::start()
{
struct sockaddr_in baddr;
struct ip_mreq mcfg;
TRACEPRINTF (t, 2, "Open");
memset (&baddr, 0, sizeof (baddr));
#ifdef HAVE_SOCKADDR_IN_LEN
baddr.sin_len = sizeof (baddr);
#endif
baddr.sin_family = AF_INET;
baddr.sin_port = htons (port);
baddr.sin_addr.s_addr = htonl (INADDR_ANY);
sock = new EIBNetIPSocket (baddr, 1, t);
if (!sock->init ())
goto err_out;
sock->on_recv.set<EIBNetIPRouter,&EIBNetIPRouter::read_cb>(this);
if (! sock->SetInterface(interface))
{
ERRORPRINTF (t, E_ERROR | 58, "interface %s not recognized", interface);
goto err_out;
}
sock->recvall = 2;
if (GetHostIP (t, &sock->sendaddr, multicastaddr) == 0)
goto err_out;
sock->sendaddr.sin_port = htons (port);
if (!GetSourceAddress (t, &sock->sendaddr, &sock->localaddr))
goto err_out;
sock->localaddr.sin_port = sock->sendaddr.sin_port;
mcfg.imr_multiaddr = sock->sendaddr.sin_addr;
mcfg.imr_interface.s_addr = htonl (INADDR_ANY);
if (!sock->SetMulticast (mcfg))
goto err_out;
TRACEPRINTF (t, 2, "Opened");
BusDriver::start();
return;
err_out:
delete sock;
sock = 0;
stopped();
}
void UserProgram::toggleState()
{
QFileInfo robot("/mnt/user/bin/robot");
if(m_userProgram.state() == QProcess::NotRunning) {
if(robot.exists()) {
m_userProgram.start("/mnt/kiss/usercode/run");
}
else {
emit consoleOutput(QString("No program to run!\n"));
}
}
else {
emit consoleOutput(QString("Program Stopped!\n"));
m_userProgram.terminate();
emit stopped();
}
}
void Player::handleButtons()
{
switch(mEngine->state())
{
case KMediaPlayer::Player::Play:
emit playing();
break;
case KMediaPlayer::Player::Pause:
emit paused();
break;
case KMediaPlayer::Player::Stop:
emit stopped();
break;
case KMediaPlayer::Player::Empty:
emit empty();
break;
}
}
void CommandProc::slotProcessExited(KProcess*)
{
kdDebug() << "CommandProc:slotProcessExited: Command process has exited." << endl;
pluginState prevState = m_state;
if (m_waitingStop)
{
m_waitingStop = false;
m_state = psIdle;
emit stopped();
} else {
m_state = psFinished;
if (prevState == psSaying)
emit sayFinished();
else
if (prevState == psSynthing)
emit synthFinished();
}
}
void Shuffle::start(MasterTimer* timer)
{
Q_ASSERT(timer != NULL);
m_masterTimer = timer;
/* No point running this shuffle if it has no steps */
if (m_steps.count() == 0)
{
emit stopped(m_id);
return;
}
/* Current position starts from invalid index because nextStep() is
called first in write(). */
m_runTimePosition = -1;
Function::start(timer);
}
void DisplayServer::finished() {
// check flag
if (!m_started)
return;
// reset flag
m_started = false;
// log message
qDebug() << " DAEMON: Display server stopped.";
// clean up
process->deleteLater();
process = nullptr;
// emit signal
emit stopped();
}
void Function::postRun(MasterTimer* timer, UniverseArray* universes)
{
Q_UNUSED(timer);
Q_UNUSED(universes);
m_stopMutex.lock();
resetElapsed();
resetIntensity();
m_stop = true;
m_overrideFadeInSpeed = defaultSpeed();
m_overrideFadeOutSpeed = defaultSpeed();
m_overrideDuration = defaultSpeed();
m_functionStopped.wakeAll();
m_stopMutex.unlock();
m_running = false;
emit stopped(m_id);
}
QWidget *TcpServerListener::requestGui(QWidget *parent)
{
NetworkConfWidget *ncw = new(std::nothrow)NetworkConfWidget(NetworkConfWidget::TCP_SERVER,parent);
if (ncw == NULL) {
qFatal("Cannot allocate memory for NetworkConfWidget X{");
}
ncw->setPort(port);
ncw->setIP(listeningAddress);
ncw->enableDecodeEncodeOption(true);
connect(ncw, SIGNAL(newIp(QHostAddress)), this, SLOT(setListeningAddress(QHostAddress)));
connect(ncw, SIGNAL(newPort(quint16)), this, SLOT(setPort(quint16)));
connect(ncw, SIGNAL(start()), this, SLOT(startListening()));
connect(ncw, SIGNAL(stop()), this, SLOT(stopListening()));
connect(ncw,SIGNAL(restart()), this, SLOT(restart()));
connect(this, SIGNAL(started()), ncw, SLOT(onServerStarted()));
connect(this, SIGNAL(stopped()), ncw, SLOT(onServerStopped()));
return ncw;
}
void EventHandler::libeventCallback(int fd, short events, void* arg) {
EventHandler* handler = reinterpret_cast<EventHandler*>(arg);
assert(fd == handler->event_.ev_fd);
auto observer = handler->eventBase_->getExecutionObserver();
if (observer) {
observer->starting(reinterpret_cast<uintptr_t>(handler));
}
// this can't possibly fire if handler->eventBase_ is nullptr
(void) handler->eventBase_->bumpHandlingTime();
handler->handlerReady(events);
if (observer) {
observer->stopped(reinterpret_cast<uintptr_t>(handler));
}
}
int Function::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: changed((*reinterpret_cast< t_function_id(*)>(_a[1]))); break;
case 1: flashing((*reinterpret_cast< t_function_id(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
case 2: running((*reinterpret_cast< t_function_id(*)>(_a[1]))); break;
case 3: stopped((*reinterpret_cast< t_function_id(*)>(_a[1]))); break;
case 4: slotFixtureRemoved((*reinterpret_cast< t_fixture_id(*)>(_a[1]))); break;
default: ;
}
_id -= 5;
}
return _id;
}
void HostedObject::requestQueryUpdate(const SpaceID& space, const ObjectReference& oref, const String& new_query) {
if (stopped()) {
HO_LOG(detailed,"Ignoring query update request after system stop.");
return;
}
SpaceObjectReference sporef(space,oref);
Mutex::scoped_lock lock(presenceDataMutex);
PresenceDataMap::iterator pdmIter = mPresenceData.find(sporef);
if (pdmIter != mPresenceData.end()) {
pdmIter->second->query = new_query;
}
else {
SILOG(cppoh,error,"Error in cppoh, requesting solid angle update for presence that doesn't exist in your presence map.");
}
mObjectHost->getQueryProcessor()->updateQuery(getSharedPtr(), sporef, new_query);
}
void
ScrobbleService::onStopped()
{
// We can sometimes get a stopped before a play when the
// media player is playing before the scrobbler is started
if ( state == Unknown ) return;
state = Stopped;
Q_ASSERT(m_watch);
Q_ASSERT(m_connection);
delete m_watch;
if( m_as )
m_as->submit();
emit stopped();
}
TomahawkTrayIcon::TomahawkTrayIcon( QObject* parent )
: QSystemTrayIcon( parent )
, m_currentAnimationFrame( 0 )
, m_showWindowAction( 0 )
{
QIcon icon( RESPATH "icons/tomahawk-icon-128x128.png" );
setIcon( icon );
refreshToolTip();
m_contextMenu = new QMenu();
setContextMenu( m_contextMenu );
ActionCollection *ac = ActionCollection::instance();
m_contextMenu->addAction( ac->getAction( "playPause" ) );
m_contextMenu->addAction( ac->getAction( "stop" ) );
m_contextMenu->addSeparator();
m_contextMenu->addAction( ac->getAction( "previousTrack" ) );
m_contextMenu->addAction( ac->getAction( "nextTrack" ) );
m_contextMenu->addSeparator();
m_contextMenu->addAction( ActionCollection::instance()->getAction( "togglePrivacy" ) );
#ifdef Q_WS_MAC
// On mac you can close the windows while leaving the app open. We then need a way to show the main window again
m_contextMenu->addSeparator();
m_showWindowAction = m_contextMenu->addAction( tr( "Hide Tomahawk Window" ) );
m_showWindowAction->setData( true );
connect( m_showWindowAction, SIGNAL( triggered() ), this, SLOT( showWindow() ) );
#endif
m_contextMenu->addSeparator();
m_contextMenu->addAction( ac->getAction( "quit" ) );
connect( AudioEngine::instance(), SIGNAL( loading( Tomahawk::result_ptr ) ), SLOT( setResult( Tomahawk::result_ptr ) ) );
connect( AudioEngine::instance(), SIGNAL( started( Tomahawk::result_ptr ) ), SLOT( enablePause() ) );
connect( AudioEngine::instance(), SIGNAL( resumed() ), this, SLOT( enablePause() ) );
connect( AudioEngine::instance(), SIGNAL( stopped() ), this, SLOT( enablePlay() ) );
connect( AudioEngine::instance(), SIGNAL( paused() ), this, SLOT( enablePlay() ) );
connect( &m_animationTimer, SIGNAL( timeout() ), SLOT( onAnimationTimer() ) );
connect( this, SIGNAL( activated( QSystemTrayIcon::ActivationReason ) ), SLOT( onActivated( QSystemTrayIcon::ActivationReason ) ) );
show();
}
void Function::postRun(MasterTimer* timer, UniverseArray* universes)
{
Q_UNUSED(timer);
Q_UNUSED(universes);
qDebug() << "Function postRun. ID: " << m_id;
m_stopMutex.lock();
resetElapsed();
resetAttributes();
m_stop = true;
//m_overrideFadeInSpeed = defaultSpeed();
//m_overrideFadeOutSpeed = defaultSpeed();
//m_overrideDuration = defaultSpeed();
m_functionStopped.wakeAll();
m_stopMutex.unlock();
m_running = false;
emit stopped(m_id);
}
void TcpServerListener::handlingClient(int socketDescriptor)
#endif
{
TcpListener * listener = new(std::nothrow) TcpListener(socketDescriptor);
if (listener != NULL) {
// qDebug() << "Listener created" << listener;
listener->setDecodeinput(decodeInput);
listener->setEncodeOutput(encodeOutput);
clients.append(listener);
listener->moveToThread(workerThread);
connect(listener, SIGNAL(blockReceived(Block)), SLOT(onClientReceivedBlock(Block)));
connect(listener, SIGNAL(stopped()), SLOT(clientFinished()));
connect(listener, SIGNAL(error(QString,QString)), SIGNAL(error(QString,QString)));
connect(listener, SIGNAL(status(QString,QString)), SIGNAL(status(QString,QString)));
QTimer::singleShot(0,listener,SLOT(startListening()));
} else {
qFatal("Cannot allocate memory for TcpListener X{");
}
}
SampleParams::SampleParams(Sample * sample, QWidget *parent) :
QWidget(parent),
ui(new Ui::SampleParams)
{
ui->setupUi(this);
mySample = sample;
connect(mySample, SIGNAL(started()), SLOT(onSampleStarted()));
connect(mySample, SIGNAL(stopped()), SLOT(onSampleStopped()));
updateSampleInfo();
connect(ui->volumeSlider, SIGNAL(sliderMoved(int)), mySample, SLOT(setVolume(int)));
connect(ui->volumeSlider, SIGNAL(valueChanged(int)), mySample, SLOT(setVolume(int)));
connect(ui->panDial, SIGNAL(sliderMoved(int)), mySample, SLOT(setPanning(int)));
connect(ui->panDial, SIGNAL(valueChanged(int)), mySample, SLOT(setPanning(int)));
connect(ui->keyCombo, SIGNAL(currentIndexChanged(int)), SLOT(onKeyComboChanged(int)));
connect(ui->noLoopRadio, SIGNAL(toggled(bool)), SLOT(onRadioChanged(bool)));
connect(ui->simpleLoopRadio, SIGNAL(toggled(bool)), SLOT(onRadioChanged(bool)));
connect(ui->autoLoopRadio, SIGNAL(toggled(bool)), SLOT(onRadioChanged(bool)));
connect(ui->muteButton, SIGNAL(toggled(bool)), mySample, SLOT(setMute(bool)));
}
void AVPlayer::stop()
{
if (!isPlaying())
return;
qDebug("AVPlayer::stop");
//blockSignals(true); //TODO: move emit stopped() before it. or connect avthread.finished() to tryEmitStop() {if (!called_by_stop) emit}
struct avthreads_t {
AVThread *thread;
const char *name;
} threads[] = {
{ audio_thread, "audio thread" },
{ video_thread, "video thread" },
{ 0, 0 }
};
for (int i = 0; threads[i].name; ++i) {
AVThread *thread = threads[i].thread;
if (!thread)
continue;
if (thread->isRunning()) {
qDebug("stopping %s...", threads[i].name);
//avoid emit stopped multiple times. AVThread.stopped() connects to AVDemuxThread.stopped().
thread->blockSignals(true);
thread->stop();
if (!thread->wait(1000)) {
qWarning("Timeout waiting for %s stopped. Terminate it.", threads[i].name);
thread->terminate();
}
thread->blockSignals(false);
}
}
//stop demux thread after avthread is better. otherwise demux thread may be terminated when waiting for avthread ?
if (demuxer_thread->isRunning()) {
qDebug("stopping demux thread...");
demuxer_thread->stop();
//wait for finish then we can safely set the vars, e.g. a/v decoders
if (!demuxer_thread->wait(1000)) {
qWarning("Timeout waiting for demux thread stopped. Terminate it.");
demuxer_thread->terminate(); //Terminate() causes the wait condition destroyed without waking up
}
}
qDebug("all threads [a|v|d] stopped...");
emit stopped();
}
void onStop ()
{
#if RIPPLE_USE_VALIDATORS
m_journal.info << "Validators stopping";
#endif
m_logic.stop ();
if (this->Thread::isThreadRunning())
{
m_journal.debug << "Signaling thread exit";
m_queue.dispatch (m_context.wrap (bind (
&Thread::signalThreadShouldExit, this)));
}
else
{
stopped();
}
}
