예제 #1
0
    def _refresh(self):
        'Refresh the list of Computers'
        self._btnRefresh.setEnabled(False)
        self._btnRefresh.setText('Scanning...')
        self._model.clear()
        
        typ = self.wizard().field('type')
        if typ == len(ComputerTypes):
            # Custom Computer Type
            didx = self.wizard().field('driver')
            drvr = list_drivers().keys()[didx]
            dopt = self.wizard().field('driveropt')
        else:
            # Predefined Computer Type
            drvr = ComputerTypes[typ]['driver']
            dopt = ComputerTypes[typ]['driveropt']
        
        dclass = list_drivers()[drvr]['class']
        doptions = [] if dopt == '' else dopt.split(':')
        
        thread = QThread(self)
        
        #FIXME: ZOMG HAX: Garbage Collector will eat DiscoveryWorker when moveToThread is called
        #NOTE: Qt.QueuedConnection is important...
        self.worker = None
        self.worker = DiscoveryWorker(dclass, doptions)
        self.worker.moveToThread(thread)
        thread.started.connect(self.worker.start, Qt.QueuedConnection)
        self.worker.foundDevice.connect(self._model.addItem, Qt.QueuedConnection)
        self.worker.finished.connect(self._discoverFinished, Qt.QueuedConnection)
        self.worker.finished.connect(self.worker.deleteLater, Qt.QueuedConnection)
        self.worker.finished.connect(thread.deleteLater, Qt.QueuedConnection)

        thread.start()
예제 #2
0
    def RunWizard(cls, parent=None):
        'Run the Add Dive Computer Wizard and return a DiveComputer object'
        wiz = cls(parent)
        if wiz.exec_() == QDialog.Rejected:
            return None

        # Handle Wizard Fields
        typ = wiz.field('type')
        if typ == len(ComputerTypes):
            # Custom Computer Type
            didx = wiz.field('driver')
            pidx = wiz.field('parser')
            drvr = list_drivers().keys()[didx]
            prsr = list_parsers().keys()[pidx]
            dopt = wiz.field('driveropt')
            popt = wiz.field('parseropt')
        else:
            # Predefined Computer Type
            drvr = ComputerTypes[typ]['driver']
            prsr = ComputerTypes[typ]['parser']
            dopt = ComputerTypes[typ]['driveropt']
            popt = ComputerTypes[typ]['parseropt']
        
        serno = wiz.field('serial')
        name = wiz.field('name')
        
        # Create the DiveComputer model
        dc = models.DiveComputer()
        dc.driver = drvr
        dc.serial = serno
        dc.name = name
        dc.parser = prsr
        dc.driver_args = dopt
        dc.parser_args = popt
        
        return dc
예제 #3
0
 def start(self):
     'Run the Transfer'
     self.status.emit(self.tr('Starting Transfer from %s') % self._dc.name)
     time.sleep(0.1)
     
     # Load the Driver
     try:
         d = list_drivers()[self._dc.driver]
         da = self._dc.driver_args
         dopts = [] if da is None or da == '' else da.split(':')
         driver = d['class'](*dopts)
         self.status.emit(self.tr('Loaded Driver "%s"') % self._dc.driver)
     except:
         self.status.emit(self.tr('Error: Cannot load driver "%s"') % self._dc.driver)
     
     # Load the Parser and Adapter Class
     try:
         p = list_parsers()[self._dc.parser]
         pa = self._dc.parser_args
         popts = [] if pa is None or pa == '' else pa.split(':')
         parser = p['class'](*popts)
         adapter_cls = p['adapter']
         self.status.emit(self.tr('Loaded Parser "%s"') % self._dc.parser)
     except:
         self.status.emit(self.tr('Error: Cannot load parser "%s"') % self._dc.parser)
     
     # Connect and check Serial Number
     self.status.emit('Connecting to %s' % self._dc.name)
     
     #FIXME: driver.discover() blocks main thread
     time.sleep(0.1)
     devs = driver.discover()
     
     drv = None
     for _dev in devs:
         time.sleep(0.1)
         try:
             _drv = d['class'](*dopts)
             _drv.connect(_dev)
             if _drv.serial == self._dc.serial:
                 drv = _drv
                 break
             else:
                 _drv.disconnect()
         except:
             self.status.emit('Error: Could not connect to %s (Driver Error)' % self._dc.name)
             self.finished.emit()
             return
     
     if drv == None:
         self.status.emit('Error: Could not connect to %s (Device Not Found)' % self._dc.name)
         
     time.sleep(0.1)
     
     # Transfer Dives
     drv.set_token(self._dc.token)
     nbytes = drv.get_bytecount()
     self.status.emit('Transferring %d bytes...' % nbytes)
     self.started.emit(nbytes)
     _dives = drv.transfer(TransferWorker.Reporter(self))
     token = drv.issue_token()
     self.status.emit('Transfer Finished (%d new dives)' % len(_dives))
     drv.disconnect()
     
     # Parse Dive Data
     for _dive in _dives:
         dive = models.Dive()
         dive.init_from_adapter(adapter_cls(parser.parse(_dive)))
         dive.computer = self._dc
         self.status.emit(self.tr('Parsed Dive: %s') % dive.dive_datetime.strftime('%x %X'))
         self.parsedDive.emit(dive)
     
     # Update Dive Computer Token
     self._dc.token = token
     
     # Finished Transferring
     self.status.emit(self.tr('Transfer Successful'))
     self.finished.emit()
예제 #4
0
 def __init__(self):
     super(DriverModel, self).__init__()
     self._drivers = list_drivers()