void RDCueEdit::stateChangedData(int id,RDPlayDeck::State state)
{
if(id!=RDPLAYDECK_AUDITION_ID) {
return;
}
switch(state) {
case RDPlayDeck::Playing:
Playing(id);
break;
case RDPlayDeck::Stopping:
break;
case RDPlayDeck::Paused:
Paused(id);
break;
case RDPlayDeck::Stopped:
Stopped(id);
break;
case RDPlayDeck::Finished:
Stopped(id);
break;
}
}
void PlaylistView::SetApplication(Application* app) {
Q_ASSERT(app);
app_ = app;
connect(app_->current_art_loader(),
SIGNAL(ArtLoaded(const Song&, const QString&, const QImage&)),
SLOT(CurrentSongChanged(const Song&, const QString&, const QImage&)));
connect(app_->player(), SIGNAL(Paused()), SLOT(StopGlowing()));
connect(app_->player(), SIGNAL(Playing()), SLOT(StartGlowing()));
connect(app_->player(), SIGNAL(Stopped()), SLOT(StopGlowing()));
connect(app_->player(), SIGNAL(Stopped()), SLOT(PlayerStopped()));
}
void QmitkToolPairNavigationView::SetNavigationUp()
{
if (m_Source.IsNotNull())
if (m_Source->IsTracking())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if (ds == NULL)
{
QMessageBox::warning(NULL, "ToolPairNavigation: Error", "can not access DataStorage. Navigation not possible");
return;
}
//1. build up the filter pipeline
try
{
this->SetupIGTPipeline();
}
catch(std::exception& e)
{
QMessageBox::warning(NULL, "ToolPairNavigation: Error", QString("Error while building the IGT-Pipeline: %1").arg(e.what()));
this->DestroyIGTPipeline();
return;
}
catch (...)
{
QMessageBox::warning(NULL, "ToolPairNavigation: Error", QString("Error while building the IGT-Pipeline."));
this->DestroyIGTPipeline();
return;
}
//2. start IGT pipeline to display tracking devices (20 Hz update rate -> 50 msec timeout)
try
{
// setup for the bundle's update timer widget
m_Controls.m_RenderingTimerWidget->SetPurposeLabelText(QString("Navigation"));
m_Controls.m_RenderingTimerWidget->SetTimerInterval( 50 );
connect( m_Controls.m_RenderingTimerWidget->GetUpdateTimer() , SIGNAL(timeout()) , this, SLOT (RenderScene()) );
connect( m_Controls.m_RenderingTimerWidget, SIGNAL(Started()), this, SLOT(StartNavigation()));
connect( m_Controls.m_RenderingTimerWidget, SIGNAL(Stopped()) , this, SLOT (StopNavigation()));
connect( m_Controls.m_RenderingTimerWidget, SIGNAL(Stopped()) , m_DistanceWidget, SLOT (SetDistanceLabelValuesInvalid()));
}
catch(std::exception& e)
{
QMessageBox::warning(NULL, "ToolPairNavigation: Error", QString("Error while starting the IGT-Pipeline: %1").arg(e.what()));
this->m_Controls.m_RenderingTimerWidget->StopTimer();
this->DestroyIGTPipeline();
return;
}
}
Remote::Remote(Player* player, QObject* parent)
: QObject(parent),
player_(player),
connection_(new xrme::Connection(this)),
retry_count_(0)
{
connection_->SetMediaPlayer(this);
connection_->SetMediaStorage(this);
connection_->set_verbose(true);
connect(connection_, SIGNAL(Connected()), SLOT(Connected()));
connect(connection_, SIGNAL(Disconnected(QString)), SLOT(Disconnected(QString)));
connect(player_, SIGNAL(Playing()), SLOT(SetStateChanged()));
connect(player_, SIGNAL(Paused()), SLOT(SetStateChanged()));
connect(player_, SIGNAL(Stopped()), SLOT(SetStateChanged()));
connect(player_, SIGNAL(PlaylistFinished()), SLOT(SetStateChanged()));
connect(player_, SIGNAL(VolumeChanged(int)), SLOT(SetStateChanged()));
connect(player_, SIGNAL(Seeked(qlonglong)), SLOT(SetStateChanged()));
connect(player_->playlists(), SIGNAL(CurrentSongChanged(Song)), SLOT(SetStateChanged()));
connect(connection_,
SIGNAL(TomahawkSIPReceived(const QVariant&)),
SLOT(TomahawkSIPReceived(const QVariant&)));
ReloadSettings();
}
void WaypointMovementGenerator<Creature>::StartMove(Creature &creature)
{
if (!i_path || i_path->empty())
return;
if (Stopped())
return;
if (WaypointBehavior *behavior = i_path->at(i_currentNode).behavior)
{
if (behavior->model2 != 0)
creature.SetDisplayId(behavior->model2);
creature.SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
}
if (m_isArrivalDone)
i_currentNode = (i_currentNode+1) % i_path->size();
m_isArrivalDone = false;
if (creature.CanFly())
creature.AddSplineFlag(SPLINEFLAG_FLYING);
creature.addUnitState(UNIT_STAT_ROAMING_MOVE);
const WaypointNode &node = i_path->at(i_currentNode);
CreatureTraveller traveller(creature);
i_destinationHolder.SetDestination(traveller, node.x, node.y, node.z);
}
void ConnectionManager::HandleEdgeClose()
{
Edge *edge = qobject_cast<Edge *>(sender());
_active_addrs.remove(edge->GetRemoteAddress());
qDebug() << "Edge closed: " << edge->ToString() << edge->GetStoppedReason();
if(!_con_tab.RemoveEdge(edge)) {
qWarning() << "Edge closed but no Edge found in CT:" << edge->ToString();
}
QSharedPointer<Connection> con = _con_tab.GetConnection(edge);
if(con) {
con = _con_tab.GetConnection(con->GetRemoteId());
if(con) {
con->Disconnect();
}
}
if(!Stopped()) {
return;
}
if(_con_tab.GetEdges().count() == 0) {
emit Disconnected();
}
}
void RepeatingBulkRound::IncomingData(const Request ¬ification)
{
if(Stopped()) {
qWarning() << "Received a message on a closed session:" << ToString();
return;
}
QSharedPointer<Connections::IOverlaySender> sender =
notification.GetFrom().dynamicCast<Connections::IOverlaySender>();
if(!sender) {
qDebug() << ToString() << " received wayward message from: " <<
notification.GetFrom()->ToString();
return;
}
const Id &id = sender->GetRemoteId();
if(!GetGroup().Contains(id)) {
qDebug() << ToString() << " received wayward message from: " <<
notification.GetFrom()->ToString();
return;
}
QVariantHash msg = notification.GetData().toHash();
bool bulk = msg.value("bulk").toBool();
if(bulk) {
ProcessData(id, msg.value("data").toByteArray());
} else {
_shuffle_round->IncomingData(notification);
}
}
void PlaylistListContainer::SetApplication(Application* app) {
app_ = app;
PlaylistManager* manager = app_->playlist_manager();
Player* player = app_->player();
connect(manager, SIGNAL(PlaylistAdded(int, QString, bool)),
SLOT(AddPlaylist(int, QString, bool)));
connect(manager, SIGNAL(PlaylistFavorited(int, bool)),
SLOT(PlaylistFavoriteStateChanged(int, bool)));
connect(manager, SIGNAL(PlaylistRenamed(int, QString)),
SLOT(PlaylistRenamed(int, QString)));
connect(manager, SIGNAL(CurrentChanged(Playlist*)),
SLOT(CurrentChanged(Playlist*)));
connect(manager, SIGNAL(ActiveChanged(Playlist*)),
SLOT(ActiveChanged(Playlist*)));
connect(model_, SIGNAL(PlaylistRenamed(int, QString)), manager,
SLOT(Rename(int, QString)));
connect(player, SIGNAL(Paused()), SLOT(ActivePaused()));
connect(player, SIGNAL(Playing()), SLOT(ActivePlaying()));
connect(player, SIGNAL(Stopped()), SLOT(ActiveStopped()));
// Get all playlists, even ones that are hidden in the UI.
for (const PlaylistBackend::Playlist& p :
app->playlist_backend()->GetAllFavoritePlaylists()) {
QStandardItem* playlist_item = model_->NewPlaylist(p.name, p.id);
QStandardItem* parent_folder = model_->FolderByPath(p.ui_path);
parent_folder->appendRow(playlist_item);
}
}
void WaypointMovementGenerator<Creature>::StartMove(Creature& creature)
{
if (!i_path || i_path->empty())
return;
if (Stopped())
return;
if (WaypointBehavior* behavior = i_path->at(i_currentNode).behavior)
{
if (behavior->model2 != 0)
creature.SetDisplayId(behavior->model2);
creature.SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
}
if (m_isArrivalDone)
i_currentNode = (i_currentNode + 1) % i_path->size();
m_isArrivalDone = false;
creature.addUnitState(UNIT_STAT_ROAMING_MOVE);
const WaypointNode& node = i_path->at(i_currentNode);
Movement::MoveSplineInit init(creature);
init.MoveTo(node.x, node.y, node.z, true);
if (node.orientation != 100 && node.delay != 0)
init.SetFacing(node.orientation);
init.SetWalk(!creature.IsLevitating());
init.Launch();
}
void Round::IncomingData(const Request ¬ification)
{
if(Stopped()) {
qWarning() << "Received a message on a closed session:" << ToString();
return;
}
QSharedPointer<Connections::IOverlaySender> sender =
notification.GetFrom().dynamicCast<Connections::IOverlaySender>();
if(!sender) {
qDebug() << ToString() << " received wayward message from: " <<
notification.GetFrom()->ToString();
return;
}
const Id &id = sender->GetRemoteId();
if(!_group.Contains(id)) {
qDebug() << ToString() << " received wayward message from: " <<
notification.GetFrom()->ToString();
return;
}
ProcessData(id, notification.GetData().toHash().value("data").toByteArray());
}
bool WaypointMovementGenerator<Creature>::DoUpdate(Creature* creature, uint32 diff)
{
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (creature->HasUnitState(UNIT_STATE_NOT_MOVE))
{
creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
return true;
}
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
return false;
if (Stopped())
{
if (CanMove(diff))
return StartMove(creature);
}
else
{
// Set home position at place on waypoint movement.
if (!creature->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) || !creature->GetTransGUID())
creature->SetHomePosition(creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ(), creature->GetOrientation());
if (creature->IsStopped())
Stop(STOP_TIME_FOR_PLAYER);
else if (creature->movespline->Finalized())
{
OnArrived(creature);
return StartMove(creature);
}
}
return true;
}
void Session::Registered(const Response &response)
{
if(Stopped()) {
return;
}
if(response.Successful() && response.GetData().toBool()) {
qDebug() << GetPrivateIdentity().GetLocalId() << "registered and waiting to go.";
return;
}
if(!_register_event.Stopped()) {
qDebug() << "Almost started two registration attempts simultaneously!";
return;
}
int delay = 5000;
if(response.GetErrorType() == Response::Other) {
delay = 60000;
}
qDebug() << "Unable to register due to" << response.GetError() <<
"Trying again later.";
Dissent::Utils::TimerCallback *cb =
new Dissent::Utils::TimerMethod<Session, int>(this, &Session::Register, 0);
_register_event = Dissent::Utils::Timer::GetInstance().QueueCallback(cb, delay);
}
bool WaypointMovementGenerator<Creature>::Update(Creature& creature, const uint32& diff)
{
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (creature.hasUnitState(UNIT_STAT_NOT_MOVE))
{
creature.clearUnitState(UNIT_STAT_ROAMING_MOVE);
return true;
}
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
{
creature.clearUnitState(UNIT_STAT_ROAMING_MOVE);
return true;
}
if (Stopped(creature))
{
if (CanMove(diff, creature))
{ StartMove(creature); }
}
else
{
if (creature.IsStopped())
{ Stop(STOP_TIME_FOR_PLAYER); }
else if (creature.movespline->Finalized())
{
OnArrived(creature);
StartMove(creature);
}
}
return true;
}
bool WaypointMovementGenerator<Creature>::DoUpdate(Creature* creature, uint32 diff)
{
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (creature->HasUnitState(UNIT_STATE_NOT_MOVE))
{
creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
return true;
}
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
return false;
if (Stopped())
{
if (CanMove(diff))
return StartMove(creature);
}
else
{
if (creature->IsStopped())
Stop(STOP_TIME_FOR_PLAYER);
else if (creature->movespline->Finalized())
{
OnArrived(creature);
return StartMove(creature);
}
}
return true;
}
bool WaypointMovementGenerator<Creature>::DoUpdate(Creature* creature, uint32 diff)
{
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (creature->HasUnitState(UNIT_STATE_NOT_MOVE))
{
creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
return true;
}
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
return false;
// Xinef: Dont allow dead creatures to move
if (!creature->IsAlive())
return false;
// prevent movement while casting spells with cast time or channel time
if (creature->HasUnitState(UNIT_STATE_CASTING))
{
bool stop = true;
if (Spell* spell = creature->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
if (!(spell->GetSpellInfo()->ChannelInterruptFlags & (AURA_INTERRUPT_FLAG_MOVE | AURA_INTERRUPT_FLAG_TURNING)) && !(spell->GetSpellInfo()->InterruptFlags & SPELL_INTERRUPT_FLAG_MOVEMENT))
stop = false;
if (stop)
{
Stop(1000);
if (!creature->IsStopped())
creature->StopMoving();
return true;
}
}
if (Stopped())
{
if (CanMove(diff))
return StartMove(creature);
}
else
{
if (creature->IsStopped())
Stop(STOP_TIME_FOR_PLAYER);
else
{
// xinef: code to detect pre-empetively if we should start movement to next waypoint
// xinef: do not start pre-empetive movement if current node has delay or we are ending waypoint movement
bool finished = creature->movespline->Finalized();
if (!finished && !i_path->at(i_currentNode)->delay && ((i_currentNode != i_path->size() - 1) || repeating))
finished = (creature->movespline->_Spline().length(creature->movespline->_currentSplineIdx()+1) - creature->movespline->timePassed()) < 200;
if (finished)
{
OnArrived(creature);
return StartMove(creature);
}
}
}
return true;
}
void Session::Challenged(const Response &response)
{
if(Stopped()) {
return;
}
if(response.Successful()) {
QPair<bool, QVariant> auth = _auth->ProcessChallenge(response.GetData());
if(auth.first) {
qDebug() << "Sending challenge response";
SendChallenge(false, auth.second);
return;
}
qDebug() << "Received an invalid challenge, retrying.";
}
if(!_register_event.Stopped()) {
qDebug() << "Almost started two registration attempts simultaneously!";
return;
}
int delay = 5000;
if(response.GetErrorType() == Response::Other) {
delay = 60000;
}
qDebug() << "Unable to register due to" << response.GetError() <<
"Trying again later.";
Dissent::Utils::TimerCallback *cb =
new Dissent::Utils::TimerMethod<Session, int>(this, &Session::Register, 0);
_register_event = Dissent::Utils::Timer::GetInstance().QueueCallback(cb, delay);
}
void WaypointMovementGenerator<Creature>::StartMove(Creature& creature)
{
if (!i_path || i_path->empty())
{ return; }
if (Stopped(creature))
{ return; }
if (!creature.IsAlive() || creature.hasUnitState(UNIT_STAT_NOT_MOVE))
{ return; }
WaypointPath::const_iterator currPoint = i_path->find(i_currentNode);
MANGOS_ASSERT(currPoint != i_path->end());
if (WaypointBehavior* behavior = currPoint->second.behavior)
{
if (behavior->model2 != 0)
{ creature.SetDisplayId(behavior->model2); }
creature.SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
}
if (m_isArrivalDone)
{
bool reachedLast = false;
++currPoint;
if (currPoint == i_path->end())
{
reachedLast = true;
currPoint = i_path->begin();
}
// Inform AI
if (creature.AI() && m_PathOrigin == PATH_FROM_EXTERNAL && m_pathId > 0)
{
if (!reachedLast)
creature.AI()->MovementInform(EXTERNAL_WAYPOINT_MOVE_START + m_pathId, currPoint->first);
else
creature.AI()->MovementInform(EXTERNAL_WAYPOINT_FINISHED_LAST + m_pathId, currPoint->first);
if (creature.IsDead() || !creature.IsInWorld()) // Might have happened with above calls
return;
}
i_currentNode = currPoint->first;
}
m_isArrivalDone = false;
creature.addUnitState(UNIT_STAT_ROAMING_MOVE);
WaypointNode const& nextNode = currPoint->second;;
Movement::MoveSplineInit init(creature);
init.MoveTo(nextNode.x, nextNode.y, nextNode.z, true);
if (nextNode.orientation != 100 && nextNode.delay != 0)
{ init.SetFacing(nextNode.orientation); }
creature.SetWalk(!creature.hasUnitState(UNIT_STAT_RUNNING_STATE) && !creature.IsLevitating(), false);
init.Launch();
}
OFCondition Association::SendObject(DcmFileFormat *dcmff)
{
if (Stopped()) {
return DUL_NETWORKCLOSED;
}
DcmDataset* dataset = dcmff->getDataset();
return SendObject(dataset);
}
/******************************************************************************
* Name: Stop
*
* Description: Tells both motors they need to stop and wait here until they do.
******************************************************************************/
void PairedMotors::Stop(void)
{
right_motor->Stop();
left_motor->Stop();
while (!Stopped());
} // PairedMotors::Stop()
void
VolumeWorker::_Work()
{
list_collection collection;
fVolumeWatcher->GetSecureEntries(collection);
if (collection.createdList->size() == 0
&& collection.deletedList->size() == 0
&& collection.modifiedList->size() == 0
&& collection.movedList->size() == 0)
return;
_SetBusy(true);
for (unsigned int i = 0; i < collection.createdList->size() || Stopped();
i++)
AnalyseEntry((*collection.createdList)[i]);
collection.createdList->clear();
for (unsigned int i = 0; i < collection.deletedList->size() || Stopped();
i++)
DeleteEntry((*collection.deletedList)[i]);
collection.deletedList->clear();
for (unsigned int i = 0; i < collection.modifiedList->size() || Stopped();
i++)
AnalyseEntry((*collection.modifiedList)[i]);
collection.modifiedList->clear();
for (unsigned int i = 0; i < collection.movedList->size() || Stopped();
i++)
MoveEntry((*collection.movedFromList)[i], (*collection.movedList)[i]);
collection.movedList->clear();
collection.movedFromList->clear();
LastEntry();
PostMessage(kTriggerWork);
_SetBusy(false);
}
void RaptorServer::StopAndWait( double max_wait_seconds )
{
Net.DisconnectNice( NULL );
Clock wait_for_stop;
while( IsRunning() )
{
if( (max_wait_seconds > 0) && (wait_for_stop.ElapsedSeconds() > max_wait_seconds) )
break;
}
Data.Clear();
Stopped();
}
bool WaypointMovementGenerator<Creature>::StartMove(Creature &creature)
{
if (!i_path || i_path->empty())
return false;
if (Stopped())
return true;
if (m_isArrivalDone)
{
if ((i_currentNode == i_path->size() - 1) && !repeating) // If that's our last waypoint
{
creature.SetHomePosition(i_path->at(i_currentNode)->x, i_path->at(i_currentNode)->y, i_path->at(i_currentNode)->z, creature.GetOrientation());
creature.GetMotionMaster()->Initialize();
return false;
}
i_currentNode = (i_currentNode+1) % i_path->size();
}
WaypointData const* node = i_path->at(i_currentNode);
if (!node)
return false;
m_isArrivalDone = false;
creature.AddUnitState(UNIT_STATE_ROAMING_MOVE);
Movement::MoveSplineInit init(creature);
init.MoveTo(node->x, node->y, node->z);
//! Accepts angles such as 0.00001 and -0.00001, 0 must be ignored, default value in waypoint table
if (node->orientation && node->delay)
init.SetFacing(node->orientation);
init.SetWalk(!node->run);
init.Launch();
//Call for creature group update
if (creature.GetFormation() && creature.GetFormation()->getLeader() == &creature)
{
creature.SetWalk(!node->run);
creature.GetFormation()->LeaderMoveTo(node->x, node->y, node->z);
}
return true;
}
void DCCConnect::MessageReceived(BMessage* msg)
{
switch (msg->what) {
case M_DCC_STOP_BUTTON: {
Stopped();
} break;
case M_DCC_UPDATE_STATUS: {
fLabel->SetText(msg->FindString("text"));
} break;
case M_DCC_GET_CONNECT_DATA: {
BMessage reply;
reply.AddString("port", fPort.String());
reply.AddString("ip", fIp.String());
reply.AddString("name", fFileName.String());
reply.AddString("nick", fNick.String());
reply.AddString("size", fSize.String());
DCCReceive* recview(dynamic_cast<DCCReceive*>(this));
if (recview != NULL) reply.AddBool("resume", recview->fResume);
DCCSend* sendview(dynamic_cast<DCCSend*>(this));
if (sendview != NULL) reply.AddMessenger("caller", sendview->fCaller);
msg->SendReply(&reply);
} break;
case M_DCC_GET_RESUME_POS: {
BMessage reply;
DCCSend* sendview(dynamic_cast<DCCSend*>(this));
if (sendview != NULL) reply.AddInt32("pos", sendview->fPos);
msg->SendReply(&reply);
} break;
case M_DCC_UPDATE_TRANSFERRED: {
fTotalTransferred = msg->FindInt32("transferred");
} break;
case M_DCC_UPDATE_AVERAGE: {
fFinalRateAverage = msg->FindInt32("average");
} break;
default:
BView::MessageReceived(msg);
}
}
void WaypointMovementGenerator<Creature>::StartMove(Creature& creature)
{
if (!i_path || i_path->empty())
return;
if (Stopped(creature))
return;
if (!creature.isAlive() || creature.hasUnitState(UNIT_STAT_NOT_MOVE))
return;
WaypointPath::const_iterator currPoint = i_path->find(i_currentNode);
BLIZZLIKE_ASSERT(currPoint != i_path->end());
if (WaypointBehavior* behavior = currPoint->second.behavior)
{
if (behavior->model2 != 0)
creature.SetDisplayId(behavior->model2);
creature.SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
}
if (m_isArrivalDone)
{
++currPoint;
if (currPoint == i_path->end())
currPoint = i_path->begin();
i_currentNode = currPoint->first;
}
m_isArrivalDone = false;
creature.addUnitState(UNIT_STAT_ROAMING_MOVE);
WaypointNode const& nextNode = currPoint->second;;
Movement::MoveSplineInit init(creature);
init.MoveTo(nextNode.x, nextNode.y, nextNode.z, true);
if (nextNode.orientation != 100 && nextNode.delay != 0)
init.SetFacing(nextNode.orientation);
creature.SetWalk(!creature.hasUnitState(UNIT_STAT_RUNNING_STATE) && !creature.IsLevitating(), false);
init.Launch();
}
void WaypointMovementGenerator<Creature>::LoadPath(Creature* creature)
{
if (LoadedFromDB)
{
if (!path_id)
path_id = creature->GetWaypointPath();
i_path = sWaypointMgr->GetPath(path_id);
}
if (!i_path)
{
// No path id found for entry
TC_LOG_ERROR("sql.sql", "WaypointMovementGenerator::LoadPath: creature %s (%s DB GUID: " UI64FMTD ") doesn't have waypoint path id: %u", creature->GetName().c_str(), creature->GetGUID().ToString().c_str(), creature->GetSpawnId(), path_id);
return;
}
if (!Stopped())
StartMoveNow(creature);
}
bool WaypointMovementGenerator<Creature>::StartMove(Creature &creature)
{
if (!i_path || i_path->empty())
return false;
if (Stopped())
return true;
const WaypointData *node = i_path->at(i_currentNode);
if (m_isArrivalDone)
{
if ((i_currentNode == i_path->size() - 1) && !repeating) // If that's our last waypoint
{
creature.SetHomePosition(node->x, node->y, node->z, creature.GetOrientation());
creature.GetMotionMaster()->Initialize();
return false;
}
i_currentNode = (i_currentNode+1) % i_path->size();
}
m_isArrivalDone = false;
creature.AddUnitState(UNIT_STAT_ROAMING_MOVE);
Movement::MoveSplineInit init(creature);
init.MoveTo(node->x, node->y, node->z);
if (node->orientation != 100 && node->delay != 0)
init.SetFacing(node->orientation);
init.SetWalk(!node->run);
init.Launch();
//Call for creature group update
if (creature.GetFormation() && creature.GetFormation()->getLeader() == &creature)
creature.GetFormation()->LeaderMoveTo(node->x, node->y, node->z);
return true;
}
OFCondition Association::SendEchoRequest()
{
DIC_US status;
DcmDataset *statusDetail = NULL;
if (Stopped()) {
return DUL_NETWORKCLOSED;
}
OFCondition cond = DIMSE_echoUser(assoc, ++msgId, DIMSE_BLOCKING, 0, &status, &statusDetail);
if (cond.good()) {
LOG_DEBUG(ambitolog, "DIMSE ECHO completed. Status: " << DU_cstoreStatusString(status));
} else {
LOG_DEBUG(ambitolog, "DIMSE ECHO Failed: " << cond.text());
}
if (statusDetail != NULL) {
delete statusDetail;
}
return cond;
}
bool WaypointMovementGenerator<Creature>::Update(Creature &creature, const uint32 &diff)
{
// Waypoint movement can be switched on/off
// This is quite handy for escort quests and other stuff
if (creature.hasUnitState(UNIT_STAT_NOT_MOVE))
{
creature.clearUnitState(UNIT_STAT_ROAMING_MOVE);
return true;
}
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
{
creature.clearUnitState(UNIT_STAT_ROAMING_MOVE);
return true;
}
if (Stopped())
{
if (CanMove(diff))
StartMove(creature);
}
else
{
CreatureTraveller traveller(creature);
if (i_destinationHolder.UpdateTraveller(traveller, diff, false, true) && !IsActive(creature))
return true;
if (creature.IsStopped())
Stop(STOP_TIME_FOR_PLAYER);
if (i_destinationHolder.HasArrived())
{
OnArrived(creature);
StartMove(creature);
}
}
return true;
}
void QmitkIGTTrackingLabView::CreateConnections()
{
connect( m_ToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnToolBoxCurrentChanged(int)) );
//connect( m_NDIConfigWidget, SIGNAL(Connected()), m_RenderingTimerWidget, SLOT(EnableWidget()) );
connect( m_NDIConfigWidget, SIGNAL(Disconnected()), this, SLOT(OnTrackerDisconnected()) );
connect( m_NDIConfigWidget, SIGNAL(Connected()), this, SLOT(OnSetupNavigation()) );
connect( m_NDIConfigWidget, SIGNAL(SignalToolNameChanged(int, QString)), this, SLOT(OnChangeToolName(int, QString)) );
connect( m_NDIConfigWidget, SIGNAL(SignalLoadTool(int, mitk::DataNode::Pointer)), this, SLOT(OnToolLoaded(int, mitk::DataNode::Pointer)) );
connect( m_NDIConfigWidget, SIGNAL(ToolsAdded(QStringList)), this, SLOT(OnToolsAdded(QStringList)) );
connect( m_NDIConfigWidget, SIGNAL(RepresentationChanged( int ,mitk::Surface::Pointer )), this, SLOT(ChangeToolRepresentation( int, mitk::Surface::Pointer )));
connect( m_RegistrationWidget, SIGNAL(AddedTrackingFiducial()), this, SLOT(OnAddRegistrationTrackingFiducial()) );
connect( m_RegistrationWidget, SIGNAL(PerformFiducialRegistration()), this, SLOT(OnRegisterFiducials()) );
connect( m_RenderingTimerWidget, SIGNAL(Started()), this, SLOT(OnStartNavigation()) );
connect( m_RenderingTimerWidget, SIGNAL(Stopped()), this, SLOT(OnStopNavigation()) );
connect( m_VirtualViewToolSelectionWidget, SIGNAL(SignalUseTool(int, bool)), this, SLOT(OnVirtualCamera(int, bool)));
connect( m_PermanentRegistrationToolSelectionWidget, SIGNAL(SignalUseTool(int, bool)), this, SLOT(OnPermanentRegistration(int, bool)) );
}
void BufferEdgeListener::CreateEdgeTo(const Address &to)
{
if(Stopped()) {
qWarning() << "Cannot CreateEdgeTo Stopped EL";
return;
}
if(!Started()) {
qWarning() << "Cannot CreateEdgeTo non-Started EL";
return;
}
const BufferAddress &rem_ba = static_cast<const BufferAddress &>(to);
BufferEdgeListener *remote_el = _el_map.value(rem_ba.GetId());
if(remote_el == 0) {
qDebug() << "Attempting to create an Edge to an EL that doesn't exist from " <<
GetAddress().ToString() << " to " << to.ToString();
ProcessEdgeCreationFailure(to, "No such peer");
return;
}
int delay = Dissent::Utils::Random::GetInstance().GetInt(10, 50);
BufferEdge *local_edge(new BufferEdge(GetAddress(), remote_el->GetAddress(), true, delay));
BufferEdge *remote_edge(new BufferEdge(remote_el->GetAddress(), GetAddress(), false, delay));
QSharedPointer<BufferEdge> ledge(local_edge);
SetSharedPointer(ledge);
QSharedPointer<BufferEdge> redge(remote_edge);
SetSharedPointer(redge);
local_edge->SetRemoteEdge(redge);
remote_edge->SetRemoteEdge(ledge);
ProcessNewEdge(ledge);
remote_el->ProcessNewEdge(redge);
}
