git.maemo.org Git - tablet-suite/blob - src/ui/.svn/text-base/pcsdeviceviewer.py.svn-base

   1 # Authors: Amaury Medeiros and Paulo Ouriques
   2 # Software License: GPL
   3
   4 from PyQt4.QtCore import *
   5 from PyQt4.QtGui import *
   6
   7 from functools import partial
   8 from time import sleep
   9
  10 from pcsdeviceinfoviewer import PcsDeviceInfoViewer
  11 from pcsdevicewidget import PcsDeviceWidget
  12 from pcsuiutils import *
  13 from tsuigeneralmethods import *
  14 from pcsutils import *
  15
  16 from style.styleTabletSuite import *
  17 from backup.pcswindowmanager import *
  18
  19 class PcsDeviceViewer(QFrame):
  20
  21     '''Class that displays the devices which are connected to the PC'''
  22
  23     _ip = "None"
  24     CONNECTION_ERROR_MESSAGE = "Could not connect to device with the given IP " + \
  25                     "address.\nCheck if device is turned on and is properly " + \
  26                     "connected to network"
  27
  28     def __init__(self, deviceManager, pcSuite):
  29         super(PcsDeviceViewer, self).__init__()
  30         self.deviceManager = deviceManager
  31         self.deviceManager.loadDevices()
  32 #        self.pcSuite = pcSuite
  33         self.setFixedSize(WINDOW_WIDTH, 150)
  34         self.deviceWidget = PcsDeviceWidget(0)
  35
  36         # Create device connection type
  37         self.deviceInfoViewer = PcsDeviceInfoViewer(pcSuite)
  38
  39         self.mainLayout = QHBoxLayout()
  40         self.mainLayout.setMargin(0)
  41
  42         spacer = QSpacerItem(15, 15)
  43         self.mainLayout.addItem(spacer)
  44         self.mainLayout.addWidget(self.deviceWidget)
  45         self.mainLayout.addItem(QSpacerItem(20,20))
  46         self.mainLayout.addLayout(self.deviceInfoViewer)
  47         self.mainLayout.addItem(spacer)
  48         self.setLayout(self.mainLayout)
  49
  50         self.connectDialog = None
  51
  52     def checkIp(self, ip):
  53         list = ip.split(".")
  54         if len(list) != 4:
  55             return False
  56         for sublist in list:
  57             if len(sublist) < 1 or len(sublist) > 3:
  58                 return False
  59             for element in sublist:
  60                 if not str(element).isdigit():
  61                     return False
  62         return True
  63
  64     def showConnectDialog(self):
  65         if(self.connectDialog == None):
  66             self.connectDialog = QDialog(self, Qt.FramelessWindowHint)
  67             self.connectDialog.setObjectName("connectDialog")
  68             self.connectDialog.setWindowIcon(QIcon(TABLET_SUITE_LOGO))
  69             self.connectDialog.setWindowTitle("Device Selection")
  70             connectDialogLayout = QVBoxLayout()
  71
  72             hLayout = QHBoxLayout()
  73             addButton = QPushButton("Add")
  74             addButton.setObjectName("smallButton")
  75             self.connect(addButton, SIGNAL("clicked()"), self.addIp)
  76
  77             self.ipField = QLineEdit()
  78             self.ipField.setText("IP Number")
  79             self.ipField.setObjectName("ipField")
  80             hLayout.addWidget(self.ipField)
  81             hLayout.addWidget(addButton)
  82
  83             buttonLayout = QHBoxLayout()
  84             self.connectButton = QPushButton("Connect")
  85             self.connectButton.setObjectName("tsButton")
  86             self.connect(self.connectButton, SIGNAL("clicked()"), self._connect)
  87
  88             self.deleteButton = QPushButton("Delete")
  89             self.deleteButton.setObjectName("tsButton")
  90             self.connect(self.deleteButton, SIGNAL("clicked()"), self._deleteSelectedIp)
  91
  92             cancelButton = QPushButton("Cancel")
  93             cancelButton.setObjectName("tsButton")
  94             setVisible = partial(self.connectDialog.setVisible, False)
  95             self.connect(cancelButton, SIGNAL("clicked()"), setVisible)
  96
  97             buttonLayout.addWidget(self.connectButton)
  98             buttonLayout.addWidget(self.deleteButton)
  99             buttonLayout.addWidget(cancelButton)
 100
 101             vLayout = QVBoxLayout()
 102             vLayout.setMargin(15)
 103             vLayout.addWidget(QLabel("Select the device IP"))
 104             vLayout.addLayout(hLayout)
 105             vLayout.addWidget(self._createIpList())
 106             connectDialogLayout.addLayout(vLayout)
 107             connectDialogLayout.addLayout(buttonLayout)
 108             self.connectDialog.setLayout(connectDialogLayout)
 109             self._updateIpList()
 110             self.connectDialog.exec_()
 111
 112         else:
 113             self._updateIpList()
 114             self.connectDialog.setVisible(True)
 115
 116     def _connect(self):
 117         self._ip = self.getSelectedIp()
 118         if not create_route(self._ip):
 119             showMessageBox(self.CONNECTION_ERROR_MESSAGE,
 120                               "Error while connecting to device")
 121             return False
 122         if not verify_exist_keys(self._ip):
 123             dialog = QMessageBox()
 124             dialog.setText( "Wrong Key, It seems that the device key " + \
 125                             "changed. Do you want to exchange keys again?")
 126             dialog.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
 127             dialog.setWindowFlags(Qt.FramelessWindowHint)
 128             dialog.setStyleSheet(MESSAGE_BOX_DEFAULT)
 129             ret = dialog.exec_()
 130             if ret == QMessageBox.Yes:
 131                 if not self.showPasswdDialog():
 132                     return False
 133             else:
 134                 return False
 135         self._runAddDevice()
 136
 137     def _createIpList(self):
 138         self.ipList = QTableView(self)
 139         self.ipList.setObjectName("ipList")
 140         self.ipList.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
 141         self.ipList.setAlternatingRowColors(True)
 142         self.ipList.setShowGrid(False)
 143         self.ipList.setEditTriggers(QAbstractItemView.NoEditTriggers)
 144         self.model = QStandardItemModel()
 145         self.ipList.setModel(self.model)
 146         self._updateButtonsState()
 147         self.connect(self.ipList.selectionModel(),
 148                      SIGNAL("selectionChanged(QItemSelection, QItemSelection)"),
 149                      self._updateButtonsState)
 150
 151         hHeader = QHeaderView(Qt.Horizontal)
 152         hHeader.setVisible(False)
 153         hHeader.setResizeMode(QHeaderView.ResizeToContents)
 154         hHeader.setMinimumSectionSize(225)
 155         self.ipList.setHorizontalHeader(hHeader)
 156
 157         vHeader = QHeaderView(Qt.Vertical)
 158         vHeader.setVisible(False)
 159         self.ipList.setVerticalHeader(vHeader)
 160
 161         return self.ipList
 162
 163     def _deleteSelectedIp(self):
 164         dialog = QMessageBox()
 165         dialog.setText("Remove selected ip?")
 166         dialog.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
 167         dialog.setWindowFlags(Qt.FramelessWindowHint)
 168         dialog.setStyleSheet(MESSAGE_BOX_APP)
 169         ret = dialog.exec_()
 170         if ret == QMessageBox.Yes:
 171             selectionModel = self.ipList.selectionModel()
 172             indexList = selectionModel.selectedRows()
 173             for index in indexList:
 174                 if index.isValid():
 175                     try:
 176                         ipAdress = self.model.itemData(index)[0].toString()
 177                         self.deviceManager.removeDevice(ipAdress)
 178                     except:
 179                         pass
 180                     finally:
 181                         self.model.removeRow(index.row())
 182
 183     def getSelectedIp(self):
 184         selectionModel = self.ipList.selectionModel()
 185         indexList = selectionModel.selectedRows()
 186
 187         for index in indexList:
 188             if index.isValid():
 189                 data = self.model.itemData(index)
 190                 return data[0].toString()
 191
 192     def showInvalidIpDialog(self):
 193         showMessageBox("Invalid ip adress", "Invalid ip")
 194
 195     def addIp(self):
 196         ip = self.ipField.text()
 197
 198         if self.checkIp(ip):
 199             for i in range(self.model.rowCount()):
 200                 if(self.model.item(i).text() == ip):
 201                     self.ipField.setText("IP Number")
 202                     return
 203             item = QStandardItem(ip)
 204             self.model.appendRow([item])
 205             self.ipField.setText("IP Number")
 206         else:
 207             self.showInvalidIpDialog()
 208
 209     def showPasswdDialog(self):
 210         (passwd, ok) = QInputDialog.getText(self, "Device Selection",
 211                                              "Root Password:",
 212                                               QLineEdit.Password,
 213                                               QString(),
 214                                               Qt.FramelessWindowHint)
 215         if ok and not passwd.isEmpty():
 216             self._passwd = passwd
 217             if not keyExchange(self._ip, self._passwd):
 218                 errorMessage = "Could not connect to device with the given IP " + \
 219                     "Could not exchange keys"
 220                 showMessageBox(errorMessage, "Error while connecting to device")
 221                 return False
 222             return True
 223
 224     def _updateButtonsState(self):
 225         selectionModel = self.ipList.selectionModel()
 226         indexList = selectionModel.selectedRows()
 227         if len(indexList) > 1 or len(indexList) <= 0:
 228             self.connectButton.setDisabled(True)
 229             self.deleteButton.setDisabled(True)
 230         else:
 231             self.connectButton.setEnabled(True)
 232             self.deleteButton.setEnabled(True)
 233
 234     def _createWindowManager(self, deviceInf):
 235          if deviceInf != None:
 236                 PcsWindowManager(deviceInf, self)
 237
 238     def _runAddDevice(self):
 239         self.connectingThread = connectingThread(self.deviceManager, self._ip)
 240         self.connect(self.connectingThread, SIGNAL("connectException"), self._connectException)
 241         self.connect(self.connectingThread, SIGNAL("createWindowManager"), self._createWindowManager)
 242         self.connectingThread.start()
 243
 244         self.connectionProgress()
 245         self.connect(self.connectingThread, SIGNAL("connectionDone"), self.updateDeviceInformation)
 246
 247     def updateDeviceInformation(self, deviceInfo):
 248         self._progressDialog.cancel()
 249         self.deviceInfo = deviceInfo
 250         self.deviceManager.setCurrentDevice(self._ip)
 251         if self.deviceInfo:
 252             self.deviceManager.loadDevices()
 253             self.deviceWidget.setDeviceInfo(self.deviceInfo)
 254             self.deviceInfoViewer.setDeviceInfo(self.deviceInfo)
 255         else:
 256             showMessageBox("An error occurred while connect.", "Connection error")
 257
 258     def _updateIpList(self):
 259         self.model.clear()
 260         devices = self.deviceManager.getDevices()
 261         for device in devices:
 262             self.model.appendRow(QStandardItem(str(device)))
 263
 264     def connectionProgress(self):
 265         self.connectDialog.setVisible(False)
 266         self._progressDialog = QProgressDialog("Connecting...",
 267                                                QString(), 0, -1, self,
 268                                                Qt.FramelessWindowHint)
 269         self._progressDialog.setObjectName("progressDialog")
 270         self._progressDialog.setWindowIcon(QIcon(BACKUP_IMAGE))
 271         self._progressDialog.setValue(0)
 272         self._progressDialog.show()
 273
 274     def _connectException(self):
 275         showMessageBox("", "Error while connect to device")
 276
 277
 278 class connectingThread(QThread):
 279     def __init__(self, deviceManager, deviceIp):
 280         QThread.__init__(self)
 281         self.deviceManager = deviceManager
 282         self.deviceIp = deviceIp
 283
 284     def run(self):
 285         try:
 286             deviceInf = self.deviceManager._addDevice(self.deviceIp)
 287             self.emit(SIGNAL("createWindowManager"), deviceInf)
 288             self.emit(SIGNAL("connectionDone"), deviceInf)
 289         except:
 290             self.emit(SIGNAL("connectException"))
 291             self.emit(SIGNAL("connectionDone"), None)
 292