diff options
Diffstat (limited to 'src/gui/connectionWindow.cpp')
| -rw-r--r-- | src/gui/connectionWindow.cpp | 763 |
1 files changed, 763 insertions, 0 deletions
diff --git a/src/gui/connectionWindow.cpp b/src/gui/connectionWindow.cpp new file mode 100644 index 0000000..cf51051 --- /dev/null +++ b/src/gui/connectionWindow.cpp @@ -0,0 +1,763 @@ +/* + # 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/ + # ----------------------------------------------------------------------------- + # src/gui/connectionWindow.cpp + # ----------------------------------------------------------------------------- + */ + +#include "connectionWindow.h" +#include <src/core/pvsConnectionManager.h> +#include <src/gui/mainWindow.h> + +ConnectionWindow::ConnectionWindow(QWidget *parent) : + QWidget(parent) { + + //initialize the position for the frame in the clientView + posX = 4; + posY = 4; + + _closeupFrame = NULL; + hasDozent = false; // at the begin we don't have a dozent machine + + QPalette newPalette = palette(); + newPalette.setColor(QPalette::Window, Qt::white); + setPalette(newPalette); + + newDummy = new QAction(tr("&Add a dummy..."), this); // set a dummy + connect(newDummy, SIGNAL(triggered()), this, SLOT(addDummy())); + + menu = new QMenu(this); + menu->addAction(newDummy); + + setAcceptDrops(true); //drag&drop should be enabled +} + +ConnectionWindow::~ConnectionWindow() { + // +} + +void ConnectionWindow::addFrame(ConnectionFrame *cF) { + bool found = false; + foreach (ConnectionFrame* cFr, AllFrameOnWindow) + { + if (QString::compare(cF->getTaskbarTitle(), cFr->getTaskbarTitle(), Qt::CaseInsensitive) == 0) + { + QPoint cuP = currentPosition(cFr); + cF->move(cuP); + AllFrameOnWindow.append(cF); + AllFrameOnWindow.removeOne(cFr); //we don't need this dummy any more + cFr->deleteLater(); + found = true; + return; + } + } + + /* If the Frame don't belong to the profile + * we have to move it at the default position for now. + * The user can move this later to his favorite position. + */ + if (!found) + { + foreach (clientLocation cur, ClientLocationList) + { + if (QString::compare(cF->getTaskbarTitle(), cur.first, Qt::CaseInsensitive) == 0) + { + cF->move(cur.second); + found = true; + return; + } + } + } + + if (!found) + cF->move(10, 10); +} + +void ConnectionWindow::addFrameBySettings(QString client, QPoint pos) { + clientLocation cur(client, pos); + ClientLocationList.append(cur); +} + +void ConnectionWindow::showFrameFromSettings() { + foreach (clientLocation cur, ClientLocationList) + { + ConnectionFrame* dummy = new ConnectionFrame( + MainWindow::getConnectionWindow()); + AllFrameOnWindow.append(dummy); + dummy->setTheTitle("[No name]"); + dummy->setTaskbarTitle(cur.first); + dummy->setDummy(true); + dummy->move(cur.second); + } +} + +void ConnectionWindow::addDummy() { //function to add a dummy + ConnectionFrame* dummy = new ConnectionFrame( + MainWindow::getConnectionWindow()); + dummy->setTheTitle("[No name]"); + dummy->setTaskbarTitle("[0.0.0.0]"); + QPoint p = QPoint(10, 10);//the default move position, when created a dummy screen + AllFrameOnWindow.append(dummy); + clientLocation cur("[No name]", p); + ClientLocationList.append(cur); + dummy->setDummy(true); + dummy->move(p); + dummy->setStyleSheet(QString::fromUtf8( + "background-color: rgb(150, 150, 168);")); +} + +void ConnectionWindow::mousePressEvent(QMouseEvent *event) { //catch the mouse press event + if (event->button() == Qt::RightButton) + menu->exec(QCursor::pos()); +} + +QPoint ConnectionWindow::currentPosition(ConnectionFrame* cF) { + QPoint pos = QPoint(10, 10); + clientLocation cur; + foreach (cur, ClientLocationList) + { + if (QString::compare(cF->getTaskbarTitle(), cur.first, Qt::CaseInsensitive) == 0) + return cur.second; + } + return pos; +} + +int ConnectionWindow::itemAt(ConnectionFrame* cf) +{ + for (int i = AllFrameOnWindow.size() - 1; i >= 0; --i) + { + ConnectionFrame* item = AllFrameOnWindow.at(i); + if (cf->pos().x() == item->pos().x() && cf->pos().y() == item->pos().y()) + return i; + } + return -1; +} + +void ConnectionWindow::removeFromList(ConnectionFrame* cF) { + //dummyList.removeOne(cF); + if(AllFrameOnWindow.contains(cF)) + AllFrameOnWindow.removeOne(cF); + cF->deleteLater(); +} + +void ConnectionWindow::onChangeConnections() { + + //clear the view + if (!frameList.empty()) { + ConnectionFrame* tmpIt; + foreach (tmpIt, frameList) + { + if (tmpIt != currentSingleFrame) + tmpIt->setActive(false); + tmpIt->hide(); + } + } + +} + +bool ConnectionWindow::projectStations(QString sname) { + QString password, hostname; + int port, quality; + ConsoleLog writeLine(QString("Projecting from: ").append(sname)); + //TODO add method parameter for this + quality = 0; + + QList<QString> projectList = + MainWindow::getConnectionList()->getTargetForTheProject(sname); + + if (!projectList.isEmpty()) { + PVSClient* tmpSrcConnection = + PVSConnectionManager::getManager()->getClientFromIp(sname); + if (tmpSrcConnection) { + if (!tmpSrcConnection->getVNCAllowed()) { + ConsoleLog writeError(QString("VNC is not allowed on Projection Source: ").append(sname)); + ConsoleLog writeError(QString("Trying to start VNC-Server on Client: ").append(sname)); + tmpSrcConnection->setProject(true); + return false; + } + password = tmpSrcConnection->getPassword(); + port = tmpSrcConnection->getPort(); + hostname = sname; + tmpSrcConnection->getConnectionFrame()->setSource(); + ConsoleLog writeError (QString("port: ").append(int2String(port))); + ConsoleLog writeError (QString("passwort: ").append(password)); + ConsoleLog writeError (QString("pr-sourcename: ").append(sname)); + + } + else + { + return false; + } + + ConsoleLog writeError (QString("port as int: ").append(port)); + ConsoleLog writeError (QString("port as String: ").append(int2String(port))); + + QString item; + foreach (item, projectList) + { + PVSClient* tmpConnection = PVSConnectionManager::getManager()->getClientFromIp(item); + if (tmpConnection) + { + ConsoleLog writeError (QString("sending vnc data to: ").append(tmpConnection->getIp())); + tmpConnection->sendMessage(PVSCOMMAND,"PROJECT", hostname + " " + int2String(port) + " " + password + " " + int2String(quality)); + tmpConnection->getConnectionFrame()->setTarget(); + } + else + { + // scream in agony + } + } + } + return true; +} + +bool ConnectionWindow::remoteHelp(QString sname) { + + //TODO Finish this... + QString password, hostname; + int port; + + PVSClient* tmpSrcConnection = + PVSConnectionManager::getManager()->getClientFromIp(sname); + QList<QString> projectList = + MainWindow::getConnectionList()->getTargetForTheProject(sname); + if (tmpSrcConnection) { + if (!tmpSrcConnection->getVNCAllowed()) { + tmpSrcConnection->requestVNCConnect(); + tmpSrcConnection->setProject(true); + return false; + } + password = tmpSrcConnection->getRWPassword(); + port = tmpSrcConnection->getPort(); + hostname = sname; + tmpSrcConnection->getConnectionFrame()->setSource(); + } else { + return false; + } + + QString item; + foreach (item, projectList) + { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp(item); + if (tmpConnection) { + ConsoleLog writeError(QString("sending vnc data to: ").append( + tmpConnection->getIp())); + tmpConnection->sendMessage(PVSCOMMAND, "PROJECT", hostname + + " " + int2String(port) + " " + password); + tmpConnection->getConnectionFrame()->setTarget(); + } else { + // scream in agony + } + } + return true; + +} + + + +bool ConnectionWindow::lockStations() { + if (std::list<QString>* lockList = MainWindow::getConnectionList()->getSelectedClients()) { + if (!lockList->empty()) { + for (std::list<QString>::iterator tmpIt = lockList->begin(); tmpIt + != lockList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + if (tmpConnection->getConnectionFrame()->getFrame()) + { + // we don't want to lock the dozent machine + if (tmpConnection && !tmpConnection->getConnectionFrame()->getFrame()->isDozent() + && !tmpConnection->getConnectionFrame()->isOnProjekt()) + lockStation(tmpConnection); + else { + // scream in agony + } + } + } + } + delete lockList; + } + return true; +} + +void ConnectionWindow::lockStation(PVSClient* pvsCon) { + if (pvsCon->getVNCConnection()) + { + pvsCon->getConnectionFrame()->getFrame()->setLockStatus(true); + // we call the update to force Qt to paint the lockicon on the frame + pvsCon->getConnectionFrame()->getFrame()->update(); + pvsCon->sendMessage(PVSCOMMAND, "LOCKSTATION", ""); + } +} + +bool ConnectionWindow::unlockStations() { + if (std::list<QString>* unlockList = MainWindow::getConnectionList()->getSelectedClients()) { + if (!unlockList->empty()) { + for (std::list<QString>::iterator tmpIt = unlockList->begin(); tmpIt + != unlockList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + if (tmpConnection && tmpConnection->getConnectionFrame()->getFrame() && + tmpConnection->getVNCConnection()) { + tmpConnection->getConnectionFrame()->getFrame()->setLockStatus(false); + tmpConnection->getConnectionFrame()->getFrame()->update(); // we call the update to force Qt to paint the lock on the frame + tmpConnection->sendMessage(PVSCOMMAND, "UNLOCKSTATION", ""); + } else { + // scream in agony + } + } + } + delete unlockList; + } + return true; +} + +void ConnectionWindow::unlockStation(PVSClient* pvsCon) { + if (pvsCon->getVNCConnection()) + { + pvsCon->getConnectionFrame()->getFrame()->setLockStatus(false); + // we call the update to force Qt to paint the lockicon on the frame + pvsCon->getConnectionFrame()->getFrame()->update(); + pvsCon->sendMessage(PVSCOMMAND, "UNLOCKSTATION", ""); + } +} + +bool ConnectionWindow::lockAllStations() +{ + if (!hasDozent) + { + QString message = QString(tr("You have to set a Superclient-machine before performing this action.")); + QMessageBox::information(this, "PVS", message); + return false; + } + std::list<PVSClient*> listAll = + PVSConnectionManager::getManager()->getConnections(); + for (std::list<PVSClient*>::iterator it = listAll.begin(); it + != listAll.end(); it++) + { + if (*it == NULL || (*it)->getConnectionFrame() == NULL) continue; + // we don't want to lock the superclient machine + if ((*it)->getConnectionFrame()->getFrame() && + !(*it)->getConnectionFrame()->getFrame()->isDozent() && + (*it)->getVNCConnection()) + (*it)->sendMessage(PVSCOMMAND, "LOCKSTATION", ""); + else if (!(*it)->getConnectionFrame()->getFrame()) + ConsoleLog writeError(QString("The Frame connection from client: "). + append((*it)->getConnectionFrame()->getTaskbarTitle()). + append(QString(" is corrupted. Reconned the client it again."))); + } + return true; +} + +bool ConnectionWindow::unlockAllStations() { + std::list<PVSClient*> listAll = + PVSConnectionManager::getManager()->getConnections(); + for (std::list<PVSClient*>::iterator it = listAll.begin(); it + != listAll.end(); it++) + { + if ((*it)->getVNCConnection()) + { + (*it)->getConnectionFrame()->getFrame()->setLockStatus(false); + (*it)->getConnectionFrame()->getFrame()->update(); // we call the update to force Qt to repaint the frame + (*it)->sendMessage(PVSCOMMAND, "UNLOCKSTATION", ""); + } + // otherwise this will get scattered all over the place + } + return true; +} + +bool ConnectionWindow::unprojectStations(QString sname) { + PVSClient* tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp(sname); + if (tmpConnection && tmpConnection->getVNCConnection()) { + tmpConnection->sendMessage(PVSCOMMAND, "UNPROJECT", ""); + tmpConnection->getConnectionFrame()->setUnproject(); + } else { + // scream in agony + } + + return true; +} + +bool ConnectionWindow::unprojectAllStations() { + std::list<PVSClient*> listAll = + PVSConnectionManager::getManager()->getConnections(); + for (std::list<PVSClient*>::iterator it = listAll.begin(); it + != listAll.end(); it++) + { + if ((*it)->getVNCConnection()) + { + (*it)->sendMessage(PVSCOMMAND, "UNPROJECT", ""); + (*it)->getConnectionFrame()->setUnproject(); + } + } + return true; +} + +bool ConnectionWindow::lockInvertStations() { + // ok, this method is highly imperformant i guess + // we're going thru all existing connections, and if they dont equal one of the selected (another loop) + // we lock them... + if (std::list<QString>* lockList = MainWindow::getConnectionList()->getSelectedClients()) { + std::list<PVSClient*> listAll = + PVSConnectionManager::getManager()->getConnections(); + bool skip = false; + for (std::list<PVSClient*>::iterator it = listAll.begin(); it + != listAll.end(); it++) { + if (!lockList->empty()) { + for (std::list<QString>::iterator tmpIt = lockList->begin(); tmpIt + != lockList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + if (tmpConnection == (*it)) { + skip = true; + break; + } + } + } + if (!skip) + (*it)->sendMessage(PVSCOMMAND, "LOCKSTATION", "");//TODO define some standard to grab this from... + // otherwise this will get scattered all over the place + } + delete lockList; + } + return true; +} + +void ConnectionWindow::lockInvertStation(PVSClient* pvsCon) { + pvsCon->sendMessage(PVSCOMMAND, "LOCKSTATION", ""); +} + +bool ConnectionWindow::messageStations(QString ident, QString message) { + if (std::list<QString>* messageList = MainWindow::getConnectionList()->getSelectedClients()) { + if (!messageList->empty()) { + for (std::list<QString>::iterator tmpIt = messageList->begin(); tmpIt + != messageList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + // we don't want to lock the dozent machine + if (tmpConnection && tmpConnection->getConnectionFrame()->getFrame() && + !tmpConnection->getConnectionFrame()->getFrame()->isDozent()) + { + messageStation(ident, message, tmpConnection); + } else { + // scream in agony + } + } + } + delete messageList; + } + return true; +} + +void ConnectionWindow::messageStation(QString ident, QString message, + PVSClient* pvsCon) { + pvsCon->sendMessage(PVSMESSAGE, ident, message); +} + +bool ConnectionWindow::lockStationsWithMessage(QString message) +{ + if (!hasDozent) + { + QString message = QString(tr("You have to set a Superclient-machine before performing this action.")); + QMessageBox::information(this, "PVS", message); + return false; + } + if (std::list<QString>* messageList = MainWindow::getConnectionList()->getSelectedClients()) { + if (!messageList->empty()) { + for (std::list<QString>::iterator tmpIt = messageList->begin(); tmpIt + != messageList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + // we don't want to lock the dozent machine + if (tmpConnection && !tmpConnection->getConnectionFrame()->getFrame()->isDozent()) + { + lockStationsWithMessage(message, tmpConnection); + + } else { + // scream in agony + } + } + } + delete messageList; + } + return true; +} + +void ConnectionWindow::lockStationsWithMessage(QString message, + PVSClient* pvsCon) +{ + pvsCon->sendMessage(PVSCOMMAND, "LOCKSTATION", message); +} + +bool ConnectionWindow::lockAllStationsWithMessage(QString message) { + + if (!hasDozent) + { + QString message = QString(tr("You have to set a Superclient-machine before performing this action.")); + QMessageBox::information(this, "PVS", message); + return false; + } + std::list<PVSClient*> listAll = + PVSConnectionManager::getManager()->getConnections(); + for (std::list<PVSClient*>::iterator it = listAll.begin(); it + != listAll.end(); it++) + { + if ((*it) && !(*it)->getConnectionFrame()->getFrame()->isDozent()) // we don't want to lock the dozent machine + (*it)->sendMessage(PVSCOMMAND, "LOCKSTATION", message); + } + return true; +} + +void ConnectionWindow::addConnection(PVSClient* newCon) { + if (newCon) { + // QList<QString> ClientList= MainWindow::getConnectionList()->getClientist(); + + //Check if this client already in the list, before we add it. + //We don't want to have two clients with the same names. + //We comments it for test. + /*if (!ClientList.contains(newCon->getHostString())) + {*/ + onVNCAdd(newCon); + MainWindow::getConnectionList()->onAddClient(newCon); + /* + * We check if the pvsmgr run a lockAll on the already connected + * clients. If yes, we lock the new conencted client too. + */ + if (MainWindow::getWindow()->isLockAllStatus() && newCon->getConnectionFrame()->getFrame()) + { + newCon->getConnectionFrame()->getFrame()->setLockStatus(true); + // we call the update to force Qt to paint the lockicon on the frame + newCon->getConnectionFrame()->getFrame()->update(); + lockStation(newCon); + } + //} + } +} + +void ConnectionWindow::removeConnection(PVSClient* newCon) { + if (newCon == NULL) return; + ConnectionFrame* frame = newCon->getConnectionFrame(); + if (frame != NULL) + { + removeFromList(frame); + //frame->deleteLater(); + } + MainWindow::getConnectionList()->onRemoveClient(newCon); +} + +void ConnectionWindow::onView() { + if (std::list<QString>* selectedClient = MainWindow::getConnectionList()->getSelectedClients()) { + if (!selectedClient->empty()) { + if (selectedClient->size() == 1) + ;//TODO + + } + } +} + +void ConnectionWindow::updateConnection(PVSClient* newCon) { + if (newCon) { + MainWindow::getConnectionList()->onUpdateClient(newCon); + } +} + +void ConnectionWindow::addVNC() { + if (std::list<QString>* vncAddList = MainWindow::getConnectionList()->getSelectedClients()) { + if (!vncAddList->empty()) { + for (std::list<QString>::iterator tmpIt = vncAddList->begin(); tmpIt + != vncAddList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + if (tmpConnection) { + tmpConnection->requestVNCConnect(); + } else { + // scream in agony + } + } + } + } +} + +void ConnectionWindow::onVNCAdd(PVSClient* newCon) { + + if (!newCon->getConnectionFrame()) { + ConnectionFrame* newFrame = newConFrame(newCon); + newFrame->setConnection(newCon); + newFrame->setTaskbarTitle(newFrame->getTaskbarTitle()); + newFrame->setDummy(false); + newFrame->setFrameRate(500); + addFrame(newFrame); + if (!frameList.contains(newFrame)) + frameList.append(newFrame); + if (!AllFrameOnWindow.contains(newFrame)) + AllFrameOnWindow.append(newFrame); + newFrame->show(); + } else + // now we have already a pvsconnection, we should set the existing vncconnection to it + newCon->getConnectionFrame()->setConnection(newCon); + // addFrame(newFrame); +} + +void ConnectionWindow::removeVNC() { + std::list<QString>* vncRemoveList = + MainWindow::getConnectionList()->getSelectedClients(); + + // if(!vncRemoveList->empty()) + // { + for (std::list<QString>::iterator tmpIt = vncRemoveList->begin(); tmpIt + != vncRemoveList->end(); tmpIt++) { + PVSClient* tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + if (tmpConnection) { + if (tmpConnection->getVNCConnection()) { + ConnectionFrame* tmpFrame = + tmpConnection->getVNCConnection()->getFrame(); + if (tmpFrame) { + frameList.removeOne(tmpFrame); + onChangeConnections(); + tmpFrame->setConnection(NULL); + tmpFrame->initFrame(); + //delete tmpFrame; + } + tmpConnection->shutDownVNC(); + } + } else { + // scream in agony + } + } + // + // } +} + +void ConnectionWindow::onRemoveConnection() { + if (std::list<QString>* removeList = MainWindow::getConnectionList()->getSelectedClients()) { + if (!removeList->empty()) { + for (std::list<QString>::iterator tmpIt = removeList->begin(); tmpIt + != removeList->end(); tmpIt++) { + PVSClient + * tmpConnection = + PVSConnectionManager::getManager()->getClientFromIp( + (*tmpIt).toUtf8().data()); + if (tmpConnection) { + // removal should start from the CM, so hes linking back to the ConnectionWindow::onConnectionRemoved() method + // to finish the removal procedure here + PVSConnectionManager::getManager()->removeConnection( + tmpConnection); + } else { + // scream in agony + } + } + // onChangeConnections(); + } + delete removeList; + return; + } +} + +void ConnectionWindow::onConnectionRemoved(PVSClient* newConnection) { + + + if (newConnection->getVNCConnection()) + + // check for associated frames! + if (newConnection->getVNCConnection()) { + ConnectionFrame* tmpFrame = + newConnection->getVNCConnection()->getFrame(); + // now handle the case that the client disconnects while we are in fullscreen mode + // the vncconnection would be cut nevertheless, so this: + if (tmpFrame) { + frameList.removeOne(tmpFrame); + // now handle the case that the client disconnects while we are in fullscreen mode + // the vncconnection would be cut nevertheless, so this: + if (tmpFrame == currentSingleFrame) { + currentSingleFrame = NULL; + } + + // no longer needed + delete tmpFrame; + newConnection->getVNCConnection()->setFrame(NULL); + } + } +} + +void ConnectionWindow::setSize(int width, int height, bool forceSquare) { + if (height >= 100 && width >= 100) { + MainWindow::getWindow()->setPrevWidth(width); + MainWindow::getWindow()->setPrevHeight(height); + } + + ignoreRatio = forceSquare; + + if (!frameList.empty()) { + ConnectionFrame* item; + foreach (item, frameList) + { + item->setIgnoreRatio(ignoreRatio); + } + } +} + +void ConnectionWindow::getCloseupSize(int &width, int &height) { + if (!onCloseup) { + width = height = 0; + return; + } + + width = 150; + height = 150; +} + +bool ConnectionWindow::getShowDummies() { + return _showDummies; +} + +void ConnectionWindow::setShowDummies(bool show) { + +} + +ConnectionFrame* ConnectionWindow::newConFrame(PVSClient* newConnection) { + if (newConnection->getConnectionFrame()) { + return NULL; + } + ConnectionFrame* temp = new ConnectionFrame( + MainWindow::getConnectionWindow()); + if (!temp) { + return NULL; + } + return temp; +} + +void ConnectionWindow::setCloseupFrame(ConnectionFrame* cFrame) { + _closeupFrame = cFrame; +} + +ConnectionFrame* ConnectionWindow::getCloseupFrame() { + if (_closeupFrame) + return _closeupFrame; + + return NULL; +} + |