void PluginManager::loadPlugin(QString name){
QPluginLoader *a=getPlugin(name);
qDebug()<<"LoadPlugin:"<<name<<":"<<(a==0);
if(a==0)return;
if(!a->load()) return;
PluginInterface *pi=qobject_cast<PluginInterface *>(a->instance());
if(pi==0)return;
QMap<QString,QString> settings=Settings::getInstance()->getPluginSettings(pi->getName());
pi->init(settings);
pi->run();
QObject *piObj=qobject_cast<QObject *>(a->instance());
if(piObj!=0){
//Connect slots&signal
// if (piObj->metaObject()->indexOfSlot( "positionUpdated" ) != -1){
QObject::connect(NavigationWindow::main->gps, SIGNAL(positionUpdate(GPSdata)), piObj, SLOT(positionUpdated(GPSdata)));
//}else{
// qDebug()<<"Brak slotu positionUpdated";
//}
}
QListIterator <PluginWidget*> plugin(pi->getWidgets());
while(plugin.hasNext()){
PluginWidget *n=plugin.next();
n->setParent(NavigationWindow::main);
n->setVisible(false);
TWidgetManager::getInstance()->addWidget(n->getWidgetName(), n);
qDebug()<<"ADD widget"<<n->getWidgetName();
}
}
void GraphicsView::sendImage()
{
emit positionUpdate(robot->pos(), robot->rotation());
QImage img(sceneRect().size().toSize(), QImage::Format_RGB32);
QPainter painter(&img);
painter.setRenderHints(QPainter::Antialiasing);
painter.setRenderHints(QPainter::SmoothPixmapTransform);
render(&painter);
emit newImage(img);
}
void TutorialUnit::setScene(GraphicsView *scene)
{
mScene = scene;
connect(this, SIGNAL(moveRel(QPointF,int)), scene, SLOT(moveRobotRel(QPointF,int)));
connect(this, SIGNAL(moveAbs(QPointF,int)), scene, SLOT(moveRobotAbs(QPointF,int)));
connect(this, SIGNAL(rotateAbs(double,int)), scene, SLOT(rotateRobotAbs(double,int)));
connect(this, SIGNAL(rotateRel(double,int)), scene, SLOT(rotateRobotRel(double,int)));
connect(this, SIGNAL(setGripperState(bool)), scene, SLOT(setGripperState(bool)));
connect(this, SIGNAL(resetScene(bool)), scene, SLOT(reset(bool)));
connect(scene, SIGNAL(movementFinished()), SLOT(onMovementFinished()));
connect(scene, SIGNAL(positionUpdate(QPointF,qreal)), this, SIGNAL(positionUpdated(QPointF,qreal)));
}
/*
* Load data back into the object we are configuring and quit
*/
void MasterConfigurationDialog::OKButtonCallback_real(Fl_Widget* w) {
// get the data
osg::Vec3 position = osg::Vec3( atof(positionXField->value()), atof(positionYField->value()), atof(positionZField->value()) );
osg::Vec3 size = osg::Vec3( atof(sizeXField->value()), atof(sizeYField->value()), atof(sizeZField->value()) );
osg::Vec3 spinVals = osg::Vec3( atof(spinXField->value()), atof(spinYField->value()), atof(spinZField->value()) );
float zRotation = atof( rotationField->value() );
osg::Vec3 rotation = osg::Vec3( 0.0, 0.0, zRotation );
// get the transformations
vector< osg::ref_ptr< BZTransform > > transforms = vector< osg::ref_ptr< BZTransform > >();
if(transformations.size() != 0) {
for(vector<TransformWidget*>::iterator i = transformations.end() - 1; i != transformations.begin() - 1; i--) {
if( (*i)->active() ) {
string widgetData = (*i)->toString();
transforms.push_back( new BZTransform( widgetData ) );
}
}
}
// call updates
UpdateMessage positionUpdate( UpdateMessage::SET_POSITION, &position );
UpdateMessage sizeUpdate( UpdateMessage::SET_SCALE, &size );
UpdateMessage rotationUpdate( UpdateMessage::SET_ROTATION, &rotation );
UpdateMessage transformUpdate( UpdateMessage::SET_TRANSFORMATIONS, &transforms );
if( object->isKey("position") || object->isKey("shift") )
object->update( positionUpdate );
if( object->isKey("size") || object->isKey("scale") )
object->update( sizeUpdate );
if( object->isKey("rotation") && !object->isKey("spin"))
object->update( rotationUpdate );
if( object->isKey("spin") ) {
object->setRotation( spinVals );
}
object->update( transformUpdate );
printf("data: \n|%s|\n", object->toString().c_str());
Fl::delete_widget(this);
}
TestEnv::TestEnv(int num, int dist, int s, QWidget *parent) : QWidget(parent), totalTargets(num), moveDistance(dist), size(s)
{
started = false;
timer = new QTime();
curTarget = new QRect(0,0,size,size);
qsrand((uint)QTime::currentTime().msec());
setMinimumSize(250,250);
this->setAutoFillBackground(true);
this->setPalette(QPalette(Qt::white));
outline = new QRect(0,0,geometry().width()-1,geometry().height()-1);
distTimer = new QTimer();
distance = 0;
positionList = new QList<QPoint>;
mousePositionList = new QList<QPoint>;
QObject::connect(distTimer, SIGNAL(timeout()), this, SLOT(positionUpdate()));
setMouseTracking(true);
}
GPSModule::GPSModule(QObject *parent) : QObject(parent)
{
QSerialPort* serial = new QSerialPort(this);
serial->setPortName(QString("/dev/ttyUSB0"));
serial->setBaudRate(QSerialPort::Baud9600);
serial->setDataBits(QSerialPort::Data8);
serial->setParity(QSerialPort::NoParity);
serial->setStopBits(QSerialPort::OneStop);
serial->open(QIODevice::ReadOnly);
if(serial->isOpen())
{
QNmeaPositionInfoSource *source = new QNmeaPositionInfoSource(QNmeaPositionInfoSource::RealTimeMode);
source->setDevice(serial);
if(source){
connect(source, SIGNAL(positionUpdated(QGeoPositionInfo)), this, SLOT(positionUpdate(QGeoPositionInfo)));
source->setPreferredPositioningMethods(QGeoPositionInfoSource::AllPositioningMethods);
source->setUpdateInterval(2000);
source->startUpdates();
}
}
}
void PlayerComponent::handleMpvEvent(mpv_event *event)
{
switch (event->event_id)
{
case MPV_EVENT_START_FILE:
{
m_CurrentUrl = mpv::qt::get_property_variant(m_mpv, "path").toString();
m_playbackStartSent = false;
break;
}
case MPV_EVENT_FILE_LOADED:
{
emit playing(m_CurrentUrl);
break;
}
case MPV_EVENT_END_FILE:
{
mpv_event_end_file *end_file = (mpv_event_end_file *)event->data;
switch (end_file->reason)
{
case MPV_END_FILE_REASON_EOF:
emit finished(m_CurrentUrl);
break;
case MPV_END_FILE_REASON_ERROR:
emit error(end_file->error, mpv_error_string(end_file->error));
break;
default:
emit stopped(m_CurrentUrl);
break;
}
emit playbackEnded(m_CurrentUrl);
m_CurrentUrl = "";
m_restoreDisplayTimer.start(0);
break;
}
case MPV_EVENT_IDLE:
{
emit playbackAllDone();
break;
}
case MPV_EVENT_PLAYBACK_RESTART:
{
// it's also sent after seeks are completed
if (!m_playbackStartSent)
emit playbackStarting();
m_playbackStartSent = true;
break;
}
case MPV_EVENT_PROPERTY_CHANGE:
{
mpv_event_property *prop = (mpv_event_property *)event->data;
if (strcmp(prop->name, "pause") == 0 && prop->format == MPV_FORMAT_FLAG)
{
int state = *(int *)prop->data;
emit paused(state);
}
else if (strcmp(prop->name, "cache-buffering-state") == 0 && prop->format == MPV_FORMAT_INT64)
{
int64_t percentage = *(int64_t *)prop->data;
emit buffering(percentage);
}
else if (strcmp(prop->name, "playback-time") == 0 && prop->format == MPV_FORMAT_DOUBLE)
{
double pos = *(double*)prop->data;
if (fabs(pos - m_lastPositionUpdate) > 0.25)
{
quint64 ms = (quint64)(qMax(pos * 1000.0, 0.0));
emit positionUpdate(ms);
m_lastPositionUpdate = pos;
}
}
else if (strcmp(prop->name, "vo-configured") == 0)
{
int state = prop->format == MPV_FORMAT_FLAG ? *(int *)prop->data : 0;
emit windowVisible(state);
}
else if (strcmp(prop->name, "duration") == 0)
{
if (prop->format == MPV_FORMAT_DOUBLE)
emit updateDuration(*(double *)prop->data * 1000.0);
}
else if (strcmp(prop->name, "audio-device-list") == 0)
{
updateAudioDeviceList();
}
break;
}
case MPV_EVENT_LOG_MESSAGE:
{
mpv_event_log_message *msg = (mpv_event_log_message *)event->data;
// Strip the trailing '\n'
size_t len = strlen(msg->text);
if (len > 0 && msg->text[len - 1] == '\n')
len -= 1;
QString logline = QString::fromUtf8(msg->prefix) + ": " + QString::fromUtf8(msg->text, len);
if (msg->log_level >= MPV_LOG_LEVEL_V)
QLOG_DEBUG() << qPrintable(logline);
else if (msg->log_level >= MPV_LOG_LEVEL_INFO)
QLOG_INFO() << qPrintable(logline);
else if (msg->log_level >= MPV_LOG_LEVEL_WARN)
QLOG_WARN() << qPrintable(logline);
else
QLOG_ERROR() << qPrintable(logline);
break;
}
case MPV_EVENT_CLIENT_MESSAGE:
{
mpv_event_client_message *msg = (mpv_event_client_message *)event->data;
// This happens when the player is about to load the file, but no actual loading has taken part yet.
// We use this to block loading until we explicitly tell it to continue.
if (msg->num_args >= 3 && !strcmp(msg->args[0], "hook_run") && !strcmp(msg->args[1], "1"))
{
QString resume_id = QString::fromUtf8(msg->args[2]);
// Calling this lambda will instruct mpv to continue loading the file.
auto resume = [=] {
QLOG_INFO() << "resuming loading";
mpv::qt::command_variant(m_mpv, QStringList() << "hook-ack" << resume_id);
};
if (switchDisplayFrameRate())
{
// Now wait for some time for mode change - this is needed because mode changing can take some
// time, during which the screen is black, and initializing hardware decoding could fail due
// to various strange OS-related reasons.
// (Better hope the user doesn't try to exit Konvergo during mode change.)
int pause = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "refreshrate.delay").toInt() * 1000;
QLOG_INFO() << "waiting" << pause << "msec after rate switch before loading";
QTimer::singleShot(pause, resume);
}
else
{
resume();
}
break;
}
}
default:; /* ignore */
}
}
void AMPIC887EpicsCoordinator::onAllConnected(bool connectedState)
{
if(connectedState) {
if(!controller_->isInValidState()) {
qDebug() << "Initialization: Setting Axes status to Error";
xAxisStatus_->move(4);
yAxisStatus_->move(4);
zAxisStatus_->move(4);
uAxisStatus_->move(4);
vAxisStatus_->move(4);
wAxisStatus_->move(4);
} else if (!connectedOnce_) {
connectedOnce_ = true;
// Initializing x Axis
if(!xAxisFeedback_->withinTolerance(controller_->currentPosition(AMGCS2::XAxis))) {
qDebug() << "Initialization: Setting x Axis position to " << controller_->currentPosition(AMGCS2::XAxis);
xAxisFeedback_->move(controller_->currentPosition(AMGCS2::XAxis));
}
if(controller_->movementStatuses().testFlag(AMGCS2::XAxisIsMoving) && !xAxisStatus_->withinTolerance(1)) {
qDebug() << "Initialization: Setting x Axis status to moving";
xAxisStatus_->move(1);
} else if (!xAxisStatus_->withinTolerance(0)) {
qDebug() << "Initialization: Setting x Axis status to move done";
xAxisStatus_->move(0);
}
// Initializing y Axis
if(!yAxisFeedback_->withinTolerance(controller_->currentPosition(AMGCS2::YAxis))) {
qDebug() << "Initialzation: Setting y Axis position to " << controller_->currentPosition(AMGCS2::YAxis);
yAxisFeedback_->move(controller_->currentPosition(AMGCS2::YAxis));
}
if(controller_->movementStatuses().testFlag(AMGCS2::YAxisIsMoving) && !yAxisStatus_->withinTolerance(1)) {
qDebug() << "Initialization: Setting y Axis status to moving";
yAxisStatus_->move(1);
} else if (!yAxisStatus_->withinTolerance(0)) {
qDebug() << "Initialization: Setting y Axis status to move done";
yAxisStatus_->move(0);
}
// Initializing z Axis
if(!zAxisFeedback_->withinTolerance(controller_->currentPosition(AMGCS2::ZAxis))) {
qDebug() << "Initialzation: Setting z Axis position to " << controller_->currentPosition(AMGCS2::ZAxis);
zAxisFeedback_->move(controller_->currentPosition(AMGCS2::ZAxis));
}
if(controller_->movementStatuses().testFlag(AMGCS2::ZAxisIsMoving) && !zAxisStatus_->withinTolerance(1)) {
qDebug() << "Initialization: Setting z Axis status to moving";
zAxisStatus_->move(1);
} else if (!zAxisStatus_->withinTolerance(0)) {
qDebug() << "Initialization: Setting z Axis status to move done";
zAxisStatus_->move(0);
}
// Initializing u Axis
if(!uAxisFeedback_->withinTolerance(controller_->currentPosition(AMGCS2::UAxis))) {
qDebug() << "Initialzation: Setting u Axis position to " << controller_->currentPosition(AMGCS2::UAxis);
uAxisFeedback_->move(controller_->currentPosition(AMGCS2::UAxis));
}
if(controller_->movementStatuses().testFlag(AMGCS2::UAxisIsMoving) && !uAxisStatus_->withinTolerance(1)) {
qDebug() << "Initialization: Setting u Axis status to moving";
uAxisStatus_->move(1);
} else if (!uAxisStatus_->withinTolerance(0)) {
qDebug() << "Initialization: Setting u Axis status to move done";
uAxisStatus_->move(0);
}
// Initializing v Axis
if(!vAxisFeedback_->withinTolerance(controller_->currentPosition(AMGCS2::VAxis))) {
qDebug() << "Initialzation: Setting v Axis position to " << controller_->currentPosition(AMGCS2::VAxis);
vAxisFeedback_->move(controller_->currentPosition(AMGCS2::VAxis));
}
if(controller_->movementStatuses().testFlag(AMGCS2::VAxisIsMoving) && !vAxisStatus_->withinTolerance(1)) {
qDebug() << "Initialization: Setting v Axis status to moving";
vAxisStatus_->move(1);
} else if (!vAxisStatus_->withinTolerance(0)) {
qDebug() << "Initialization: Setting v Axis status to move done";
vAxisStatus_->move(0);
}
// Initializing w Axis
if(!wAxisFeedback_->withinTolerance(controller_->currentPosition(AMGCS2::WAxis))) {
qDebug() << "Initialzation: Setting w Axis position to " << controller_->currentPosition(AMGCS2::WAxis);
wAxisFeedback_->move(controller_->currentPosition(AMGCS2::WAxis));
}
if(controller_->movementStatuses().testFlag(AMGCS2::WAxisIsMoving) && !wAxisStatus_->withinTolerance(1)) {
qDebug() << "Initialization: Setting w Axis status to moving";
wAxisStatus_->move(1);
} else if (!wAxisStatus_->withinTolerance(0)) {
qDebug() << "Initialization: Setting w Axis status to move done";
wAxisStatus_->move(0);
}
// Initialize system velocity
if(!systemVelocityFeedback_->withinTolerance(controller_->systemVelocity())) {
qDebug() << "Initialization: Setting system velocity to " << controller_->systemVelocity();
systemVelocityFeedback_->move(controller_->systemVelocity());
}
if(!systemVelocitySetpoint_->withinTolerance(controller_->systemVelocity())) {
qDebug() << "Initialization: Setting system velocity setpoint to " << controller_->systemVelocity();
systemVelocitySetpoint_->move(controller_->systemVelocity());
}
// Initialize the record rate.
if(!recordRateFeedback_->withinTolerance(controller_->recordRate())) {
qDebug() << "Initialization: Setting record rate to " << controller_->recordRate();
recordRateFeedback_->move(controller_->recordRate());
}
if(!recordRateSetpoint_->withinTolerance(controller_->recordRate())) {
qDebug() << "Initialization: Setting record rate setpoint to " << controller_->recordRate();
recordRateSetpoint_->move(controller_->recordRate());
}
// Initialize data recorder active state
double dataRecorderActiveValue = controller_->isDataRecorderActive() ? 1.0 : 0.0;
if(dataRecorderActive_->withinTolerance(dataRecorderActiveValue)) {
qDebug() << "Initialization: Setting data recorder active status to " << dataRecorderActiveValue;
dataRecorderActive_->move(dataRecorderActiveValue);
}
}
connect(systemVelocitySetpoint_, SIGNAL(valueChanged(double)), this, SLOT(onSystemVelocitySetpointChanged(double)));
connect(recordRateSetpoint_, SIGNAL(valueChanged(double)), this, SLOT(onRecordRateSetpointPVChanged(double)));
connect(dataRecorderActive_, SIGNAL(valueChanged(double)), this, SLOT(onDataRecorderActivePVChanged(double)));
connect(stopAll_, SIGNAL(valueChanged(double)), this, SLOT(onStopAll(double)));
connect(controller_, SIGNAL(moveStarted(AMGCS2::AxisMovementStatuses)), this, SLOT(onMotionStartedChanged(AMGCS2::AxisMovementStatuses)));
connect(controller_, SIGNAL(moveFailed(AMGCS2::AxisMovementStatuses)), this, SLOT(onMotionFailed(AMGCS2::AxisMovementStatuses)));
connect(controller_, SIGNAL(moveComplete()), this, SLOT(onMotionCompleted()));
connect(controller_, SIGNAL(positionUpdate(AMPIC887AxisMap<double>)), this, SLOT(onPositionUpdate(AMPIC887AxisMap<double>)));
connect(controller_, SIGNAL(systemVelocityChanged(double)), this, SLOT(onSystemVelocityChanged(double)));
connect(controller_, SIGNAL(recordRateChanged(double)), this, SLOT(onControllerRecordRateChanged(double)));
connect(controller_, SIGNAL(dataRecorderActiveStateChanged(bool)), this, SLOT(onControllerDataRecorderActiveChanged(bool)));
}
}