ui4/wifisetupdialog.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # (c) Copyright 2001-2009 Hewlett-Packard Development Company, L.P.
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # Authors: Don Welch
  20 #
  21
  22 # StdLib
  23 import operator
  24
  25 # Local
  26 from base.g import *
  27 from base import device, utils, models, wifi, LedmWifi
  28 from base.codes import *
  29 from ui_utils import *
  30
  31 # Qt
  32 from PyQt4.QtCore import *
  33 from PyQt4.QtGui import *
  34
  35 # Ui
  36 from wifisetupdialog_base import Ui_Dialog
  37
  38
  39
  40 PAGE_INTRO = 0 # Ask user to plugin temp USB connection
  41 PAGE_DEVICES = 1 # Select a probed USB device
  42 PAGE_NETWORK = 2 # Select a discovered SSID
  43 PAGE_CONFIGURE_WIFI = 3 # Configure USB device on network
  44 PAGE_EXIT = 4 #  Tell user if successful, unplug USB onnection
  45
  46
  47 BUTTON_NEXT = 0
  48 BUTTON_FINISH = 1
  49 BUTTON_CONNECT = 3
  50
  51 SUCCESS_NOT_CONNECTED = 0
  52 SUCCESS_AUTO_IP = 1
  53 SUCCESS_CONNECTED = 2
  54
  55 ASSOCIATE_DELAY = 30
  56 REFRESH_INTERVAL = 20
  57
  58
  59 class DeviceTableWidgetItem(QTableWidgetItem):
  60     def __init__(self, text, device_uri):
  61         QTableWidgetItem.__init__(self, text, QTableWidgetItem.UserType)
  62         self.device_uri = device_uri
  63
  64
  65 class WifiSetupDialog(QDialog, Ui_Dialog):
  66     def __init__(self, parent, device_uri=None, standalone=True):
  67         QDialog.__init__(self, parent)
  68         self.setupUi(self)
  69
  70         self.device_uri = device_uri
  71         self.devices = {}
  72         self.networks = {}
  73         self.ssid = ''
  74         self.directed = False
  75         self.show_extended = False
  76         self.bus = 'usb'
  77         self.search = ''
  78         self.max_page = PAGE_EXIT
  79         self.location_cache = {} # { 'bssid' : <location>, ... }
  80         self.dev = None
  81         self.success = SUCCESS_NOT_CONNECTED
  82         self.ip = '0.0.0.0'
  83         self.hn = ''
  84         self.standalone = standalone
  85         self.initUi()
  86         self.adapterName = 'Wifi0'
  87         self.wifiObj = wifi
  88
  89         #if self.device_uri is None:
  90         #    QTimer.singleShot(0, self.showIntroPage)
  91         #else:
  92         #    QTimer.singleShot(0, self.showNetworkPage)
  93
  94         QTimer.singleShot(0, self.showIntroPage)
  95
  96
  97     #
  98     # INIT
  99     #
 100
 101     def initUi(self):
 102         self.setWindowIcon(QIcon(load_pixmap('hp_logo', '128x128')))
 103
 104         # connect signals/slots
 105         self.connect(self.CancelButton, SIGNAL("clicked()"), self.CancelButton_clicked)
 106         self.connect(self.BackButton, SIGNAL("clicked()"), self.BackButton_clicked)
 107         self.connect(self.NextButton, SIGNAL("clicked()"), self.NextButton_clicked)
 108
 109         self.initIntroPage()
 110         self.initDevicesPage()
 111         self.initNetworkPage()
 112         self.initConfigWifiPage()
 113         self.initExitPage()
 114
 115     #
 116     # INTRO PAGE
 117     #
 118
 119     def initIntroPage(self):
 120         self.Picture.setPixmap(load_pixmap("usb_connection", "other"))
 121         self.InfoIcon.setPixmap(load_pixmap("info", "16x16"))
 122
 123         if self.standalone:
 124             self.MainTitleLabel.setText(self.__tr("""This utility allows you configure your wireless capable printer using a temporary USB connection. You will be prompted to disconnect the USB cable once wireless network setup is complete.
 125
 126 <p><i>Note: This configuration utility does not setup (install) your printer on this computer. Use hp-setup to setup your printer after it has been configured on the network by this utility.</i></p>
 127 <p><i>Note: Only select wireless capable printers are supported by this utility.</i></p>"""))
 128         else:
 129             self.MainTitleLabel.setText(self.__tr("""This utility allows you configure your wireless capable printer using a temporary USB connection. You will be prompted to disconnect the USB cable once wireless network setup is complete.
 130
 131 <p><i>Note: Printer setup (installation) will continue after your printer is configured on the network.</i></p>
 132 <p><i>Note: Only select wireless capable printers are supported by this utility.</i></p>"""))
 133
 134
 135     def showIntroPage(self):
 136         self.BackButton.setEnabled(False)
 137         self.NextButton.setEnabled(True)
 138
 139         self.displayPage(PAGE_INTRO)
 140
 141
 142     #
 143     # DEVICES PAGE
 144     #
 145
 146     def initDevicesPage(self):
 147         self.connect(self.RefreshButton,  SIGNAL("clicked()"),  self.RefreshButton_clicked)
 148
 149
 150     def showDevicesPage(self):
 151         self.BackButton.setEnabled(True)
 152         self.setNextButton(BUTTON_NEXT)
 153
 154         beginWaitCursor()
 155         try:
 156             if not self.devices:
 157                 log.info("Searching on USB bus...")
 158                 filter_dict = {'wifi-config' : (operator.gt, WIFI_CONFIG_NONE)}
 159
 160                 self.devices = device.probeDevices([self.bus], 0, 0, filter_dict, self.search)
 161         finally:
 162             endWaitCursor()
 163
 164         self.clearDevicesTable()
 165
 166         if self.devices:
 167             self.NextButton.setEnabled(True)
 168             self.DevicesFoundIcon.setPixmap(load_pixmap('info', '16x16'))
 169
 170             if len(self.devices) == 1:
 171                 self.DevicesFoundLabel.setText(self.__tr("<b>1 wireless capable device found.</b> Click <i>Next</i> to continue."))
 172             else:
 173                 self.DevicesFoundLabel.setText(self.__tr("<b>%1 wireless capable devices found.</b> Select the device to install and click <i>Next</i> to continue.").arg(len(self.devices)))
 174
 175             self.loadDevicesTable()
 176
 177         else:
 178             self.NextButton.setEnabled(False)
 179             self.DevicesFoundIcon.setPixmap(load_pixmap('error', '16x16'))
 180             log.error("No devices found on bus: %s" % self.bus)
 181             self.DevicesFoundLabel.setText(self.__tr("<b>No wireless capable devices found.</b><br>Plug in your printer with a USB cable and click <i>Refresh</i> to search again."))
 182
 183         self.displayPage(PAGE_DEVICES)
 184
 185
 186     def loadDevicesTable(self):
 187         self.DevicesTableWidget.setSortingEnabled(False)
 188         self.DevicesTableWidget.setRowCount(len(self.devices))
 189
 190         headers = [self.__tr('Model'), self.__tr('Device URI')]
 191         device_uri_col = 1
 192
 193         self.DevicesTableWidget.setColumnCount(len(headers))
 194         self.DevicesTableWidget.setHorizontalHeaderLabels(headers)
 195         flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled
 196
 197         for row, d in enumerate(self.devices):
 198             back_end, is_hp, bus, model, serial, dev_file, host, zc, port = device.parseDeviceURI(d)
 199             model_ui = models.normalizeModelUIName(model)
 200
 201             i = DeviceTableWidgetItem(QString(model_ui), d)
 202             i.setFlags(flags)
 203             self.DevicesTableWidget.setItem(row, 0, i)
 204
 205             i = QTableWidgetItem(QString(d))
 206             i.setFlags(flags)
 207             self.DevicesTableWidget.setItem(row, device_uri_col, i)
 208
 209         self.DevicesTableWidget.resizeColumnsToContents()
 210         self.DevicesTableWidget.setSortingEnabled(True)
 211         self.DevicesTableWidget.sortItems(0)
 212         self.DevicesTableWidget.selectRow(0)
 213
 214
 215     def clearDevicesTable(self):
 216         self.DevicesTableWidget.clear()
 217         self.DevicesTableWidget.setRowCount(0)
 218         self.DevicesTableWidget.setColumnCount(0)
 219
 220
 221     def RefreshButton_clicked(self):
 222         self.clearDevicesTable()
 223         self.devices = []
 224         QTimer.singleShot(0, self.showDevicesPage)
 225
 226
 227     #
 228     # NETWORK
 229     #
 230
 231     def initNetworkPage(self):
 232         self.NetworksTableWidget.setIconSize(QSize(34, 20))
 233         self.ShowExtendedCheckBox.setChecked(False)
 234         self.connect(self.ShowExtendedCheckBox, SIGNAL("clicked(bool)"), self.ShowExtendedCheckBox_clicked)
 235         self.connect(self.SearchPushButton, SIGNAL("clicked()"), self.SearchPushButton_clicked)
 236         self.connect(self.UndirectedRadioButton, SIGNAL("clicked(bool)"), self.UndirectedRadioButton_clicked)
 237         self.connect(self.DirectedRadioButton, SIGNAL("clicked(bool)"), self.DirectedRadioButton_clicked)
 238         self.connect(self.NetworksTableWidget, SIGNAL("itemSelectionChanged()"), self.NetworksTableWidget_itemSelectionChanged)
 239
 240
 241     def showNetworkPage(self):
 242         if self.dev is None:
 243             try:
 244                 self.dev = device.Device(self.device_uri)
 245             except Error, e:
 246                 FailureUI(self, self.__tr("<b>Error opening device:</b><p>%1</p><p>(%2)</p>").arg(self.device_uri).arg(QString(e[0])))
 247
 248                 if self.dev is not None:
 249                     self.dev.close()
 250
 251                 self.close()
 252                 return
 253
 254         self.networks.clear()
 255         self.num_networks = 0
 256
 257         try:
 258             self.adaptor_id, self.adapterName, state, presence = self.wifiObj.getWifiAdaptorID(self.dev)
 259         except Error, e:
 260             self.showIOError(e)
 261             return
 262
 263         log.debug("Adaptor ID: %s" % self.adaptor_id)
 264         log.debug("Adaptor name: %s" % self.adapterName)
 265         log.debug("Adaptor state: %s" % state)
 266         log.debug("Adaptor presence: %s" % presence)
 267
 268         if self.adaptor_id == -1:
 269             FailureUI(self, self.__tr("<b>Unable to locate wireless hardware on device.</b>"))
 270             if self.dev is not None:
 271                 self.dev.close()
 272
 273             self.close()
 274
 275         log.debug("Turning on wireless radio...")
 276         try:
 277             self.wifiObj.setAdaptorPower(self.dev, self.adapterName, self.adaptor_id)
 278         except Error, e:
 279             self.showIOError(e)
 280             return
 281
 282         self.performScan()
 283         self.setNextButton(BUTTON_NEXT)
 284         self.displayPage(PAGE_NETWORK)
 285
 286
 287     def performScan(self):
 288         beginWaitCursor()
 289         error = False
 290         try:
 291             self.ssid = unicode(self.SSIDLineEdit.text())
 292             if self.directed and self.ssid:
 293                 try:
 294                     self.networks = self.wifiObj.performScan(self.dev, self.adapterName, self.ssid)
 295                 except Error, e:
 296                     self.showIOError(e)
 297                     return
 298             else:
 299                 try:
 300                     self.networks = self.wifiObj.performScan(self.dev, self.adapterName)
 301                 except Error, e:
 302                     self.showIOError(e)
 303                     return
 304         finally:
 305             self.dev.close()
 306             endWaitCursor()
 307
 308         self.num_networks = self.networks['numberofscanentries']
 309         self.clearNetworksTable()
 310
 311         if self.num_networks:
 312             self.NextButton.setEnabled(True)
 313             self.NetworksFoundIcon.setPixmap(load_pixmap('info', '16x16'))
 314
 315             if self.num_networks == 1:
 316                 self.NetworksFoundLabel.setText(self.__tr("<b>1 wireless network found. </b> If the wireless network you would like to connect to is not listed, try entering a wireless network name and/or press <i>Search</i> to search again."))
 317             else:
 318                 self.NetworksFoundLabel.setText(self.__tr("<b>%1 wireless networks found.</b> If the wireless network you would like to connect to is not listed, try entering a wireless network name and/or press <i>Search</i> to search again.").arg(self.num_networks))
 319
 320             self.loadNetworksTable()
 321
 322         else:
 323             self.NextButton.setEnabled(False)
 324             self.NetworksFoundIcon.setPixmap(load_pixmap('error', '16x16'))
 325             log.warning("No wireless networks found.")
 326             self.NetworksFoundLabel.setText(self.__tr("<b>No wireless networks found.</b><br>Enter a wireless network name and/or press <i>Search</i> to search again."))
 327
 328
 329     def ShowExtendedCheckBox_clicked(self, b):
 330         self.show_extended = b
 331         self.loadNetworksTable()
 332
 333
 334     def SearchPushButton_clicked(self):
 335         self.performScan()
 336         self.loadNetworksTable()
 337
 338
 339     def UndirectedRadioButton_clicked(self, b):
 340         self.directed = not b
 341         self.SSIDLineEdit.setEnabled(not b)
 342
 343
 344     def DirectedRadioButton_clicked(self, b):
 345         self.directed = b
 346         self.SSIDLineEdit.setEnabled(b)
 347
 348
 349     def loadNetworksTable(self):
 350         self.n, self.network = 0, u''
 351         if self.num_networks:
 352             beginWaitCursor()
 353             try:
 354                 if self.show_extended:
 355                     for n in xrange(self.num_networks):
 356                         bssid = self.networks['bssid-%d' % n]
 357                         ss = self.networks['signalstrength-%d' % n]
 358                         try:
 359                             self.location_cache[bssid]
 360                         except KeyError:
 361                             location = wifi.getLocation(bssid, ss)
 362                             lat = self.networks['latitude-%d' % n] = location.get('latitude', 'Unknown')
 363                             lng  = self.networks['longitude-%d' % n] = location.get('longitude', 'Unknown')
 364                             address = self.networks['address-%d' % n] = location.get('address', 'Unknown')
 365                             self.location_cache[bssid] = (lat, lng, address)
 366                         else:
 367                             self.networks['latitude-%d' % n], self.networks['longitude-%d' % n], self.networks['address-%d' % n] = \
 368                                 self.location_cache[bssid]
 369
 370                 self.NetworksTableWidget.setSortingEnabled(False)
 371                 self.NetworksTableWidget.setRowCount(self.num_networks)
 372
 373                 headers = [self.__tr('Network Name (SSID)'), self.__tr('Signal Strength'),
 374                             self.__tr("Security"), self.__tr("Mode")]
 375
 376                 if self.show_extended:
 377                     headers.extend([self.__tr('Channel'),
 378                             self.__tr("Address (BSSID)"), self.__tr("Location"),
 379                             self.__tr("Lat/Long")])
 380
 381                 self.NetworksTableWidget.setColumnCount(len(headers))
 382                 self.NetworksTableWidget.setHorizontalHeaderLabels(headers)
 383                 enabled_flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled
 384
 385                 for n in xrange(self.num_networks):
 386                     name = self.networks['ssid-%d' % n]
 387
 388                     if name == '(unknown)':
 389                         flags = None
 390                     else:
 391                         flags = enabled_flags
 392
 393                     ss = self.networks['signalstrength-%d' % n]
 394                     sec = self.networks['encryptiontype-%d' % n]
 395                     mode = self.networks['communicationmode-%d' % n]
 396
 397                     log.debug("%d: Name=%s, strength=%s, security=%s, mode=%s" % #, channel=%d bssid=%s" %
 398                         (n, name, ss, sec, mode))
 399
 400                     if self.show_extended:
 401                         chn = self.networks['channel-%d' % n]
 402                         dbm = self.networks['dbm-%d' % n]
 403                         bssid = self.networks['bssid-%d' % n]
 404                         address = self.networks['address-%d' % n]
 405                         lat = self.networks['latitude-%d' % n]
 406                         lng = self.networks['longitude-%d' % n]
 407
 408                         log.debug("%d: channel=%d bssid=%s dbm=%s lat=%s long=%s address=%s" %
 409                             (n, chn, bssid, dbm, lat, lng, address))
 410
 411                     i = QTableWidgetItem(QString(name))
 412                     if flags is not None: i.setFlags(flags)
 413                     i.setData(Qt.UserRole, QVariant(n))
 414                     self.NetworksTableWidget.setItem(n, 0, i)
 415
 416                     pixmap = load_pixmap('signal%d' % ss, 'other')
 417                     if self.show_extended:
 418                         i = QTableWidgetItem(QIcon(pixmap), self.__tr("%1/5 (%2 dBm)").arg(ss).arg(dbm))
 419                     else:
 420                         i = QTableWidgetItem(QIcon(pixmap), self.__tr("%1/5").arg(ss))
 421                     if flags is not None: i.setFlags(flags)
 422                     self.NetworksTableWidget.setItem(n, 1, i)
 423
 424                     i = QTableWidgetItem(QString(sec))
 425                     if flags is not None: i.setFlags(flags)
 426                     self.NetworksTableWidget.setItem(n, 2, i)
 427
 428                     i = QTableWidgetItem(QString(mode))
 429                     if flags is not None: i.setFlags(flags)
 430                     self.NetworksTableWidget.setItem(n, 3, i)
 431
 432                     if self.show_extended:
 433                         i = QTableWidgetItem(QString(str(chn)))
 434                         if flags is not None: i.setFlags(flags)
 435                         self.NetworksTableWidget.setItem(n, 4, i)
 436
 437                         i = QTableWidgetItem(QString(bssid))
 438                         if flags is not None: i.setFlags(flags)
 439                         self.NetworksTableWidget.setItem(n, 5, i)
 440
 441                         i = QTableWidgetItem(QString(address))
 442                         if flags is not None: i.setFlags(flags)
 443                         self.NetworksTableWidget.setItem(n, 6, i)
 444
 445                         i = QTableWidgetItem(QString("%1/%2").arg(lat).arg(lng))
 446                         if flags is not None: i.setFlags(flags)
 447                         self.NetworksTableWidget.setItem(n, 7, i)
 448
 449
 450                 self.NetworksTableWidget.resizeColumnsToContents()
 451                 self.NetworksTableWidget.setSortingEnabled(True)
 452                 self.NetworksTableWidget.sortItems(1, Qt.DescendingOrder)
 453                 self.NetworksTableWidget.selectRow(0)
 454                 self.NetworksTableWidget.emit(SIGNAL("itemSelectionChanged()"))
 455
 456             finally:
 457                 endWaitCursor()
 458                 self.NextButton.setEnabled(True)
 459
 460         else:
 461             self.NextButton.setEnabled(False)
 462
 463
 464     def NetworksTableWidget_itemSelectionChanged(self):
 465         row = self.NetworksTableWidget.currentRow()
 466         item = self.NetworksTableWidget.item(row, 0)
 467         n, ok = item.data(Qt.UserRole).toInt()
 468         if ok:
 469             sec = self.networks['encryptiontype-%d' % n]
 470             if sec.lower() == 'none':
 471                 self.setNextButton(BUTTON_CONNECT)
 472             else:
 473                 self.setNextButton(BUTTON_NEXT)
 474
 475
 476     def clearNetworksTable(self):
 477         self.DevicesTableWidget.clear()
 478         self.DevicesTableWidget.setRowCount(0)
 479         self.DevicesTableWidget.setColumnCount(0)
 480
 481
 482     def RefreshButton2_clicked(self):
 483         self.clearNetworksTable()
 484         self.networks = {}
 485         QTimer.singleShot(0, self.showNetworkPage)
 486
 487
 488     #
 489     # CONFIGURE WIFI
 490     #
 491
 492     def initConfigWifiPage(self):
 493         self.connect(self.ShowKeyCheckBox, SIGNAL("toggled(bool)"), self.ShowKeyCheckBox_toggled)
 494
 495
 496     def showConfigWifiPage(self):
 497         self.setNextButton(BUTTON_CONNECT)
 498         self.SSIDLabel.setText(self.network)
 499         font = QFont()
 500         font.setPointSize(12)
 501         self.SSIDLabel.setFont(font)
 502         self.KeyLineEdit.setText(QString())
 503         self.ShowKeyCheckBox.setChecked(False)
 504         self.StrengthIcon.setPixmap(load_pixmap('signal%d' % self.ss, 'other'))
 505         self.ConfigureIcon.setPixmap(load_pixmap('info', '16x16'))
 506         self.KeysIcon.setPixmap(load_pixmap('keys', '32x32'))
 507
 508         if 'wpa' in self.security.lower():
 509             self.WPARadioButton.setChecked(True)
 510
 511         elif 'wep' in self.security.lower():
 512             self.WEPRadioButton.setChecked(True)
 513
 514         self.KeyLineEdit.setFocus()
 515         self.KeyLineEdit.setEchoMode(QLineEdit.Password)
 516         self.displayPage(PAGE_CONFIGURE_WIFI)
 517
 518
 519     def ShowKeyCheckBox_toggled(self, b):
 520         if b:
 521             self.KeyLineEdit.setEchoMode(QLineEdit.Normal)
 522         else:
 523             self.KeyLineEdit.setEchoMode(QLineEdit.Password)
 524
 525
 526     #
 527     # EXIT/CONNECT PAGE
 528     #
 529
 530     def initExitPage(self):
 531         self.connect(self.PageSpinBox, SIGNAL("valueChanged(int)"), self.PageSpinBox_valueChanged)
 532         self.RefreshTimer = QTimer(self)
 533         self.connect(self.RefreshTimer, SIGNAL('timeout()'), self.RefreshTimer_timeout)
 534         self.pages = []
 535         self.page_index = 0
 536         self.PageSpinBox.setMinimum(1)
 537
 538
 539     def showExitPage(self):
 540         self.setNextButton(BUTTON_FINISH)
 541         self.NextButton.setEnabled(False)
 542         self.CancelButton.setEnabled(True)
 543         self.SSIDLabel_2.setText(QString(self.network))
 544         self.ip = '0.0.0.0'
 545         self.hn = ''
 546         self.success = SUCCESS_NOT_CONNECTED
 547
 548         beginWaitCursor()
 549         try:
 550             try:
 551                 self.ip,_,addressmode, subnetmask, gateway, pridns, sec_dns= self.wifiObj.getIPConfiguration(self.dev, self.adapterName)
 552                 vsa_codes = self.wifiObj.getVSACodes(self.dev, self.adapterName)
 553                 ss_max, ss_min, ss_val, ss_dbm = self.wifiObj.getSignalStrength(self.dev, self.adapterName,self.network, self.adaptor_id)
 554                 self.hn = self.wifiObj.getHostname(self.dev)
 555             except Error, e:
 556                 self.showIOError(e)
 557                 return
 558         finally:
 559             self.dev.close()
 560             endWaitCursor()
 561
 562         if addressmode.lower() == 'dhcp':
 563             self.success = SUCCESS_CONNECTED
 564
 565         elif addressmode.lower() == 'autoip':
 566             self.success = SUCCESS_AUTO_IP
 567
 568         if self.ip == '0.0.0.0':
 569             self.success = SUCCESS_NOT_CONNECTED
 570
 571         self.pages = []
 572
 573         if self.success == SUCCESS_NOT_CONNECTED:
 574             self.pages.append((self.__tr("<b>Your printer has not been connected to the wireless network.</b> A valid connection to a wireless network can take up to 2 minutes. This screen will automatically refresh every %1 seconds.<p>If your printer fails to connect within a reasonable time, there may be a problem with your configuration.").arg(REFRESH_INTERVAL), load_pixmap('error', '16x16')))
 575             self.RefreshTimer.start(REFRESH_INTERVAL * 1000)
 576
 577         elif self.success == SUCCESS_AUTO_IP:
 578             self.pages.append((self.__tr("Your printer has been connected to the wireless network, but it has been assigned an address which may not be usable."), load_pixmap('warning', '16x16')))
 579             self.RefreshTimer.start(REFRESH_INTERVAL * 1000)
 580
 581         else: # SUCCESS_CONNECTED
 582             if self.standalone:
 583                 self.pages.append((self.__tr("Your printer has been successfully configured on the wireless network. You may now unplug the USB cable. To setup the printer, now run <pre>hp-setup.</pre>"), load_pixmap('info', '16x16')))
 584             else:
 585                 self.pages.append((self.__tr("Your printer has been successfully configured on the wireless network. You may now unplug the USB cable."), load_pixmap('info', '16x16')))
 586             self.CancelButton.setEnabled(False)
 587             self.BackButton.setEnabled(False)
 588             self.RefreshTimer.stop()
 589
 590         if addressmode is None:
 591             self.AddressModeLabel.setText(self.__tr("Unknown"))
 592         else:
 593             self.AddressModeLabel.setText(QString(addressmode))
 594
 595         if self.hn is None:
 596             self.HostnameLabel.setText(self.__tr("Unknown"))
 597         else:
 598             self.HostnameLabel.setText(QString(self.hn))
 599
 600         self.IPAddressLabel.setText(QString(self.ip))
 601         self.GatewayLabel.setText(QString(gateway))
 602         self.DNSLabel.setText(QString(pridns))
 603         self.NextButton.setEnabled(True)
 604
 605         self.SignalStrengthLabel.setText(QString("%1/%2 (%3 dBm)").arg(ss_val).arg(ss_max).arg(ss_dbm))
 606         self.SignalStrengthIcon.setPixmap(load_pixmap('signal%d' % ss_val, 'other'))
 607
 608         for c, s in vsa_codes:
 609             ss = s.lower()
 610             if ss.startswith("info"):
 611                 pixmap = load_pixmap('info', '16x16')
 612
 613             elif ss.startswith("warn"):
 614                 pixmap = load_pixmap('warning', '16x16')
 615
 616             elif ss.startswith("crit"):
 617                 pixmap = load_pixmap('error', '16x16')
 618
 619             else:
 620                 pixmap = load_pixmap('info', '16x16')
 621
 622             self.pages.append((device.queryString("vsa_%s" % str(c).zfill(3)), pixmap))
 623
 624         num_pages = len(self.pages)
 625         self.PageSpinBox.setMaximum(num_pages)
 626         self.PageSpinBox.setEnabled(num_pages>1)
 627         self.PageSpinBox.setValue(1)
 628         self.PageLabel.setEnabled(num_pages>1)
 629         self.PageLabel2.setEnabled(num_pages>1)
 630         self.PageLabel.setText(self.__tr("of %1").arg(num_pages))
 631         self.page_index = 0
 632         self.ExitLabel.setText(self.pages[self.page_index][0])
 633         self.ExitIcon.setPixmap(self.pages[self.page_index][1])
 634         self.displayPage(PAGE_EXIT)
 635
 636
 637     def PageSpinBox_valueChanged(self, i):
 638         self.page_index = i-1
 639         self.ExitLabel.setText(self.pages[self.page_index][0])
 640         self.ExitIcon.setPixmap(self.pages[self.page_index][1])
 641
 642
 643     def RefreshTimer_timeout(self):
 644         self.showExitPage()
 645
 646
 647     #
 648     # ASSOCIATE
 649     #
 650
 651     def associate(self, key=u''):
 652         beginWaitCursor()
 653         try:
 654             try:
 655                 alg, mode, secretid = self.wifiObj.getCryptoSuite(self.dev, self.adapterName)
 656             except Error, e:
 657                 self.showIOError(e)
 658                 return
 659
 660             log.debug("Crypto algorithm: %s" % alg)
 661             log.debug("Crypto mode: %s" % mode)
 662         finally:
 663             endWaitCursor()
 664
 665         beginWaitCursor()
 666         try:
 667             try:
 668                 ret = self.wifiObj.associate(self.dev, self.adapterName, self.network, self.mode, self.security, key)
 669             except Error, e:
 670                 self.showIOError(e)
 671                 return
 672         finally:
 673             endWaitCursor()
 674
 675
 676     #
 677     # Misc
 678     #
 679
 680     def NextButton_clicked(self):
 681         p = self.StackedWidget.currentIndex()
 682         if p == PAGE_INTRO:
 683             self.showDevicesPage()
 684
 685         elif p == PAGE_DEVICES:
 686             row = self.DevicesTableWidget.currentRow()
 687             if row != -1:
 688                 self.device_uri = self.DevicesTableWidget.item(row, 0).device_uri
 689                 self.mq = device.queryModelByURI(self.device_uri)
 690
 691                 self.getWifiObject(self.mq['wifi-config'])
 692                 back_end, is_hp, bus, model, serial, dev_file, host, zc, port = device.parseDeviceURI(self.device_uri)
 693                 self.model = models.normalizeModelName(model).lower()
 694
 695             self.showNetworkPage()
 696
 697         elif p == PAGE_NETWORK:
 698             self.security = 'None'
 699             self.mode = 'Infrastructure'
 700             self.ss = 0
 701             row = self.NetworksTableWidget.currentRow()
 702             if row != -1:
 703                 i = self.NetworksTableWidget.item(row, 0)
 704                 if i is not None:
 705                     self.network = unicode(i.text())
 706                     log.debug("Selected network SSID: %s" % self.network)
 707                     self.n, ok = i.data(Qt.UserRole).toInt()
 708                     if ok:
 709                         self.security = self.networks['encryptiontype-%d' % self.n]
 710                         log.debug("Security: %s" % self.security)
 711
 712                         self.mode = self.networks['communicationmode-%d' % self.n]
 713                         log.debug("Mode: %s" % self.mode)
 714
 715                         self.ss = self.networks['signalstrength-%d' % self.n]
 716                         log.debug("Signal strength: %s" % self.ss)
 717
 718             if self.security.lower() != 'none':
 719                 self.showConfigWifiPage()
 720             else:
 721                 # Skip config page if no security to setup
 722                 self.associate()
 723                 self.showAssociateProgressDialog()
 724                 self.showExitPage()
 725
 726         elif p == PAGE_CONFIGURE_WIFI:
 727             key = unicode(self.KeyLineEdit.text())
 728             self.associate(key)
 729             self.showAssociateProgressDialog()
 730             self.showExitPage()
 731
 732         elif p == PAGE_EXIT:
 733             if self.dev is not None:
 734                 self.dev.close()
 735
 736             self.close()
 737
 738         else:
 739             log.error("Invalid page!") # shouldn't happen!
 740
 741
 742     def showAssociateProgressDialog(self):
 743         AssociateProgressDialog = QProgressDialog(self.__tr("Waiting for printer to connect to the wireless network..."), self.__tr("Cancel"), 0, ASSOCIATE_DELAY, self)
 744         AssociateProgressDialog.setWindowTitle(self.__tr("HP Device Manager - Please wait..."))
 745         AssociateProgressDialog.setWindowModality(Qt.WindowModal)
 746         AssociateProgressDialog.setMinimumDuration(0)
 747         AssociateProgressDialog.forceShow()
 748         canceled = False
 749         for x in range(ASSOCIATE_DELAY):
 750             AssociateProgressDialog.setValue(x)
 751             QThread.sleep(1)
 752             qApp.processEvents()
 753
 754             if AssociateProgressDialog.wasCanceled():
 755                 canceled = True
 756                 break
 757
 758         AssociateProgressDialog.setValue(ASSOCIATE_DELAY)
 759         AssociateProgressDialog.close()
 760
 761         if canceled:
 762             if self.dev is not None:
 763                 self.dev.close()
 764
 765             self.close()
 766
 767
 768     def BackButton_clicked(self):
 769         p = self.StackedWidget.currentIndex()
 770         if p == PAGE_DEVICES:
 771             self.devices = {}
 772             self.showIntroPage()
 773
 774         elif p == PAGE_NETWORK:
 775             self.showDevicesPage()
 776
 777         elif p == PAGE_CONFIGURE_WIFI:
 778             self.showNetworkPage()
 779
 780         elif p == PAGE_EXIT:
 781             self.RefreshTimer.stop()
 782             if self.security.lower() != 'none':
 783                 self.showConfigWifiPage()
 784             else:
 785                 self.showNetworkPage()
 786
 787         else:
 788             log.error("Invalid page!") # shouldn't happen!
 789
 790
 791     def CancelButton_clicked(self):
 792         if self.dev is not None:
 793             self.dev.close()
 794
 795         self.close()
 796
 797
 798     def displayPage(self, page):
 799         self.StackedWidget.setCurrentIndex(page)
 800         self.updateStepText(page)
 801
 802
 803     def setNextButton(self, typ=BUTTON_FINISH):
 804         if typ == BUTTON_NEXT:
 805             self.NextButton.setText(self.__tr("Next >"))
 806
 807         elif typ == BUTTON_FINISH:
 808             self.NextButton.setText(self.__tr("Finish"))
 809
 810         elif typ == BUTTON_CONNECT:
 811             self.NextButton.setText(self.__tr("Connect"))
 812
 813
 814     def updateStepText(self, p):
 815         self.StepText.setText(self.__tr("Step %1 of %2").arg(p+1).arg(self.max_page+1))
 816
 817
 818     def showIOError(self, e):
 819         FailureUI(self, self.__tr("<b>An I/O error occurred.</b><p>Please check the USB connection to your printer and try again.</p>(%1)").arg(QString(e[0])))
 820
 821         if self.dev is not None:
 822             self.dev.close()
 823
 824         self.close()
 825
 826
 827     def __tr(self,s,c = None):
 828         return qApp.translate("WifiSetupDialog",s,c)
 829
 830     # The Wifi object here is not actual object, Dynamically relevant modules are selected based on
 831     # wifi-config value in the models file.
 832     def getWifiObject(self,wifiConfVal):
 833         if wifiConfVal == WIFI_CONFIG_LEDM:
 834             self.wifiObj = LedmWifi
 835         else:
 836             self.wifiObj = wifi
 837
 838
 839