vncwindow.cpp

Go to the documentation of this file.

/*
 # Copyright (c) 2009, 2010 - 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 feedback@openslx.org
 #
 # General information about OpenSLX can be found at http://openslx.org/
 # -----------------------------------------------------------------------------
 # clientVNCViewer.cpp
 #  - connetct to vnc server and show remote screen (window/full)
 # -----------------------------------------------------------------------------
 */

#include "vncwindow.h"
#include "vncthread.h"
#include "../clientapp/clientapp.h"

#include <QGuiApplication>
#include <QTimer>
#include <QPainter>
#include <QScreen>
#include <QKeyEvent>

static int gcd(int a, int b)
{
   if (b == 0)
      return a;
   return gcd(b, a % b);
}

VncWindow::VncWindow(QWidget *parent) :
   QWidget(parent), _srcStepX(1), _srcStepY(1), _dstStepX(1), _dstStepY(1),
   _vncWorker(nullptr), _viewOnly(true), _multiScreen(false), _clientId(0), _redrawTimer(0), _tcpTimeoutTimer(0)
{
   auto *upper = new QTimer(this);
   connect(upper, &QTimer::timeout, this, &VncWindow::timer_moveToTop);
   upper->start(1111);
}

VncWindow::~VncWindow() = default;

// Private

void VncWindow::terminateVncThread()
{
   if (_vncWorker == nullptr)
      return;

   disconnect(_vncWorker, &VncThread::projectionStopped, this, &VncWindow::onProjectionStopped);
   disconnect(_vncWorker, &VncThread::projectionStarted, this, &VncWindow::onProjectionStarted);
   disconnect(_vncWorker, &VncThread::imageUpdated, this, &VncWindow::onUpdateImage);
   _vncWorker->stop();
   _vncWorker = nullptr;
   if (_redrawTimer != 0) {
      killTimer(_redrawTimer);
      _redrawTimer = 0;
   }
   if (_tcpTimeoutTimer != 0) {
      killTimer(_tcpTimeoutTimer);
      _tcpTimeoutTimer = 0;
   }
}

void VncWindow::deleteVncThread()
{
   qDebug() << "Deleting thread" << QObject::sender();
   delete QObject::sender();
}

void VncWindow::draw(const int x, const int y, const int w, const int h)
{
   if (_vncWorker == nullptr)
      return;
   QSharedPointer<QImage> buffer = _vncWorker->getFrameBuffer();
   if (buffer.isNull())
      return;
   this->calcScaling(buffer.data());

   QPainter painter(this);
   if (_dstStepX > 1 || _dstStepY > 1) {
      // Scaling is required as vnc server and client are using different resolutions
      // Calc section offsets first
      const int startX = x / _dstStepX;
      const int startY = y / _dstStepY;
      const int endX = (x + w - 1) / _dstStepX + 1;
      const int endY = (y + h - 1) / _dstStepY + 1;
      // Now pixel offsets for source
      const int dstX = startX * _dstStepX;
      const int dstY = startY * _dstStepY;
      const int dstW = endX * _dstStepX - dstX;
      const int dstH = endY * _dstStepY - dstY;
      // Pixel offsets for destination
      const int srcX = startX * _srcStepX;
      const int srcY = startY * _srcStepY;
      const int srcW = endX * _srcStepX - srcX;
      const int srcH = endY * _srcStepY - srcY;
      // Rescale
      QImage scaled(
         buffer->copy(srcX, srcY, srcW, srcH).scaled(dstW, dstH, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
      painter.drawImage(dstX, dstY, scaled, 0, 0, dstW, dstH);
   } else {
      // Same resolution, nothing to do
      painter.drawImage(x, y, *buffer, x, y, w, h);
   }
   //painter.drawRect(x,y,w,h); // for debugging updated area
}

bool VncWindow::calcScaling(const QImage *remote)
{
   if (this->size() == _desiredSize &&
         (remote == nullptr || remote->size() == _remoteSize))
      return false;
   const QSize mySize = this->size();
   const QSize remoteSize = remote == nullptr ? _remoteSize : remote->size();
   if (mySize.isEmpty())
      return false;
   if (remoteSize.isEmpty())
      return false;
   _remoteSize = remoteSize;
   _desiredSize = mySize;
   const int gcdX = gcd(_desiredSize.width(), _remoteSize.width());
   const int gcdY = gcd(_desiredSize.height(), _remoteSize.height());
   _srcStepX = _remoteSize.width() / gcdX;
   _srcStepY = _remoteSize.height() / gcdY;
   _dstStepX = _desiredSize.width() / gcdX;
   _dstStepY = _desiredSize.height() / gcdY;
   qDebug() << "Scaling updated to" << _remoteSize << "->" << _desiredSize;
   return true;
}

// Public

void VncWindow::open(const QString& host, int port, const QString& passwd, bool /* ro */ , bool fullscreen, const QString& caption, const int clientId, const QByteArray& rawThumb)
{
   this->terminateVncThread();
   _clientId = clientId;
   _vncWorker = new VncThread(host, port, passwd, 1);
   connect(_vncWorker, &VncThread::projectionStopped, this, &VncWindow::onProjectionStopped, Qt::QueuedConnection);
   connect(_vncWorker, &VncThread::projectionStarted, this, &VncWindow::onProjectionStarted, Qt::QueuedConnection);
   connect(_vncWorker, &VncThread::imageUpdated, this, &VncWindow::onUpdateImage, Qt::QueuedConnection);
   connect(_vncWorker, &VncThread::finished, this, &VncWindow::deleteVncThread, Qt::QueuedConnection);

   setWindowTitle(caption);

   setAttribute(Qt::WA_OpaquePaintEvent);

   _remoteThumb.loadFromData(rawThumb);

   if (fullscreen) {
      setWindowFlags(Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint | Qt::Tool); // | Qt::X11BypassWindowManagerHint); <- better, but window won't get any keyboard input
      // Show projection on rightmost screen
      QRect best;
      for (auto *screen : QGuiApplication::screens()) {
         QRect r = screen->geometry();
         if (best.isNull() || r.left() > best.left()) {
            best = r;
         }
      }
      _multiScreen = QGuiApplication::screens().size() > 1;
      qDebug() << "Spawning VNC viewer at" << best;
      show();
      setGeometry(best);
      raise();
      if (!_multiScreen) {
         activateWindow();
      }
      move(best.topLeft());
   } else {
      setWindowFlags(Qt::Tool | Qt::WindowMaximizeButtonHint);
      resize(800, 600);
      showNormal();
   }

   this->update();

   _tcpTimeoutTimer = startTimer(10000);
   _vncWorker->start(QThread::LowPriority);
}

void VncWindow::closeEvent(QCloseEvent * /* e */ )
{
   qDebug("Closing VNC viewer window.");
   this->terminateVncThread();
   emit running(false, _clientId);
}

// Slots

void VncWindow::onUpdateImage(const int x, const int y, const int w, const int h)
{
   if (_vncWorker == nullptr)
      return;
   if (!this->calcScaling(_vncWorker->getFrameBuffer().data()) && !_remoteSize.isEmpty()) {
      if (_srcStepX > 1 || _srcStepY > 1) {
         this->update((x * _desiredSize.width()) / _remoteSize.width() - 2,
                   (y * _desiredSize.height()) / _remoteSize.height() - 2,
                   (w * _desiredSize.width()) / _remoteSize.width() + 4,
                   (h * _desiredSize.height()) / _remoteSize.height() + 4);
      } else {
         this->update(x, y, w, h);
      }
   } else {
      // Changed, redraw everything
      this->update();
   }
}

void VncWindow::onProjectionStarted()
{
   _remoteThumb = QPixmap();
   if (_tcpTimeoutTimer != 0) {
      killTimer(_tcpTimeoutTimer);
      _tcpTimeoutTimer = 0;
   }
   emit running(true, _clientId);
   _redrawTimer = startTimer(500);
}

void VncWindow::onProjectionStopped()
{
   this->terminateVncThread();
   this->close();
}

void VncWindow::timer_moveToTop()
{
   if (this->isHidden())
      return;
   if (!_multiScreen) {
      activateWindow();
   }
   raise();
}

// Protected
void VncWindow::timerEvent(QTimerEvent *event)
{
   if (event->timerId() == _redrawTimer) {
      killTimer(_redrawTimer);
      _redrawTimer = 0;
      this->update();
   } else if (event->timerId() == _tcpTimeoutTimer) {
      killTimer(_tcpTimeoutTimer);
      _tcpTimeoutTimer = 0;
      if (_vncWorker != nullptr && !_vncWorker->isConnected()) {
         this->close();
      }
   } else
      killTimer(event->timerId());
}

void VncWindow::paintEvent(QPaintEvent *event)
{
   if (_vncWorker == nullptr || !_vncWorker->isConnected()) {
      QPainter painter(this);
      if (!_remoteThumb.isNull() && _remoteThumb.height() > 0) {
         painter.drawPixmap(0, 0, this->width(), this->height(), _remoteThumb);
      } else {
         painter.fillRect(event->rect(), QColor(60, 63, 66));
      }
      QFontInfo fi = painter.fontInfo();
      painter.setPen(QColor(200, 100, 10));
      painter.setFont(QFont(fi.family(), 28, fi.weight(), fi.italic()));
      painter.drawText(this->contentsRect(), Qt::AlignCenter, tr("Connecting..."));
   } else {
      const QRect &r = event->rect();
      this->draw(r.left(), r.top(), r.width(), r.height());
   }
   event->accept();
}

void VncWindow::keyReleaseEvent(QKeyEvent* event)
{
   if (event->modifiers() == 0 && clientApp->isConnectedToLocalManager()) {
      this->close();
   } else {
      QWidget::keyReleaseEvent(event);
   }
}