mainwindow.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 feedback@openslx.org
 #
 # General information about OpenSLX can be found at http://openslx.org/
 # -----------------------------------------------------------------------------
 # mainWindow.cpp
 This is the Main class for the pvsManager. The GUI is constructed here.
 # -----------------------------------------------------------------------------
 */
// Self
#include "mainwindow.h"
// QT stuff
#include <QSvgRenderer>
#include <QPainter>
#include <QImage>
#include <QMessageBox>
#include <QCloseEvent>
#include <QDialogButtonBox>
#include <QScreen>
// Other custom UI elements
#include "../serverapp/serverapp.h"
#include "../clicklabel/clicklabel.h"
#include "../sessionnamewindow/sessionnamewindow.h"
#include "../connectionframe/connectionframe.h"
#include "../helpwindow/helpwindow.h"
#include "../reloadroomwindow/reloadroomwindow.h"
// Network
#include "../net/listenserver.h"
#include "../net/client.h"
#include "../net/discoverylistener.h"
// Others
#include "../../shared/settings.h"
#include "../util/platform/screensaver.h"
// Auto-generated ui class
#include "ui_mainwindow.h"

#define sStrTutorNdef MainWindow::tr("No tutor defined.")
#define sStrTutorOffline MainWindow::tr("Tutor is offline.")
#define sStrSourceNdef MainWindow::tr("Please select a projection source.")
#define sStrSourceOffline MainWindow::tr("The projection source is offline.")
#define sStrDestNdef MainWindow::tr("Please select a projection destination.")
#define sStrDestOffline MainWindow::tr("The projection destination is offline.")
#define sStrSourceDestSame MainWindow::tr("Selected projection target is tutor.")
#define sStrNoDestAv MainWindow::tr("No projection destination available.")

MainWindow::MainWindow(QWidget* parent)
      : QMainWindow(parent)
      , ui(new Ui::MainWindow)
      , _mode(Mode::Multicast)
{
   qDebug() << "MainWindow(parent)";

   /* default value, these will be updated a room is loaded */
   _tilesX = 10;
   _tilesY = 10;

   _sessionNameWindow = new SessionNameWindow(this);
   _reloadWindow = new ReloadRoomWindow(this);
   _reloadWindow->setWindowTitle(tr("Reload Room"));
   ui->setupUi(this);
   setWindowFlags(Qt::FramelessWindowHint);

   serverApp->setSessionName();

   //conWin = new ConnectionWindow(ui->widget);
   //ui->VconWinLayout->addWidget(conWin);
   //conList = new ConnectionList(ui->ClWidget);
   //ui->ClientGLayout->addWidget(conList);

   // Show only session name label, not textbox
   _sessionNameLabel = new ClickLabel(this);
   ui->mainLayout->addWidget(_sessionNameLabel);

   ui->frmRoom->setStyleSheet("background-color:#444");

   // toolbar and actions in pvsmgr
   ui->action_Exit->setStatusTip(tr("Exit"));
   ui->action_Lock->setStatusTip(tr("Lock or Unlock all Clients"));

   /* the label */
   _examModeLabel = new QLabel("Klausur-\nModus");
   _examModeLabel->setObjectName("examModeLabel");
   _examModeLabel->setAlignment(Qt::AlignCenter);
   _examModeLabel->setFixedHeight(400);
   ui->toolBar->insertWidget(ui->action_TutorToStudent, _examModeLabel);
   _dropMarker = new QLabel(ui->frmRoom);
   _dropMarker->setStyleSheet("background-color: #448; border-radius: 2px;");
   _dropMarker->hide();
   _helpWindow = new HelpWindow(ui->toolBar->actions(), this);

   serverApp->setExam(false);

   // Close button in tool bar
   connect(ui->action_Exit, &QAction::triggered, this, &MainWindow::onButtonExit);
   connect(ui->action_TutorToAll, &QAction::triggered, this, &MainWindow::onButtonTutorToAll);
   connect(ui->action_StudentToTutor, &QAction::triggered, this, &MainWindow::onButtonStudentToTutor);
   connect(ui->action_StudentToTutorExclusive, &QAction::triggered, this, &MainWindow::onButtonStudentToTutorExclusive);
   connect(ui->action_TutorToStudent, &QAction::triggered, this, &MainWindow::onButtonTutorToStudent);
   connect(ui->action_StopProjection, &QAction::triggered, this, &MainWindow::onButtonStopProjection);
   connect(ui->action_SetAsTutor, &QAction::triggered, this, &MainWindow::onButtonSetAsTutor);
   connect(ui->action_SetAsTutor, &QAction::triggered, this, &MainWindow::onButtonStopProjection);
   connect(ui->action_Lock, &QAction::toggled, this, &MainWindow::onButtonLock);
   connect(ui->action_LockSingle, &QAction::triggered, this, &MainWindow::onButtonLockSingle);
   connect(ui->action_Help, &QAction::triggered, this, &MainWindow::onButtonHelp);
   connect(ui->actionReload_Room_Configuration, &QAction::triggered, this, &MainWindow::onButtonReloadRoomConfig);
   connect(ui->action_DeleteClient, &QAction::triggered, this, &MainWindow::onDeleteClient);

   /* Stuff for the button lock */
   //Setup a timeout
   _buttonLockTimer = new QTimer(this);
   _buttonLockTimer->setSingleShot(true);
   _buttonLockTimer->setInterval(BUTTON_BLOCK_TIME);
   connect(_buttonLockTimer, &QTimer::timeout, this, &MainWindow::enableButtons);
   // Define the locking buttons
   _lockingButtons
         << ui->action_DeleteClient
         << ui->action_StudentToTutor
         << ui->action_StudentToTutorExclusive
         << ui->action_SetAsTutor
         << ui->action_TutorToStudent
         << ui->action_LockSingle
           << ui->action_Lock
         << ui->action_TutorToAll
         << ui->action_StopProjection;

   // Clicking the session name label shows the edit field for it
   connect(_sessionNameLabel, &ClickLabel::clicked, this, &MainWindow::onSessionNameClick);
   // Listen to updates to the session name through the session name window
   connect(_sessionNameWindow, &SessionNameWindow::updateSessionName,
         this, &MainWindow::onSessionNameUpdate);

   setAttribute(Qt::WA_QuitOnClose);
   setUnifiedTitleAndToolBarOnMac(true);
   this->showMaximized(); // show the Mainwindow maximized

   auto *ls = new ListenServer(CLIENT_PORT, this);
   connect(ls, &ListenServer::newClient, this, &MainWindow::onClientConnected);
   new DiscoveryListener(this);

   // Finally
   this->onSessionNameUpdate(); // Just make lable visible.

   reloadCurrentRoom();
}

void MainWindow::clientCountChanged()
{
   int examClientCount = 0;
   int clientCount = 0;


   for (auto * frame : _clientFrames) {
      Client* c = frame->client();
      if (c != nullptr) {
         bool b = c->isExamMode();
         examClientCount += b ? 1 : 0;
         clientCount++;
      }
   }

   serverApp->setExam(examClientCount * 2 >= clientCount && clientCount > 0);
   bool e = serverApp->isExam();
   qDebug() << "isExam is " << e;
   ui->action_TutorToAll->setVisible(!e);
   ui->action_StudentToTutor->setVisible(!e);
   ui->action_StudentToTutorExclusive->setVisible(!e);
   ui->action_TutorToStudent->setVisible(!e);
   ui->action_StopProjection->setVisible(!e);
   _examModeLabel->setVisible(e);
   _examModeLabel->setFixedHeight(e ? 400 : 0);

   if (_lastClientCount != clientCount) {
      // Client count actually changed
      if (clientCount == 0) {
         // Last client must have disconnected, enable screen saver again
         ScreenSaver::allowSaverAndStandby(true);
      } else if (_lastClientCount == 0) {
         // We didn't have a client before, but now we do, disable screen saver
         ScreenSaver::forceUnlockAndScreenOn();
         ScreenSaver::allowSaverAndStandby(false);
      }
      // Remember client count
      _lastClientCount = clientCount;
   }
   // Also we might have to enable/disable buttons in the toolbar if the
   // client frame is currently selected
   updateContextButtonStates();
}

MainWindow::~MainWindow()
{
   _sessionNameLabel->deleteLater();
   delete ui;
}

static int distance(QPoint a, QPoint b)
{
   const int dx = a.x() - b.x();
   const int dy = a.y() - b.y();
   const int sum = dx * dx + dy * dy;
   return sum;
}

QPoint MainWindow::closestFreeSlot(const QPoint &preferredPixels, const ConnectionFrame* toIgnore)
{
   const bool pickFirstOne = ( preferredPixels == QPoint(-1, -1) );
   const QSize& clientSize = serverApp->getCurrentRoom()->clientSize;
#define GRID(X,Y) (grid[((X) * _tilesY) + (Y)])
   bool *grid = new bool[_tilesX * _tilesY];
   memset(grid, 0, sizeof(bool) * size_t(_tilesX * _tilesY)); /* set everything to false */

   /* fill grid */
   for (auto * frame : _clientFrames) {

      if (frame == toIgnore) { continue; }

      const QPoint p = frame->getGridPosition();

      for (int x = p.x(); x < p.x() + clientSize.width(); x++) {
         for (int y = p.y(); y < p.y() + clientSize.height(); y++) {
            GRID(x, y) = true;
         }
      }
   }

   QList<QPoint> freePositions;
   /* check all positions to see if they are available */
   for (int x = 0; x <= _tilesX - clientSize.width(); x++) {
      for ( int y = 0; y <= _tilesY - clientSize.height(); y++) {
         /* check if (x,y) is free */
         bool isFree = true;
         int dx, dy = 0;
         for (dx = 0; dx < clientSize.width(); dx++) {
            for (dy = 0; dy < clientSize.height(); dy++) {
               if (GRID(x + dx, y + dy)) {
                  isFree = false;
                  goto endLoop; // double-break
               }
            }
         }
endLoop: ;
         if (isFree) {
            freePositions << QPoint(x, y);
            if (pickFirstOne) {
               goto endSearch;
            }
         }
      }
   }
endSearch: ;
#undef GRID
   delete[] grid;
   if (freePositions.isEmpty() && toIgnore != nullptr) {
      return toIgnore->getGridPosition();
   }
   /* among all the free positions, find the closest */
   int min_distance = 10000000;
   QPoint bestPosition = QPoint(0, 0);

   for (QPoint freePos : freePositions) {
      const QPoint freePosPx( freePos.x() * getTileWidthPx(), freePos.y() * getTileHeightPx() );
      const int dist = distance(freePosPx, preferredPixels);
      if (dist < min_distance) {
         min_distance = dist;
         bestPosition = freePos;
      }
   }
   return bestPosition;
}

/* place frame in the closest available spot */
void MainWindow::placeFrameInFreeSlot(ConnectionFrame* frame, QPoint preferredPixels)
{
   QPoint bestPosition = closestFreeSlot(preferredPixels, frame);
   frame->setGridPosition(bestPosition);
}

ConnectionFrame* MainWindow::createFrame(const QString &computerId, const QPoint* gridPosition, bool fromRoomplan)
{
   auto *cf = new ConnectionFrame(this, ui->frmRoom, fromRoomplan);
   if (gridPosition == nullptr) {
      placeFrameInFreeSlot(cf);
   } else {
      cf->setGridPosition(*gridPosition);
   }
   cf->setComputerId(computerId);
   _clientFrames.append(cf);
   cf->show();
   connect(cf, &ConnectionFrame::frameMoved, this, &MainWindow::onFrameDropped);
   connect(cf, &ConnectionFrame::clicked, this, &MainWindow::onFrameClicked);
   connect(cf, &ConnectionFrame::frameMoving, this, &MainWindow::onFrameMoving);
   return cf;
}

void MainWindow::tellClientCurrentSituation(Client* client)
{
   // If clients are currently locked, tell this new client
   if (ui->action_Lock->isChecked() || _mode == Mode::LockedUnicast)
      client->lockScreen(true);

   if (_mode == Mode::Broadcast) {
      client->setDesiredProjectionSource(_streamingSource);
      if (_streamingSource != 0) {
         client->startVncClient(getClientFromId(_streamingSource));
      }
   }
}

Client* MainWindow::getClientFromId(int id)
{
   for (auto * frame : _clientFrames) {
      if (frame->client() != nullptr) {
         if (frame->client()->id() == id)
            return frame->client();
      }
   }
   return nullptr;
}

ConnectionFrame* MainWindow::getTutorFrame()
{
   for (auto * frame : _clientFrames) {
      if ((frame != nullptr) && (frame->isTutor()))
         return frame;
   }
   return nullptr;
}

ConnectionFrame* MainWindow::getSelectedFrame()
{
   for (auto * frame : _clientFrames) {
      if ((frame != nullptr) && (frame->isSelected()))
         return frame;
   }
   return nullptr;
}

/*
 * Overridden methods
 */

void MainWindow::closeEvent(QCloseEvent* e)
{
   QMessageBox::StandardButton ret = QMessageBox::question(this, tr("Question"), tr("Are you sure you want to exit?"),
         QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
   if (ret == QMessageBox::Yes) {
      QApplication::exit(0);
   } else {
      e->ignore();
   }
}

void MainWindow::changeEvent(QEvent* e)
{
   QMainWindow::changeEvent(e);
}

enum AspectStatus { GRID_OK, GRID_TOO_WIDE, GRID_TOO_TALL };

AspectStatus checkAspectRatio(const QSize& frameSize, const QSize& gridSize)
{
   float aspectRoom  = float(gridSize.height()) / float(gridSize.width());
   float aspectFrame = float(frameSize.height()) / float(frameSize.width());

   if (aspectRoom / aspectFrame <  0.8f) {
      return GRID_TOO_WIDE;
   }
   if ( aspectFrame / aspectRoom < 0.8f) {
      return GRID_TOO_TALL;
   }
   return GRID_OK;
}


void MainWindow::resizeEvent(QResizeEvent* /* e */ )
{
   if (ui->frmRoom->size().width() < 100 || ui->frmRoom->size().height() < 100) {
      return;
   }

   const Room* room = serverApp->getCurrentRoom();
   QSize newGridSize = room->gridSize;
   const QSize& clientSize = room->clientSize;

   // Check if any frames have been moved beyond the room dimensions
   for (auto * frame : _clientFrames) {
      QPoint bounds = frame->getGridPosition();
      while (bounds.x() + clientSize.width() > newGridSize.width()) {
         newGridSize += QSize(1, 0);
      }
      while (bounds.y() + clientSize.height() > newGridSize.height()) {
         newGridSize += QSize(0, 1);
      }
   }

   /* do we have to add virtual columns or rows? */
   AspectStatus status;
   do {
      status = checkAspectRatio(ui->frmRoom->size(), newGridSize);
      if (status == GRID_TOO_WIDE) {
         /* add row */
         newGridSize += QSize(0, 1);
      }
      if (status == GRID_TOO_TALL) {
         /* add column */
         newGridSize += QSize(1, 0);
      }
   } while (status != GRID_OK);
   this->_tilesX = newGridSize.width();
   this->_tilesY = newGridSize.height();
   const int maxX = _tilesX - clientSize.width();
   const int maxY = _tilesY - clientSize.height();

   /* Bring back frames which are now out of the screen */
   for (auto * frame : _clientFrames) {
      const QPoint gp = frame->getGridPosition();
      if ( gp.x() > maxX || gp.y() > maxY ) {
         placeFrameInFreeSlot(frame, frame->pos());
      }
   }

   /* Resize all connection windows */
   for (auto * frame : _clientFrames) {
      frame->updateGeometry();
   }

   /* update background image label */
   if (_backgroundImage != nullptr) {
      int w = ui->frmRoom->width() - 5; /* to make sure that we don't enlarge the window */
      int h = ui->frmRoom->height() - 5;
      ui->imageLabel->hide();
      ui->imageLabel->setScaledContents(true);
      ui->imageLabel->setPixmap(QPixmap::fromImage(*_backgroundImage).scaled(w, h, Qt::IgnoreAspectRatio));
      ui->imageLabel->show();
   } else {
      ui->imageLabel->clear();
   }
}

void MainWindow::updateContextButtonStates()
{
   if (_buttonLockTimer->isActive()) // If buttons are disabled for cooldown, don't do anything
      return;
   const ConnectionFrame *selected = getSelectedFrame();
   const ConnectionFrame *tutor = getTutorFrame();
   const bool somethingSelected = (selected != nullptr);
   const bool selectedOnline = (selected != nullptr && selected->client() != nullptr);
   const bool tutorOnline = (tutor != nullptr && tutor->client() != nullptr);
   // Deletion only for offline clients, tutor if anything is selected, locking only for online clients
   ui->action_DeleteClient->setEnabled(somethingSelected && !selectedOnline);
   ui->action_SetAsTutor->setEnabled(somethingSelected);
   ui->action_LockSingle->setEnabled(selectedOnline && selected != tutor);
   // Don't allow projection to self
   ui->action_StudentToTutorExclusive->setEnabled(selectedOnline && tutorOnline && selected != tutor);
   ui->action_StudentToTutor->setEnabled(selectedOnline && tutorOnline && selected != tutor);
   ui->action_TutorToStudent->setEnabled(selectedOnline && tutorOnline && selected != tutor);
   // Only allow tutor broadcast if they're online
   ui->action_TutorToAll->setEnabled(tutorOnline);
}

void MainWindow::mouseReleaseEvent(QMouseEvent* e)
{
   // Try to figure out if the user clicked inside the "room" frame
   // No idea if there is a more elegant way to do this without
   // sub-classing that frame and overriding its mouseReleaseEvent
   const QPoint pos(ui->frmRoom->mapFrom(this, e->pos()));
   if (pos.x() < 0 || pos.y() < 0)
      return;
   const QSize frame(ui->frmRoom->size());
   if (frame.width() > pos.x() && frame.height() > pos.y()) {
      if (getSelectedFrame() != nullptr) {
         getSelectedFrame()->setSelection(false);
         updateContextButtonStates();
      }
   }
}

void MainWindow::reset(bool lock)
{
   _mode = Mode::None;

   // Stop server (Clients get stopped on ACK)
   if (getClientFromId(_streamingSource) != nullptr) {
      getClientFromId(_streamingSource)->stopVncServer();
   }

   // Unlock all clients
   for (auto * frame : _clientFrames) {
      if (frame->client() != nullptr) {
         frame->client()->lockScreen(lock);
         frame->client()->removeAttention();
      }
   }

}

/*
 * Slots
 */

void MainWindow::onFrameMoving(ConnectionFrame* connectionFrame)
{
   // Get where the frame would be placed, and show a blue shadow in that spot
   QPoint slot = closestFreeSlot(connectionFrame->pos(), connectionFrame);
   _dropMarker->setGeometry(slot.x() * getTileWidthPx(), slot.y() * getTileHeightPx(), connectionFrame->width(), connectionFrame->height());
   if (!_dropMarker->isVisible()) {
      _dropMarker->lower();
      ui->imageLabel->lower();
      _dropMarker->show();
   }
}

void MainWindow::onFrameDropped(ConnectionFrame* connectionFrame)
{
   _dropMarker->hide();
   const QPoint preferredPixels = connectionFrame->pos();
   placeFrameInFreeSlot(connectionFrame, preferredPixels);
}

void MainWindow::onFrameClicked(ConnectionFrame* frame)
{
   _dropMarker->hide();
   ConnectionFrame *current = getSelectedFrame();
   // If same frame is clicked again, do nothing
   if (current == frame)
      return;

   // If another frame has been selected, unselect it
   // Set the ui selected and set a new reference
   if (current != nullptr) {
      current->setSelection(false);
   }
   frame->setSelection(true);
   updateContextButtonStates();
}

void MainWindow::onSessionNameClick()
{
   _sessionNameWindow->show((serverApp->sessionName()));
}

void MainWindow::onSessionNameUpdate()
{
   _sessionNameLabel->setText(tr("Session Name: %1  [click to edit]").arg(serverApp->sessionName()));
   bool haveAdditionalClient = false;
   for (QMutableListIterator<ConnectionFrame*> it(_clientFrames); it.hasNext(); ) {
      if (!it.next()->isFromRoomplan()) {
         haveAdditionalClient = true;
         break;
      }
   }
   if (!haveAdditionalClient)
      return; // No additional client exists, don't ask about reset
   // Current layout contains additional clients (voa session name), ask to delete
   QMessageBox::StandardButton ret = QMessageBox::question(this,
         tr("Question"), tr("Do you want to delete and disconnect any clients\n"
            "not belonging to the current room layout?"),
         QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
   if (ret != QMessageBox::Yes)
      return;
   // Stop all projections and clear all clients, which were connected to old sessionName.
   reset();
   for (QMutableListIterator<ConnectionFrame*> it(_clientFrames); it.hasNext(); ) {
      ConnectionFrame *cf = it.next();
      if (!cf->isFromRoomplan()) {
         cf->hide();
         cf->deleteLater();
         it.remove();
      }
   }
}

void MainWindow::startVncServerIfNecessary(int from)
{
   Client* os = getClientFromId(_streamingSource);
   Client* ns = getClientFromId(from);

   // if there is a server running which is not "from" stop it.
   if (os != nullptr && _streamingSource != from)
      os->stopVncServer();

   // Set new streaming source
   _streamingSource = from;

   // If streaming source is already active avoid a restart
   if (ns != nullptr) {
      if (ns->isActiveVncServer()) {
         this->onVncServerStateChange(ns);
      } else { // Could not take shortcut, (re)start VNC server on source
         ns->startVncServer();
      }
      ns->removeAttention();
   }
}

void MainWindow::onButtonReloadRoomConfig()
{
   connect(_reloadWindow->buttonBox(), &QDialogButtonBox::accepted, this, &MainWindow::onReloadRoomOk);
   connect(_reloadWindow->buttonBox(), &QDialogButtonBox::rejected, this, &MainWindow::onReloadRoomCancel);
   QList<QString> keyList = serverApp->getRooms().keys();
   for (const auto & it : keyList) {
      _reloadWindow->addRoom(it);
   }
   _reloadWindow->show();
}

void MainWindow::onReloadRoomCancel()
{
   disconnect(_reloadWindow->buttonBox(), &QDialogButtonBox::accepted, this, &MainWindow::onReloadRoomOk);
   disconnect(_reloadWindow->buttonBox(), &QDialogButtonBox::rejected, this, &MainWindow::onReloadRoomCancel);
   _reloadWindow->clearRoomList();
   _reloadWindow->hide();
}

void MainWindow::reloadCurrentRoom()
{
   /* delete old image */
   delete _backgroundImage;
   _backgroundImage = nullptr;

   const Room *room = serverApp->getCurrentRoom();
   if (room != nullptr) {
      /* set tiles */
      _tilesX = room->gridSize.width();
      _tilesY = room->gridSize.height();


      /* place connection frames */
      for (auto it = room->clientPositions.begin(); it != room->clientPositions.end(); ++it) {
         const QString& computerId = it.key();
         const QPoint& pos = it.value();

         ConnectionFrame *cf = createFrame(computerId, &pos, true);
         onFrameDropped(cf);
         if (computerId == room->tutorIP) {
            qDebug() << "set computer with id " << computerId << " as tutor per configuration";
            if (getTutorFrame() != nullptr) {
               getTutorFrame()->setTutor(false);
            }
            cf->setTutor(true);
         }
      }

      /* load background image */
      QString imgPath = room->imagePath;
      qDebug() << "imgPath is " << imgPath;

      if (imgPath != "") {
         qDebug() << "set background image path: " << imgPath;
         if (imgPath.endsWith("svg")) {
            /* render once with maximal screen size */
            QSize s = QGuiApplication::screenAt(geometry().center())->size();
            QSvgRenderer renderer(imgPath);
            _backgroundImage = new QImage(s, QImage::Format_ARGB32);
            _backgroundImage->fill(Qt::lightGray); /* background color */
            QPainter painter(_backgroundImage);
            renderer.render(&painter);
         } else {
            _backgroundImage = new QImage();
            _backgroundImage->load(imgPath);
         }
      }
   }

   /* and force a resize event (this scales the image)  */
   resizeEvent(nullptr);
   clientCountChanged();
}

void MainWindow::onReloadRoomOk()
{
    QString roomToReload = _reloadWindow->currentRoom();
   if (roomToReload.isEmpty()) {
      QMessageBox::critical(this, "Warning", tr("No item selected, please select room!"), 0, 1);
      return;
   }
   QMessageBox::StandardButton ret = QMessageBox::question(this, tr("Warning"),
         tr("Are you sure you want to reload the room?\n"
            "Note that all clients will be deleted."),
         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
   if (ret == QMessageBox::Yes) {
      disconnect(_reloadWindow->buttonBox(), &QDialogButtonBox::accepted, this, &MainWindow::onReloadRoomOk);
      disconnect(_reloadWindow->buttonBox(), &QDialogButtonBox::rejected, this, &MainWindow::onReloadRoomCancel);
      // Delete all clients.
      for (auto * frame : _clientFrames) {
         frame->hide();
         frame->deleteLater();
      }
      _clientFrames.clear();

      // Load new room configuration.
      serverApp->setCurrentRoom(roomToReload);
      reloadCurrentRoom();

      _reloadWindow->clearRoomList();
      _reloadWindow->hide();

   }
}

int MainWindow::getTileWidthPx() const
{

   return ui->frmRoom->size().width() / _tilesX;
}

int MainWindow::getTileHeightPx() const
{
   return ui->frmRoom->size().height() / _tilesY;
}

QRect MainWindow::calcFrameGeometry(ConnectionFrame* frame) const
{
   const QPoint pos = frame->getGridPosition();
   const QSize& clientSize = serverApp->getCurrentRoom()->clientSize;
   const int w = getTileWidthPx();
   const int h = getTileHeightPx();
   return QRect(pos.x() * w, pos.y() * h, w * clientSize.width(), h * clientSize.height());
}

void MainWindow::onButtonHelp()
{
   _helpWindow->show();
}

void MainWindow::onButtonTutorToAll()
{
   ui->action_Lock->setChecked(false);

   if (getTutorFrame() == nullptr)
      QMessageBox::critical(this, tr("Projection"), sStrTutorNdef);
   else if (getTutorFrame()->client() == nullptr)
      QMessageBox::critical(this, tr("Projection"), sStrTutorOffline);
   else if (_clientFrames.size() == 1)
      QMessageBox::critical(this, tr("Projection"), sStrNoDestAv);
   else {
      // If this mode is already active, reset everything
      if (_mode == Mode::Broadcast) {
         reset();
         return;
      }

      // Set all clients as watchers of tutor. Except for the tutors desired source, which hase to be none
      for (auto * frame : _clientFrames)
         if (frame->client() != nullptr)
            frame->client()->setDesiredProjectionSource(frame->client() == getTutorFrame()->client() ? NO_SOURCE : getTutorFrame()->client()->id());

      disableButtons();
      _mode = Mode::Broadcast;
      startVncServerIfNecessary(getTutorFrame()->client()->id());
   }
}

void MainWindow::onButtonTutorToStudent()
{
   ui->action_Lock->setChecked(false);

   if (getSelectedFrame() == nullptr)
      QMessageBox::critical(this, tr("Projection"), sStrDestNdef);
   else if (getTutorFrame() == nullptr)
      QMessageBox::critical(this, tr("Projection"), sStrTutorNdef);
   else if (getSelectedFrame() == getTutorFrame())
      QMessageBox::critical(this, tr("Projection"), sStrSourceDestSame);
   else if (getSelectedFrame()->client() == nullptr)
      QMessageBox::critical(this, tr("Projection"), sStrDestOffline);
   else if (getTutorFrame()->client() == nullptr)
      QMessageBox::critical(this, tr("Projection"), sStrTutorOffline);
   else {
        auto sourceClient = getTutorFrame()->client();
        auto destinationClient = getSelectedFrame()->client();
      // If this is the first call in this mode clear the watchers
      if (_mode != Mode::Multicast) {
            for (auto c : _clientFrames) {
                if (c->client() != nullptr) {
                    c->client()->stopVncClient();
                }
            }
      }

      // If "to" already watches "from" stop it
        if (destinationClient->desiredProjectionSource() == sourceClient->id() ) {
            destinationClient->stopVncClient();
        } else {
            destinationClient->setDesiredProjectionSource(sourceClient->id());
        }

      disableButtons();
        int numClients = 0;
        for (auto * c : _clientFrames) {
            if (c->client() != nullptr && c->client()->desiredProjectionSource() == sourceClient->id()) {
                numClients++;
            }
        }
        if (numClients == 0) {
            _mode = Mode::None;
            sourceClient->stopVncServer();
        } else {
            _mode = Mode::Multicast;
            startVncServerIfNecessary(sourceClient->id());
        }
   }
}

void MainWindow::onButtonStudentToTutor()
{
   this->vncOneOnOne(false);
}


void MainWindow::onButtonStudentToTutorExclusive()
{
   this->vncOneOnOne(true);
}

void MainWindow::vncOneOnOne(bool exclusive)
{
   if (getSelectedFrame() == nullptr) {
      QMessageBox::critical(this, tr("Projection"), sStrSourceNdef);
   } else if (getTutorFrame() == nullptr) {
      QMessageBox::critical(this, tr("Projection"), sStrTutorNdef);
   } else if (getTutorFrame() == getSelectedFrame()) {
      QMessageBox::critical(this, tr("Projection"), sStrSourceDestSame);
   } else if (getSelectedFrame()->client() == nullptr) {
      QMessageBox::critical(this, tr("Projection"), sStrSourceOffline);
   } else if (getTutorFrame()->client() == nullptr) {
      QMessageBox::critical(this, tr("Projection"), sStrTutorOffline);
   } else {
      const bool wasLocked = ui->action_Lock->isChecked();
      ui->action_Lock->setChecked(false);
      Client *source = getSelectedFrame()->client();
      Client *dest = getTutorFrame()->client();
      const Mode mode = exclusive ? Mode::LockedUnicast : Mode::Unicast;

      if (_mode == mode && source->id() == dest->desiredProjectionSource()) {
         // Button clicked again with same selection, treat this as reset
         reset();
         return;
      }

      for (ConnectionFrame* f : _clientFrames) {
         if (f->client() == nullptr) // Disconnected frame
            continue;
         if (source != f->client() && dest != f->client()) { //Not source or destination
            f->client()->setDesiredProjectionSource(NO_SOURCE);
            if (_mode == Mode::Unicast) { // Already in unlocked unicast mode
               if (exclusive) { // Only change lock state (to locked) if switching to locked unicast
                  f->client()->lockScreen(true); // (don't change otherwise, would reset individually locked clients)
               }
            } else if (wasLocked) { // Was in "lock all" mode, update lock mode for everyone
               f->client()->lockScreen(exclusive);
            }
         }
      }
      dest->lockScreen(false);
      source->lockScreen(false);
      dest->setDesiredProjectionSource(source->id());
      source->setDesiredProjectionSource(NO_SOURCE);
      disableButtons();
      _mode = mode;
      startVncServerIfNecessary(source->id());
   }
}

void MainWindow::onButtonStopProjection()
{
   ui->action_Lock->setChecked(false);
   reset();
}

void MainWindow::onButtonLock(bool checked)
{
   // Stop all projections and lock if requested
   reset(checked);
}

void MainWindow::onButtonLockSingle()
{
   // If no frame is selected, warning.
   if (getSelectedFrame() == nullptr) {
      QMessageBox::critical(this, tr("Selection"), tr("No client is selected."));
      return;
   }
   Client *client = getSelectedFrame()->client();

   // If frame of inactive client has been selected unselect it
   if (client == nullptr) {
      QMessageBox::critical(this, tr("Selection"), tr("The selected client is not connected."));
      return;
   } else { // If selected client is locked, first unlock
      bool newState = !client->isLocked();
      client->lockScreen(newState);
      if (!newState) {
         // If no more clients are locked, reset button
         for (auto * frame : _clientFrames) {
            if (frame->client() == nullptr)
               continue;
            if (frame->client()->isLocked())
               return;
         }
         ui->action_Lock->setChecked(false);
      }
   }
}

void MainWindow::onButtonExit()
{
   this->close();
}

void MainWindow::onButtonSetAsTutor()
{
   ConnectionFrame *selected = getSelectedFrame();
   ConnectionFrame *tutor = getTutorFrame();

   if (selected == nullptr) {
      QMessageBox::critical(this, tr("Selection"), tr("No client is selected."));
      return;
   }

   // Unlock client about to become a tutor, just in case
   if (selected->client() != nullptr) {
      selected->client()->lockScreen(false);
   }
   // If same frame is already tutor, do nothing
   if (selected == tutor)
      return;
   // Else unset the old and set the new tutor
   if (tutor != nullptr) {
      tutor->setTutor(false);
   }
   selected->setTutor(true);
   updateContextButtonStates();
}

void MainWindow::onClientConnected(Client* client)
{
   connect(client, &Client::authenticating, this, &MainWindow::onClientAuthenticating);
   connect(client, &Client::authenticated, this, &MainWindow::onClientAuthenticated);
}

void MainWindow::onClientAuthenticating(Client* client, ClientLogin* request)
{
   disconnect(client, &Client::authenticating, this, &MainWindow::onClientAuthenticating);
   /* copy examMode */
   client->setExamMode(request->examMode);

   if (!request->accept) // Another receiver of that signal already rejected the client, so nothing to do
      return;
   bool inuse;
   QString check = request->name;
   int addnum = 1;
   do {
      inuse = false;
      for (auto * frame : _clientFrames) {
         Client *c = frame->client();
         if (c == nullptr)
            continue;
         if (!c->isAuthed())
            continue;
         if (c->ip() == request->ip) {
            request->accept = false;
            return;
         }
         if (c->name() == check) {
            inuse = true;
            check = request->name + " (" + QString::number(++addnum) + ")";
            break;
         }
      }
   } while (inuse && addnum < 100);
   if (inuse) {
      request->accept = false;
   } else {
      request->name = check;
   }
}

void MainWindow::onClientAuthenticated(Client* client)
{
   disconnect(client, &Client::authenticated, this, &MainWindow::onClientAuthenticated);
   connect(client, &Client::vncServerStateChange, this, &MainWindow::onVncServerStateChange);
   connect(client, &Client::vncClientStateChange, this, &MainWindow::onVncClientStateChange);
   ConnectionFrame *existing = nullptr;
   ConnectionFrame *cf = nullptr;
   for (auto * frame : _clientFrames) {
      if (frame->computerId() == client->ip()) {
         existing = frame;
      }
   }

   // Clients ip already exists, but was not active.
   if (existing != nullptr) {
      cf = existing;
   } else {
      cf = createFrame();
   }

   cf->assignClient(client);
   connect(client, &Client::disconnected, this, &MainWindow::clientCountChanged);
   tellClientCurrentSituation(client);
   clientCountChanged();
}

void MainWindow::onVncServerStateChange(Client* client)
{
   if (client == getClientFromId(_streamingSource)) {
      enableButtons();
   }

   if (client->isActiveVncServer()) {
      // apply the desired projection sources
      for (ConnectionFrame *frame : _clientFrames) {
         if (frame->client() == nullptr) // Ignore offline clients
            continue;
         if (frame->client()->desiredProjectionSource() == client->id()) {
            frame->client()->startVncClient(client);
            client->lockScreen(false);
         } else {
            frame->client()->lockScreen(frame->client()->desiredProjectionSource() == NO_SOURCE && _mode == Mode::LockedUnicast);
         }
      }
      // Dont forget to unlock the vnc server
      client->lockScreen(false);
   } else {
      // VNC server stopped on some client or failed to start - reset local pending projection information
      for (auto * frame : _clientFrames) {
         if (frame->client() != nullptr) {
            if (frame->client()->desiredProjectionSource() == client->id()) {
               frame->client()->setDesiredProjectionSource(NO_SOURCE);
               frame->client()->stopVncClient();
               if (_mode == Mode::LockedUnicast)
                  frame->client()->lockScreen(true);
            }
         }
      }
      // Dont forget to unlock the vnc server (if necesarry)
      client->lockScreen((client->desiredProjectionSource() == NO_SOURCE &&  _mode == Mode::LockedUnicast)
                     || ui->action_Lock->isChecked());

      // If this was the current source remember that there is no source anymore and reset mode
      if (client == getClientFromId(_streamingSource)) {
         _streamingSource = NO_SOURCE;
         _mode = Mode::None;
      }
   }
}

void MainWindow::onVncClientStateChange(Client* client)
{
   if (client != nullptr) {
      // VNC Client stopped -> remove from watchers
      if (!client->isActiveVncClient()) {
         // Only unset a desired Projection source if it has not changed meanwhile
         if (client->projectionSource() == client->desiredProjectionSource())
            client->setDesiredProjectionSource(NO_SOURCE);

         /*
          * If nobody is watching the VNC server of the pvsclient that
          * stopped its vncclient stop it. (The _LAST_ vncserver, there
          * may be a new one)
          * This is necessary for the race condition when a server
          * is stopped and another started at the same time, since the new
          * server would be killed if all client disconnect before any of
          * the new connect.
          */
         bool serverHasWatchers = false;
         for (auto * frame : _clientFrames)
            if (frame->client() != nullptr)
               if (frame->client()->desiredProjectionSource() == client->projectionSource()) {
                  serverHasWatchers = true;
                  break;
               }

         if (!serverHasWatchers) {
            Client* c = getClientFromId(client->projectionSource());
            if (c != nullptr)
               c->stopVncServer();
         }
      }
   }
}

void MainWindow::disableButtons()
{
   _buttonLockTimer->start();
   for (QAction *a : _lockingButtons) {
      a->setDisabled(true);
   }
}

void MainWindow::enableButtons()
{
   _buttonLockTimer->stop();
   for (QAction *a : _lockingButtons) {
      a->setEnabled(true);
   }
   updateContextButtonStates(); // In case user changed selection while buttons were disabled
}


void MainWindow::onDeleteClient()
{
   // If no frame is selected, warning.
   ConnectionFrame* frame = getSelectedFrame();
   if (frame == nullptr) {
      QMessageBox::critical(this, tr("Selection"), tr("No client is selected."));
      return;
   }
   if (frame->client() != nullptr) {
      QMessageBox::critical(this, tr("Selection"), tr("This client is still connected."));
      return;
   }
   QMessageBox::StandardButton ret = QMessageBox::question(this, tr("Warning"), tr("Are you sure you want to delete the selected client?"),
         QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
   if (ret == QMessageBox::Yes) {
      frame->hide();
      frame->deleteLater();
      _clientFrames.removeAll(frame);
      clientCountChanged();
      return;
   }
}