viswnd.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * rob08 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "viswnd.h"

#include "arena.h"
#include "robIO.h"

#ifndef BUILDING_DOX
#   include <assert.h>
#   include <math.h>
#   include <QApplication>
#   include <QCheckBox>
#   include <QFormLayout>
#   include <QGridLayout>
#   include <QLabel>
#   include <QLCDNumber>
#   include <QMessageBox>
#   include <QScrollBar>
#   include <QSlider>
#   include <QTimer>
#   include <QWheelEvent>
#endif

using std::string;
using namespace StreamDecorator;

static const qreal defaultZoomRatio = 4.0;

// /////////////////////////////////////////////////////////////////////////////
// VisWnd implementation
struct VisWnd::Private {
    Arena               *arena;
    QScrollArea         *scrollArea;
    NavigationBar       *navigationBar;
    MetersBar           *metersBar;
    QStatusBar          *statusBar;
};
VisWnd::VisWnd(CoreSync *cs):
    d(new Private)
{
    // craete arena
    d->arena = new Arena(cs);
    d->arena->zoom(defaultZoomRatio);

    // create scroll area
    d->scrollArea = new ScrollArea;
    d->scrollArea->setWidget(d->arena);
    d->scrollArea->setAlignment(Qt::AlignCenter | Qt::AlignVCenter);
    d->scrollArea->setBackgroundRole(QPalette::Midlight);
    this->setCentralWidget(d->scrollArea);

    // create navigation toolbar
    d->navigationBar = new NavigationBar;
    connect(
            d->navigationBar,   SIGNAL(setShrinkPathEnabled(bool)),
            d->arena,           SLOT(setShrinkPathEnabled(bool)));
    connect(
            d->navigationBar,   SIGNAL(setDrawSurfaceEnabled(bool)),
            d->arena,           SLOT(setDrawSurfaceEnabled(bool)));
    connect(
            d->navigationBar,   SIGNAL(zoomChanged(qreal)),
            d->arena,           SLOT(zoom(qreal)));
    connect(
            d->arena,           SIGNAL(preferredPosChanged(QPoint)),
            this,               SLOT(scrollToView(QPoint)));
    connect(
            d->scrollArea,      SIGNAL(zoomIn()),
            d->navigationBar,   SLOT(zoomIn()));
    connect(
            d->scrollArea,      SIGNAL(zoomOut()),
            d->navigationBar,   SLOT(zoomOut()));
    this->addDockWidget(Qt::TopDockWidgetArea, d->navigationBar);

    // create meters bar
    d->metersBar = new MetersBar(d->arena);
    d->metersBar->coreInfoChanged();
    connect(
            d->arena,           SIGNAL(coreInfoChanged()),
            d->metersBar,       SLOT(coreInfoChanged()));
    this->addDockWidget(Qt::LeftDockWidgetArea, d->metersBar);

    // craete status bar
    d->statusBar = new QStatusBar;
    this->setStatusBar(d->statusBar);
}
VisWnd* VisWnd::showMainWindow(CoreSync *cs) {
    // show/initialize
    VisWnd *wnd = new VisWnd(cs);
    wnd->show();
    wnd->d->navigationBar->setMaximumHeight(wnd->d->navigationBar->minimumHeight());
    wnd->d->metersBar->setMaximumWidth(wnd->d->metersBar->minimumWidth());
    wnd->d->navigationBar->zoom(defaultZoomRatio);

    // update status bar
    QSize envSize = wnd->d->arena->envSize();
    wnd->d->statusBar->showMessage(QString("Environment loaded, arena size is %1 x %2...")
            .arg(envSize.width())
            .arg(envSize.height()),
            8000);

    // return initialized instance
    return wnd;
}
VisWnd::~VisWnd() {
    delete d;
}
void VisWnd::syncThreadFinished() {
    if (QMessageBox::Yes == QMessageBox::warning(this, "rob08 visualizer",
            "Connection lost. Do you want to close visualizer?", 
            QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes))
        QCoreApplication::quit();
    else
        d->statusBar->showMessage("Out of sync!!!");
}
void VisWnd::scrollToView(QPoint pos) {
    QScrollArea *sArea = d->scrollArea;
    QScrollBar *hSb = sArea->horizontalScrollBar();
    QScrollBar *vSb = sArea->verticalScrollBar();
    if ((hSb && hSb->isSliderDown())
            || (vSb && vSb->isSliderDown()))
        return;

    // save scrollbars original position
    int hPos1 = hSb ? hSb->value() : 0;
    int vPos1 = vSb ? vSb->value() : 0;

    const int margin = 50 + d->arena->botSize();
    // std::cerr << "scrollToView: x = " << pos.x() << ", y = " << pos.y() << ", margin = " << margin << std::endl;
    d->scrollArea->ensureVisible(pos.x(), pos.y(), margin, margin);

    // check scrollbars new position
    hSb = sArea->horizontalScrollBar();
    vSb = sArea->verticalScrollBar();
    int hPos2 = hSb ? hSb->value() : 0;
    int vPos2 = vSb ? vSb->value() : 0;

    // update statusbar
    QStatusBar *sb = d->statusBar;
    if (sb->currentMessage().isEmpty() && (hPos1 != hPos2 || vPos1 != vPos2))
        d->statusBar->showMessage("Scrolling to Trilobot position, hold scrollbar down to suppress this behavior...", 4000);
}

// /////////////////////////////////////////////////////////////////////////////
// ScrollArea implementation
ScrollArea::ScrollArea(QWidget *parent):
    QScrollArea(parent)
{
}
ScrollArea::~ScrollArea() {
}
void ScrollArea::wheelEvent(QWheelEvent *e) {
    if (!(e->modifiers() & Qt::ControlModifier)) {
        QScrollArea::wheelEvent(e);
        return;
    }
    if (0 < e->delta())
        emit zoomIn();
    else
        emit zoomOut();

    // TODO: move scrollbars?
    e->accept();
}

// /////////////////////////////////////////////////////////////////////////////
// Bar implementation
Bar::Bar(QSize floatingSize):
    floatingSize_(floatingSize)
{
    this->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
    connect(this, SIGNAL(topLevelChanged(bool)),
            this, SLOT(topLevelChanged(bool)));
}
void Bar::topLevelChanged (bool topLevel) {
    if (!topLevel) {
        this->setMinimumSize(0,0);
        if (this->allowedAreas() & (Qt::TopDockWidgetArea|Qt::BottomDockWidgetArea))
            this->setMaximumWidth(QWIDGETSIZE_MAX);
        if (this->allowedAreas() & (Qt::LeftDockWidgetArea|Qt::RightDockWidgetArea))
            this->setMaximumHeight(QWIDGETSIZE_MAX);
    }
    this->resize(this->floatingSize_);
    this->updateGeometry();
    if (topLevel) {
        this->setMinimumSize(this->size());
        this->setMaximumSize(this->size());
    }
}

// /////////////////////////////////////////////////////////////////////////////
// NavigationBar implementation
struct NavigationBar::Private {
    QFrame              *frame;
    QHBoxLayout         *layout;
    QLabel              *titleBar;
    QLabel              *zoomLabel;
    QSlider             *zoomSlider;
    QCheckBox           *shrinkPath;
    QCheckBox           *drawSurface;
};
NavigationBar::NavigationBar():
    Bar(QSize(600, 0)),
    d(new Private)
{
    // initialize frame
    d->frame = new QFrame;
    d->layout = new QHBoxLayout;
    d->frame->setLayout(d->layout);

    // create "shrink path" checkbox
    d->shrinkPath = new QCheckBox("shrink path", d->frame);
    d->layout->addWidget(d->shrinkPath);
    connect(
            d->shrinkPath,  SIGNAL(stateChanged(int)),
            this,           SLOT(shrinkPathChanged(int)));
    d->layout->addSpacing(32);

    // create "draw surface" checkbox
    d->drawSurface = new QCheckBox("draw surface", d->frame);
    d->layout->addWidget(d->drawSurface);
    connect(
            d->drawSurface, SIGNAL(stateChanged(int)),
            this,           SLOT(drawSurfaceChanged(int)));
    d->layout->addSpacing(32);

    // create label
    d->zoomLabel = new QLabel(d->frame);
    d->layout->addWidget(d->zoomLabel);

    // create slider
    d->zoomSlider = new QSlider(Qt::Horizontal, d->frame);
    d->zoomSlider->setMinimum(10);
    d->zoomSlider->setMaximum(320);
    d->layout->addWidget(d->zoomSlider);
    connect(
            d->zoomSlider,  SIGNAL(valueChanged(int)),
            this,           SLOT(zoomChanged(int)));

    // initialize self
    this->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea | Qt::NoDockWidgetArea);
    this->setWidget(d->frame);
    d->shrinkPath->setCheckState(Qt::Checked);
}
NavigationBar::~NavigationBar() {
    delete d;
}
void NavigationBar::zoom(qreal ratio) {
    QSlider *slider = d->zoomSlider;

    // convert rario to slider position
    int pos = static_cast<int>(ratio*10);
    assert(slider->minimum() < pos);
    assert(pos < slider->maximum());

    slider->setValue(pos);
}
void NavigationBar::zoomIn() {
    //d->zoomSlider->triggerAction(QAbstractSlider::SliderSingleStepAdd);
    d->zoomSlider->triggerAction(QAbstractSlider::SliderPageStepAdd);
}
void NavigationBar::zoomOut() {
    //d->zoomSlider->triggerAction(QAbstractSlider::SliderSingleStepSub);
    d->zoomSlider->triggerAction(QAbstractSlider::SliderPageStepSub);
}
void NavigationBar::shrinkPathChanged(int state) {
    emit setShrinkPathEnabled(state == Qt::Checked);
}
void NavigationBar::drawSurfaceChanged(int state) {
    emit setDrawSurfaceEnabled(state == Qt::Checked);
}
void NavigationBar::zoomChanged(int pos) {
    qreal ratio = static_cast<double>(pos)/10;

    // update label
    QString label("zoom ratio: ");
    label += QString::number(ratio, 'f', 1);
    label += "x";
    d->zoomLabel->setText(label);

    d->zoomSlider->setSingleStep(pos/10);
    d->zoomSlider->setPageStep(pos/10);
    emit zoomChanged(ratio);
}

// /////////////////////////////////////////////////////////////////////////////
// MetersBar implementation
struct MetersBar::Private {
    ICoreInfoSource *ciSource;

    QFrame          *frame;
    QFormLayout     *layout;
    QCheckBox       *fastRefresh;

    QLCDNumber      *xLcd;
    QLCDNumber      *yLcd;
    QLCDNumber      *alphaLcd;
    QLCDNumber      *distanceLcd;
    QLCDNumber      *speedLcd;
    QLCDNumber      *radiusLcd;

    QTimer          timer;

    void createLcd(QLCDNumber *&, QString label);
    void display(QLCDNumber *, qreal value);
};
MetersBar::MetersBar(ICoreInfoSource *ciSource):
    Bar(QSize()),
    d(new Private)
{
    d->ciSource = ciSource;

    // create root frame
    QBoxLayout *rootLayout = new QVBoxLayout;
    QFrame *rootFrame = new QFrame;
    rootFrame->setLayout(rootLayout);
    this->setWidget(rootFrame);
    this->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::NoDockWidgetArea);

    // create controls
    d->fastRefresh = new QCheckBox("fast refresh", rootFrame);
    d->fastRefresh->setCheckState(Qt::Checked);
    rootLayout->addWidget(d->fastRefresh);

    // create frame for meters
    d->frame = new QFrame(rootFrame);
    d->layout = new QFormLayout;
    rootLayout->addWidget(d->frame);

    d->createLcd(d->xLcd, "x");
    d->createLcd(d->yLcd, "y");
    d->createLcd(d->alphaLcd, "angle");
    d->createLcd(d->distanceLcd, "distance");
    d->createLcd(d->speedLcd, "speed");
    d->createLcd(d->radiusLcd, "radius");

    d->frame->setLayout(d->layout);

    QTimer &timer = d->timer;
    connect(&timer, SIGNAL(timeout()),
            this,   SLOT(refresh()));
    timer.start(250);
}
MetersBar::~MetersBar() {
    delete d;
}
void MetersBar::coreInfoChanged() {
    if (Qt::Checked == d->fastRefresh->checkState())
        refresh();
}
void MetersBar::refresh() {
    const CoreInfo &info = d->ciSource->coreInfo();

    d->display(d->xLcd, info.x);
    d->display(d->yLcd, info.y);
    d->display(d->alphaLcd, info.angle);
    d->display(d->distanceLcd, info.distance);
    d->display(d->speedLcd, info.speed);
    d->display(d->radiusLcd,
            fabs(info.speed) < 0.1
            ? 0.0 : info.radius);
}
void MetersBar::Private::createLcd(QLCDNumber *&lcd, QString text) {
    lcd = new QLCDNumber(6, frame);
    lcd->setAutoFillBackground(true);
    lcd->setPalette(QPalette(Qt::black, QPalette().window().color()));
    layout->addRow(new QLabel(text, frame), lcd);
}
void MetersBar::Private::display(QLCDNumber *lcd, qreal value) {
    lcd->display(QString::number(value, 'f', 1));
}

---