//___________________________________________________________
bool BlurHelper::eventFilter( QObject* object, QEvent* event )
{
// do nothing if not enabled
if( !enabled() ) return false;
switch( event->type() )
{
case QEvent::Hide:
{
QWidget* widget( qobject_cast<QWidget*>( object ) );
if( widget && isOpaque( widget ) )
{
QWidget* window( widget->window() );
if (window && isTransparent(window) && !_pendingWidgets.contains(window) )
{
_pendingWidgets.insert( window, window );
delayedUpdate();
}
}
break;
}
case QEvent::Show:
case QEvent::Resize:
{
// cast to widget and check
QWidget* widget( qobject_cast<QWidget*>( object ) );
if( !widget ) break;
if( isTransparent( widget ) )
{
_pendingWidgets.insert( widget, widget );
delayedUpdate();
} else if( isOpaque( widget ) ) {
QWidget* window( widget->window() );
if( isTransparent( window ) )
{
_pendingWidgets.insert( window, window );
delayedUpdate();
}
}
break;
}
default: break;
}
// never eat events
return false;
}
void AbstractDataPlugin::setModel( AbstractDataPluginModel* model )
{
if ( d->m_model ) {
disconnect( d->m_model, SIGNAL(itemsUpdated()), this, SLOT(delayedUpdate()) );
delete d->m_model;
}
d->m_model = model;
connect( d->m_model, SIGNAL(itemsUpdated()), this, SLOT(delayedUpdate()) );
connect( d->m_model, SIGNAL(favoriteItemsChanged(QStringList)), this,
SLOT(favoriteItemsChanged(QStringList)) );
connect( d->m_model, SIGNAL(favoriteItemsOnlyChanged()), this,
SIGNAL(favoriteItemsOnlyChanged()) );
emit favoritesModelChanged();
}
IMUWidget::IMUWidget(QWidget *parent, Qt::WFlags flags) : QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
{
connect(this, SIGNAL(delayedUpdate()), this, SLOT(update()), Qt::QueuedConnection);
linear_acceleration = make_tuple(0,0,0); // ROS Geometry Messages Vector3: <x, y, z> -- Initialize to all 0s
angular_velocity = make_tuple(0,0,0); // ROS Geometry Messages Vector3: <x, y, z> -- Initialize to all 0s
orientation = make_tuple(0,0,0,0); // ROS Geometry Messages Quaternion: <w, x, y, z> -- Initialize to all 0s
}
void MapFrame::addCollectionPoint(string rover, float x, float y)
{
// The QT drawing coordinate system is reversed from the robot coordinate system in the y direction
y = -y;
update_mutex.lock();
collection_points[rover_to_display].push_back(pair<float,float>(x,y));
update_mutex.unlock();
emit delayedUpdate();
}
void MapFrame::addTargetLocation(string rover, float x, float y)
{
//The QT drawing coordinate system is reversed from the robot coordinate system in the y direction
y = -y;
update_mutex.lock();
target_locations[rover].push_back(pair<float,float>(x,y));
update_mutex.unlock();
emit delayedUpdate();
}
FilterSortingArea::FilterSortingArea(int processorId,
const OlvisInterface &model,
bool allowInputCreation, QWidget *parent)
: QWidget(parent), mInterface(model), mProcessorId(processorId),
ui(new Ui::FilterSortingArea)
{
mRecursivePaint = false;
ui->setupUi(this);
mAllowInputCreate = allowInputCreation;
ui->inputs->setAllowPortCreation(allowInputCreation);
if (!allowInputCreation)
ui->inputs->setVisible(false);
setAcceptDrops(true);
mEmptyWidget = new QWidget();
mEmptyWidget->setFixedHeight(60);
mCurrent.ignore = 0;
connect(ui->outputs, SIGNAL(startConnect(FilterPortWidget *)),
SLOT(onStartConnect(FilterPortWidget *)));
connect(ui->outputs, SIGNAL(startDisconnect(FilterPortWidget *)),
SLOT(onStartDisconnect(FilterPortWidget *)));
connect(ui->inputs, SIGNAL(startConnect(FilterPortWidget *)),
SLOT(onStartConnect(FilterPortWidget *)));
connect(ui->inputs, SIGNAL(startDisconnect(FilterPortWidget *)),
SLOT(onStartDisconnect(FilterPortWidget *)));
connect(this, SIGNAL(delayedUpdateReq()), SLOT(delayedUpdate()),
Qt::QueuedConnection);
connect(this, SIGNAL(addFilterRequested(int, QString, int)), &mInterface,
SLOT(addFilter(int, QString, int)), Qt::QueuedConnection);
connect(this, SIGNAL(moveFilterRequested(int, int)), &mInterface,
SLOT(moveFilter(int, int)), Qt::QueuedConnection);
connect(this, SIGNAL(connectRequested(int, QString, int, QString)),
&mInterface, SLOT(connectFilter(int, QString, int, QString)),
Qt::QueuedConnection);
connect(this, SIGNAL(connectInputRequested(QString, int, QString)),
&mInterface, SLOT(connectProcessorInput(QString, int, QString)),
Qt::QueuedConnection);
connect(this, SIGNAL(disconnectRequested(int, QString)), &mInterface,
SLOT(disconnectFilter(int, QString)), Qt::QueuedConnection);
connect(this, SIGNAL(addProcessorOutputRequested(int, QString)),
&mInterface, SLOT(createProcessorOutput(int, QString)),
Qt::QueuedConnection);
connect(this, SIGNAL(deleteProcessorOutputRequested(int, QString)),
&mInterface, SLOT(deleteProcessorOutput(int, QString)),
Qt::QueuedConnection);
}
void MapFrame::addToEKFRoverPath(string rover, float x, float y)
{
// Negate the y direction to orient the map so up is north.
y = -y;
if (x > max_ekf_seen_x[rover]) max_ekf_seen_x[rover] = x;
if (y > max_ekf_seen_y[rover]) max_ekf_seen_y[rover] = y;
if (x < min_ekf_seen_x[rover]) min_ekf_seen_x[rover] = x;
if (y < min_ekf_seen_y[rover]) min_ekf_seen_y[rover] = y;
// Normalize the displayed coordinates to the largest coordinates seen since we don't know the coordinate system.
max_ekf_seen_width[rover] = max_ekf_seen_x[rover]-min_ekf_seen_x[rover];
max_ekf_seen_height[rover] = max_ekf_seen_y[rover]-min_ekf_seen_y[rover];
update_mutex.lock();
ekf_rover_path[rover].push_back(pair<float,float>(x,y));
update_mutex.unlock();
emit delayedUpdate();
}
MapFrame::MapFrame(QWidget *parent, Qt::WFlags flags) : QFrame(parent)
{
connect(this, SIGNAL(delayedUpdate()), this, SLOT(update()), Qt::QueuedConnection);
// Scale coordinates
frame_width = this->width();
frame_height = this->height();
// max_gps_seen_x[rover] = -std::numeric_limits<float>::max();
// max_gps_seen_y[rover] = -std::numeric_limits<float>::max();
// min_gps_seen_x[rover] = std::numeric_limits<float>::max();
// min_gps_seen_y[rover] = std::numeric_limits<float>::max();
// max_ekf_seen_x[rover] = -std::numeric_limits<float>::max();
// max_ekf_seen_y[rover] = -std::numeric_limits<float>::max();
// min_ekf_seen_x[rover] = std::numeric_limits<float>::max();
// min_ekf_seen_y[rover] = std::numeric_limits<float>::max();
// max_encoder_seen_x[rover] = -std::numeric_limits<float>::max();
// max_encoder_seen_y[rover] = -std::numeric_limits<float>::max();
// min_encoder_seen_x[rover] = std::numeric_limits<float>::max();
// min_encoder_seen_y[rover] = std::numeric_limits<float>::max();
// max_gps_seen_width[rover] = 0;
// max_gps_seen_height[rover] = 0;
// max_ekf_seen_width[rover] = 0;
// max_ekf_seen_height[rover] = 0;
// max_encoder_seen_width[rover] = 0;
// max_encoder_seen_height[rover] = 0;
display_ekf_data = false;
display_gps_data = false;
display_encoder_data = false;
frames = 0;
}
//___________________________________________________________
void BlurHelper::registerWidget( QWidget* widget )
{
// check if already registered
if( _widgets.contains( widget ) ) return;
// install event filter
addEventFilter( widget );
// add to widgets list
_widgets.insert( widget );
// cleanup on destruction
connect( widget, SIGNAL( destroyed( QObject* ) ), SLOT( widgetDestroyed( QObject* ) ) );
if( enabled() )
{
// schedule shadow area repaint
_pendingWidgets.insert( widget, widget );
delayedUpdate();
}
}
bool BlurHelper::eventFilter (QObject* object, QEvent* event)
{
switch (event->type())
{
case QEvent::Show:
case QEvent::Hide:
case QEvent::Resize:
/* the theme may changed from
Kvantum and to it again */
case QEvent::StyleChange: {
QWidget* widget (qobject_cast<QWidget*>(object));
/* take precautions */
if (!widget || !widget->isWindow()) break;
pendingWidgets_.insert (widget, widget);
delayedUpdate();
break;
}
default: break;
}
// never eat events
return false;
}
void Controller::on_ui_down_released() { m_cbc->downReleased(m_port); delayedUpdate(); }
void Controller::on_ui_up_released() { m_cbc->upReleased(m_port); delayedUpdate(); }
void Controller::on_ui_right_released() { m_cbc->rightReleased(m_port); delayedUpdate(); }
void Controller::on_ui_left_released() { m_cbc->leftReleased(m_port); delayedUpdate(); }
void Controller::on_ui_stop_clicked()
{
m_client->setPort(m_port);
m_client->sendCommand(KISS_STOP_COMMAND);
delayedUpdate();
}
GPSFrame::GPSFrame(QWidget *parent, Qt::WFlags flags) : QFrame(parent)
{
connect(this, SIGNAL(delayedUpdate()), this, SLOT(update()), Qt::QueuedConnection);
frames = 0;
}