connectionframe.cpp

Go to the documentation of this file.

/*
# Copyright (c) 2009 - OpenSLX Project, Computer Center University of Freiburg
#
# This program is free software distributed under the GPL version 2.
# See http://openslx.org/COPYING
#
# If you have any feedback please consult http://openslx.org/feedback and
# send your suggestions, praise, or complaints to [email protected]
#
# General information about OpenSLX can be found at http://openslx.org/
# -----------------------------------------------------------------------------
# src/gui/connectionFrame.cpp
# -----------------------------------------------------------------------------
*/


#include "connectionframe.h"
#include "../mainwindow/mainwindow.h"
#include "../../shared/util.h"
#include "../net/client.h"

#include <QImage>
#include <QResizeEvent>
#include <QBoxLayout>
#include <QLabel>
#include <QApplication>
#include <QPainter>

static const QString style_student(
    "QLabel{ background-color: #FFF; border-radius: 2px; color: black;}"
   " QGroupBox { background-color: #AAA; margin: 2px; border-radius: 4px}"
);
static const QString style_tutor(
    "QLabel{ background-color: #FFF; border-radius: 2px; color: black;}"
   " QGroupBox { background-color: #70C670; margin: 2px; border-radius: 4px}"
);
static const QString style_attention(
    "QLabel{ background-color: #FFF; border-radius: 2px; color: black;}"
   " QGroupBox { background-color: #C88; margin: 2px; border-radius: 4px}"
);
static const QString style_selectedStudent(
    "QLabel{ background-color: #FFF; border-radius: 2px; color: black; }"
   " QGroupBox { background-color: #ccebff; margin: 0px; border-radius: 4px; border: 4px solid #6C8CF0;}"
);
static const QString style_selectedTutor(
    "QLabel{ background-color: #FFF; border-radius: 2px; color: black;}"
   " QGroupBox { background-color: #9f9; margin: 0px;  border-radius: 4px; border: 4px solid #6C8CF0;}"
);
static const QString style_selectedAttention(
    "QLabel{ background-color: #FFF; border-radius: 2px; color: black;}"
   " QGroupBox { background-color: #E99; margin: 0px;  border-radius: 4px; border: 4px solid #6C8CF0;}"
);
static const QString style_exam (
    "QLabel{ background-color: #919191; color: black; }"
   " QGroupBox { background-color: #d35400; margin: 1px; border-radius: 4px}"
);
static const QString style_exam_selected (
    "QLabel{ background-color: #919191; color: black; }"
   " QGroupBox { background-color: #cc743a; margin: 1px; border-radius: 4px}"
);
static const QString style_disconnected(
    "QLabel{ background-color: #919191; border-radius: 2px; color: black; }"
   " QGroupBox { background-color: #7F7F7F; margin: 1px; border-radius: 4px}"
);

static QIcon *term = nullptr, *cam = nullptr, *eye = nullptr, *lock = nullptr;

static const int START_DRAG_DISTANCE = 40;

bool ConnectionFrame::paintDisabled = false;

ConnectionFrame::ConnectionFrame(MainWindow* main, QWidget *parent, bool fromRoomplan)
      : QGroupBox(parent)
      , _isFromRoomplan(fromRoomplan)
      , _mainWindow(main)
{

   //defines the ui-stuff
   // load icons first
   if (term == nullptr) {
      term = new QIcon(":terminal");
      cam = new QIcon(":cf_cam");
      eye = new QIcon(":cf_eye");
      lock = new QIcon(":cf_lock");
   }

   _mainLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);
   _mainLayout->setSpacing(1);
   _mainLayout->setMargin(3);
   _mainLayout->setAlignment(Qt::AlignHCenter);
   this->setStyleSheet(style_student);

   _iconLayout = new QBoxLayout(QBoxLayout::RightToLeft, nullptr);
   _iconLayout->setSpacing(1);
   _iconLayout->setMargin(3);

   _lblUserName = new QLabel("Test", this);
   _lblUserName->setAlignment(Qt::AlignHCenter);

   _lblHostName = new QLabel("PC", this);
   _lblHostName->setAlignment(Qt::AlignHCenter);

   _lblExamMode = new QLabel(tr("EXAM-MODE"), this);
   _lblExamMode->setAlignment(Qt::AlignHCenter);
   _lblExamMode->setVisible(false);

   _icoCam = addIcon(cam);
   _icoEye = addIcon(eye);
   _icoLock = addIcon(lock);

   _iconLayout->addWidget(_icoCam);
   _iconLayout->addWidget(_icoEye);
   _iconLayout->addWidget(_icoLock);
   _iconLayout->addStretch();

   _mainLayout->addLayout(_iconLayout);
   _mainLayout->addStretch();
   _mainLayout->addWidget(_lblExamMode);
   _mainLayout->addStretch();
   _mainLayout->addWidget(_lblUserName);
   _mainLayout->addWidget(_lblHostName);
   this->setLayout(_mainLayout);
   this->updateAppearance();
   this->updateLabels();
}

ConnectionFrame::~ConnectionFrame()
{
   if (_client != nullptr) {
      _client->deleteLater();
   }
   _iconLayout->deleteLater();
}

void ConnectionFrame::setGridPosition(const QPoint& pos)
{
   _gridPosition = pos;
   updateGeometry();
}

void ConnectionFrame::setGridPosition(int x, int y)
{
   setGridPosition(QPoint(x, y));
}

void ConnectionFrame::updateGeometry()
{
   const QRect rect = _mainWindow->calcFrameGeometry(this);
   setGeometry(rect);
   if (this->_client == nullptr)
      showDefaultThumb();
}

QLabel* ConnectionFrame::addIcon(const QIcon* icon)
{
   auto *label = new QLabel(this);
   label->setPixmap(icon->pixmap(24, 24, QIcon::Normal, QIcon::On));
   label->setAttribute(Qt::WA_TranslucentBackground);
   label->hide();
   _icons.append(label);
   return label;
}

void ConnectionFrame::assignClient(Client* client)
{
   assert(_client == nullptr);
   _client = client;
   connect(_client, &Client::disconnected, this, &ConnectionFrame::onClientDisconnected );
   connect(_client, &Client::thumbUpdated, this, &ConnectionFrame::onThumbUpdated );
   connect(_client, &Client::vncServerStateChange, this, &ConnectionFrame::updateAppearance);
   connect(_client, &Client::vncClientStateChange, this, &ConnectionFrame::updateAppearance);
   connect(_client, &Client::stateChanged, this, &ConnectionFrame::updateAppearance);
   _computerId = client->ip();
   updateLabels();
   showDefaultThumb();
   if (_timerId == 0)
      _timerId = startTimer(slxrand() % 150 + 1000);
   this->updateAppearance();
   _client->setTutor(_isTutor);
}

void ConnectionFrame::showDefaultThumb()
{
   _remoteScreen = term->pixmap(_desiredThumbSize, QIcon::Normal, QIcon::On).toImage();
   this->update();
}

void ConnectionFrame::calcDesiredThumbSize(const QSize &frameSize)
{
   const int width = frameSize.width() - 10;
   const int height = frameSize.height() - 12 - _lblHostName->height() - (_lblUserName->isHidden() ? 0 : _lblUserName->height());
   _desiredThumbSize = QSize(width, height);
}

void ConnectionFrame::updateLabels()
{
   _lblHostName->setText(_computerId);
   if (_client == nullptr) {
      _lblUserName->setText(QString());
      _lblUserName->hide();
   } else {
      _lblHostName->setToolTip(_client->host());
      _lblUserName->setText(_client->name());
      _lblUserName->show();
   }
   calcDesiredThumbSize(this->size());
}

void ConnectionFrame::enterEvent(QEvent* event)
{
   QApplication::setOverrideCursor(QCursor(Qt::OpenHandCursor));
   event->accept();
}

void ConnectionFrame::leaveEvent(QEvent* event)
{
   QApplication::setOverrideCursor(QCursor(Qt::ArrowCursor));
   event->accept();
}

void ConnectionFrame::mousePressEvent(QMouseEvent *event)
{
   event->accept();
   if (event->button() == Qt::RightButton) {
      // Menu...
   } else if (event->button() == Qt::LeftButton) {
      _clickPoint = event->pos();
      _previousPosition  = this->pos();
      QApplication::setOverrideCursor(QCursor(Qt::ClosedHandCursor));
   }
   // On click, the window has to be on the top-level.
   raise();
   update();
}

void ConnectionFrame::mouseMoveEvent(QMouseEvent *event)
{
   event->accept();
   QApplication::setOverrideCursor(QCursor(Qt::ClosedHandCursor));
   move(mapToParent(event->pos() - _clickPoint));
   if ((this->pos() - _previousPosition).manhattanLength() > START_DRAG_DISTANCE) {
      emit frameMoving(this);
   }
}

void ConnectionFrame::mouseReleaseEvent(QMouseEvent* event)
{
   event->accept();
   QApplication::setOverrideCursor(QCursor(Qt::OpenHandCursor));
   if (event->button() == Qt::LeftButton) {
      // Only recognize a move if the distance is larger than _startDragDistance
      if ((this->pos() - _previousPosition).manhattanLength() > START_DRAG_DISTANCE) {
         emit frameMoved(this);
      } else {
         move(_previousPosition);
         emit clicked(this);
      }
   }
}

void ConnectionFrame::mouseDoubleClickEvent(QMouseEvent* event)
{
   emit doubleClicked(this);
   event->accept();
}

void ConnectionFrame::paintEvent(QPaintEvent *event)
{
   if (ConnectionFrame::paintDisabled) {
      return;
   }
   QGroupBox::paintEvent(event);
   if (_remoteScreen.isNull()) {
      return;
   }

   if (!_desiredThumbSize.isEmpty()) {
      if (abs(100 - ((_remoteScreen.width() * 100) / _desiredThumbSize.width())) > 5
            && abs(100 - ((_remoteScreen.height() * 100) / _desiredThumbSize.height())) > 5) {
         qDebug() << "Rescale thumb" << _remoteScreen.size() << "to" << _desiredThumbSize;
         _remoteScreen = _remoteScreen.scaled(_desiredThumbSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
      }
   }

   QPainter painter(this);
   painter.drawImage((this->width() - _remoteScreen.width()) / 2, 4, _remoteScreen);
   event->accept();
}

void ConnectionFrame::timerEvent(QTimerEvent* /* event */ )
{
   if (_client == nullptr)
      return;
   ++_timerCounter;
   if (_client->isActiveVncServer() && _timerCounter % 5 != 0)
      return;
   _client->requestThumb(_desiredThumbSize);
}

void ConnectionFrame::setSelection(bool selected)
{
   if (_isSelected == selected)
      return;
   _isSelected = selected;
   this->updateAppearance();
}

void ConnectionFrame::setTutor(bool b)
{
   if (_isTutor != b && _client != nullptr)
      _client->setTutor(b);
   _isTutor = b;
   this->updateAppearance();
}

void ConnectionFrame::updateAppearance()
{
   if (_client == nullptr) {
      // Unconnected Frame
      if (_isSelected) {
         this->setStyleSheet(style_selectedStudent);
      } else if (_isTutor) {
         this->setStyleSheet(style_tutor);
      } else {
         this->setStyleSheet(style_disconnected);
      }
      for (auto *_icon : _icons) {
         _icon->hide();
      }
      return;
   }
   _icoCam->setVisible(_client->isActiveVncServer());
   _icoEye->setVisible(_client->isActiveVncClient());
   _icoLock->setVisible(_client->isLocked());


   _lblExamMode->setVisible(_client->isExamMode());
   // Normal client, no special stuff active

   if (_isSelected && _isTutor) {
      this->setStyleSheet(style_selectedTutor);
   } else if (_isTutor) {
      this->setStyleSheet(style_tutor);
   } else if (_isSelected && _client->wantsAttention()) {
      this->setStyleSheet(style_selectedAttention);
   } else if (_client->wantsAttention()) {
      this->setStyleSheet(style_attention);
   } else if (_client->isExamMode()) {
      if (_isSelected) {
         this->setStyleSheet(style_exam_selected);
      } else {
         this->setStyleSheet(style_exam);
      }
   } else if (_isSelected) {
      this->setStyleSheet(style_selectedStudent);
   } else {
      this->setStyleSheet(style_student);
   }
}

/*
 * Slots
 */

void ConnectionFrame::onClientDisconnected()
{
   if (_timerId != 0) {
      killTimer(_timerId);
      _timerId = 0;
   }
   _client = nullptr;
   updateLabels();
   updateAppearance();
   showDefaultThumb();
}

void ConnectionFrame::onThumbUpdated(Client* client, const QImage& thumb)
{
   assert(client == _client);
   _remoteScreen = thumb;
   this->update();
}

void ConnectionFrame::resizeEvent(QResizeEvent *event) {
   calcDesiredThumbSize(event->size());
   QGroupBox::resizeEvent(event);
}