Python Worker.moveToThread方法代码示例

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import moveToThread [as 别名]
    def startWorker(self, featureCollection, attributes, pointProvider=None, hexagonProvider=None):
        # create a new worker instance
        worker = Worker(featureCollection, attributes, pointProvider, hexagonProvider)
        

        # configure the QgsMessageBar
        messageBar = self.iface.messageBar().createMessage('Reading IMAER data...', )
        progressBar = QtGui.QProgressBar()
        progressBar.setAlignment(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
        progressBar.setMinimum(0)
        progressBar.setMaximum(100)
        progressBar.setTextVisible(True)
        cancelButton = QtGui.QPushButton()
        cancelButton.setText('Cancel')
        cancelButton.clicked.connect(worker.kill)
        messageBar.layout().addWidget(progressBar)
        messageBar.layout().addWidget(cancelButton)
        self.iface.messageBar().pushWidget(messageBar, self.iface.messageBar().INFO)
        self.messageBar = messageBar
        self.progressBar = progressBar

        # start the worker in a new thread
        thread = QtCore.QThread(self)
        worker.moveToThread(thread)
        worker.finished.connect(self.workerFinished)
        worker.error.connect(self.workerError)
        worker.progress.connect(self.updateProgress)
        thread.started.connect(worker.run)
        thread.start()
        self.thread = thread
        self.worker = worker

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import moveToThread [as 别名]
    def run(self):
        settings = QtCore.QSettings()

        self.plFromName = settings.value("connect_points_plugin/point_layer_from", "")
        self.plToName = settings.value("connect_points_plugin/polygin_layer_to", "")
        self.fIdFromName = settings.value("connect_points_plugin/filed_name_id_from", "")
        self.fLinkName = settings.value("connect_points_plugin/filed_name_link", "")
        self.fIdToName = settings.value("connect_points_plugin/filed_name_id_to", "")
        self.resLayerName = settings.value("connect_points_plugin/result_layer_name", "")

        # QgisPlugin().plPrint("self.pointLayerName: %s" % self.pointLayerName)
        # QgisPlugin().plPrint("self.polygonLayerName: %s" % self.polygonLayerName)
        # QgisPlugin().plPrint("self.fieldName: %s" % self.fieldName)

        if any([v == "" for v in [self.plFromName, self.plToName, self.fIdFromName, self.fLinkName, self.fIdToName]]):
            QgisPlugin().showMessageForUser(
                self.tr(u"Plugin settings are incorrect. Please, check settings!"),
                QgsMessageBar.CRITICAL,
                0
            )
            return

        plFrom_list = QgsMapLayerRegistry.instance().mapLayersByName(self.plFromName)
        if len(plFrom_list) == 0:
            QgisPlugin().showMessageForUser(
                self.tr(u"Layer with name '%s' not found!") % self.plFromName,
                QgsMessageBar.CRITICAL,
                0
            )
            return
        plFrom = plFrom_list[0]

        plTo_list = QgsMapLayerRegistry.instance().mapLayersByName(self.plToName)
        if len(plTo_list) == 0:
            QgisPlugin().showMessageForUser(
                self.tr(u"Layer with name '%s' not found!") % self.plToName,
                QgsMessageBar.CRITICAL,
                0
            )
            return
        plTo = plTo_list[0]

        layers = QgsMapLayerRegistry.instance().mapLayersByName(self.resLayerName)
        if len(layers) == 0:
            if self.resLayerName == "":
                self.resLayerName = "connect_points_result"
            else:
                QgisPlugin().showMessageForUser(
                    self.tr(u"Layer with name '%s' not found!") % self.resLayerName + " " + self.tr("New layer is created!"),
                    QgsMessageBar.WARNING,
                    0
                )
            self.resLayer = QgsVectorLayer(
                u"LineString?crs=%s" % self._iface.mapCanvas().mapSettings().destinationCrs().authid(),
                self.resLayerName,
                u"memory"
            )
        else:
            if layers[0].providerType() == u"ogr":
                self.resLayer = QgsVectorLayer(layers[0].source(), self.resLayerName, u"ogr")
                QgsMapLayerRegistry.instance().removeMapLayers([layers[0].id()])
            elif layers[0].providerType() == u"memory":
                QgsMapLayerRegistry.instance().removeMapLayers([layers[0].id()])
                self.resLayer = QgsVectorLayer(
                    u"LineString?crs=%s" % self._iface.mapCanvas().mapSettings().destinationCrs().authid(),
                    self.resLayerName,
                    u"memory"
                )

        result = self.addFields(self.resLayer)
        if result is False:
            QgisPlugin().showMessageForUser(
                self.tr(u"Layer with name '%s' can not be used for result output!") % self.resLayerName,
                QgsMessageBar.WARNING,
                0
            )
            return

        self.applyResultStyle(self.resLayer)

        progressDlg = QgsBusyIndicatorDialog(self.tr(u"Prepare"))
        progressDlg.setWindowTitle(self.tr(u"Calculation"))
        worker = Worker(plFrom, plTo, self.fIdFromName, self.fLinkName, self.fIdToName, self.resLayer)
        thread = QtCore.QThread(self._iface.mainWindow())

        worker.moveToThread(thread)

        thread.started.connect(worker.run)
        worker.stoped.connect(self.addLayerToProject)
        worker.stoped.connect(thread.quit)
        worker.stoped.connect(worker.deleteLater)
        worker.stoped.connect(thread.deleteLater)
        worker.stoped.connect(progressDlg.close)
        worker.error.connect(self.showError)
        worker.error.connect(progressDlg.close)
        worker.progressChanged.connect(
            lambda x, y: progressDlg.setMessage(
                self.tr(u"Process %d points from %d") % (x, y)
            )
        )
#.........这里部分代码省略.........

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import moveToThread [as 别名]

#.........这里部分代码省略.........
                        self.plot.addItem(self.saveCurves[i])
                        self.saveCurves[i].setData(self.xData, yData)

                    else:
                        self.plot.removeItem(self.saveCurves[i])
                        self.saveCurves[i] = None

                    self.SAVE[i] = False

            if self.WATERFALL:
                self.waterfallUpdate(self.xData, yData)
        #print len(yData)
        self.curve.setData(self.xData, yData)

    def waterfallUpdate(self, xData, yData):
        if self.waterfallImg is None:
            self.waterfallImgArray = np.zeros((self.waterfallHistorySize, len(xData)))
            self.waterfallImg = pg.ImageItem()
            self.waterfallImg.scale((xData[-1] - xData[0]) / len(xData), 1)
            self.waterfallImg.setPos(xData[0],-self.waterfallHistorySize)
            self.waterfallPlot.clear()
            self.waterfallPlot.addItem(self.waterfallImg)
            self.waterfallHistogram.setImageItem(self.waterfallImg)
            self.plot.setXRange(self.startFreq/1e6, self.stopFreq/1e6)

        self.waterfallImgArray = np.roll(self.waterfallImgArray, -1, axis=0)
        self.waterfallImgArray[-1] = yData
        self.waterfallImg.setImage(self.waterfallImgArray.T,
                                   autoLevels=True, autoRange=False)
### SETUP SAMPLER AND WORKER
    def setupSampler(self):
        self.samplerThread = QtCore.QThread(self)
        self.sampler = Sampler(self.gain, self.sampRate, self.freqs, self.numSamples)
        self.sampler.moveToThread(self.samplerThread)
        self.samplerThread.started.connect(self.sampler.sampling)
        self.sampler.samplerError.connect(self.onError)
        self.sampler.dataAcquired.connect(self.worker.work)
        self.samplerThread.start(QtCore.QThread.NormalPriority)

    def setupWorker(self):
        self.workerThread = QtCore.QThread(self)
        self.worker = Worker(self.nfft, self.length, self.sliceLength, self.sampRate, self.nwelch)
        self.worker.moveToThread(self.workerThread)
        self.worker.dataReady.connect(self.plotUpdate)
        self.workerThread.start(QtCore.QThread.NormalPriority)


### GUI FUNCTIONS ###
    def mouseMoved(self, evt):
        pos = evt[0]
        if self.plot.sceneBoundingRect().contains(pos):
            mousePoint = self.plot.getViewBox().mapSceneToView(pos)
            self.posLabel.setText("f=%0.1f MHz, P=%0.1f dBm" % (mousePoint.x(),mousePoint.y()))
            self.vLine.setPos(mousePoint.x())
            self.hLine.setPos(mousePoint.y())
            self.posLabel.setPos(mousePoint.x(), mousePoint.y())

    @pyqtSlot()
    def onStart(self):
        self.ui.startButton.setEnabled(False)
        self.ui.stopButton.setEnabled(True)
        self.ui.statusbar.setVisible(False)
        self.ui.statusbar.clearMessage()
        self.ui.settingsTabs.setEnabled(True)

        self.setupWorker()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import moveToThread [as 别名]
    def run(self):
        settings = QtCore.QSettings()

        self.pointLayerName = settings.value("pointsinpolygons_plugin/point_layer_name", "")
        self.polygonLayerName = settings.value("pointsinpolygons_plugin/polygin_layer_name", "")
        self.fieldName = settings.value("pointsinpolygons_plugin/filed_name", "")

        Plugin().plPrint("self.pointLayerName: %s" % self.pointLayerName)
        Plugin().plPrint("self.polygonLayerName: %s" % self.polygonLayerName)
        Plugin().plPrint("self.fieldName: %s" % self.fieldName)

        if self.pointLayerName == "" or self.polygonLayerName == "" or self.fieldName == "":
            Plugin().showMessageForUser(
                u"Плагин настроен не корректно. Проверте настройки!",
                QgsMessageBar.CRITICAL,
                0
            )
            return

        pointLayers = QgsMapLayerRegistry.instance().mapLayersByName(self.pointLayerName)
        if len(pointLayers) == 0:
            Plugin().showMessageForUser(
                u"Слой с именем '%s' не найден!" % self.pointLayerName,
                QgsMessageBar.CRITICAL,
                0
            )
            return
        pointLayer = pointLayers[0]

        polygonLayers = QgsMapLayerRegistry.instance().mapLayersByName(self.polygonLayerName)
        if len(polygonLayers) == 0:
            Plugin().showMessageForUser(
                u"Слой с именем '%s' не найден!" % self.polygonLayerName,
                QgsMessageBar.CRITICAL,
                0
            )
            return
        polygonLayer = polygonLayers[0]

        if self.fieldName == "":
            Plugin().showMessageForUser(
                u"Значение поля не задано!",
                QgsMessageBar.CRITICAL,
                0
            )
            return

        progressDlg = QgsBusyIndicatorDialog(u"Подготовка")
        progressDlg.setWindowTitle(u"Идёт расчет")
        worker = Worker(pointLayer, polygonLayer, self.fieldName)
        thread = QtCore.QThread(self._iface.mainWindow())

        worker.moveToThread(thread)

        thread.started.connect(worker.run)
        worker.stoped.connect(thread.quit)
        worker.stoped.connect(worker.deleteLater)
        worker.stoped.connect(thread.deleteLater)
        worker.stoped.connect(progressDlg.close)
        # worker.error.connect(self.showError)
        worker.progressChanged.connect(lambda x, y: progressDlg.setMessage(u"Обработано %d полигонов из %d" % (x, y)))
        thread.start()

        self.thread = thread
        self.worker = worker

        progressDlg.exec_()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import moveToThread [as 别名]
class NetDotTsinghuaApplication(QApplication):
    """NetDotTsinghuaApplication"""
    start_worker = pyqtSignal()
    username_changed = pyqtSignal(str)
    update_all = pyqtSignal()

    def __init__(self, argv):
        super().__init__(argv)
        icon = QIcon(":/icon.png")

        self.setQuitOnLastWindowClosed(False)  # Run without windows.
        self.setWindowIcon(icon)
        self.account_setting_dialog = None

        self.worker = Worker()
        self.worker_thread = QThread()
        self.worker.moveToThread(self.worker_thread)

        # For convenience.
        worker = self.worker
        config = worker.config
        acc = worker.account

        # Set up tray menu.
        self.tray = QSystemTrayIcon(icon, self)
        self.tray_menu = QMenu()

        # Status section.
        self.status_action = self.add_unabled_action()
        self.status_changed(worker.account.status)
        self.status = acc.status
        self.last_session = None

        # Account info section.
        self.tray_menu.addSeparator()
        self.username_action = self.add_unabled_action()
        self.usage_action = self.add_unabled_action()
        self.balance_action = self.add_unabled_action()
        self.refresh_username(config['username'])
        self.refresh_account_info(None, None)

        # Sessions section.
        self.sessions = []
        self.session_menus = []
        self.last_check = None

        self.tray_menu.addSeparator()
        self.sessions_title_action = self.add_unabled_action()
        self.last_check_action = self.add_unabled_action()

        self.refresh_sessions([])

        # Actions.
        self.tray_menu.addSeparator()
        self.tray_menu.addAction('上线').triggered.connect(acc.login)
        self.tray_menu.addAction('下线').triggered.connect(acc.logout)
        self.tray_menu.addAction('现在刷新').triggered.connect(acc.update_all)

        # Config section.
        self.tray_menu.addSeparator()
        self.auto_manage_action = self.tray_menu.addAction('自动管理')
        self.auto_manage_action.setCheckable(True)
        self.auto_manage_action.setChecked(config['auto_manage'])
        self.auto_manage_action.toggled.connect(worker.auto_manage_changed)

        self.account_setting_action = self.tray_menu.addAction('账号设置...')
        self.account_setting_action.triggered.connect(self.account_setting)

        # About.
        self.tray_menu.addSeparator()
        self.tray_menu.addAction('关于').triggered.connect(self.show_about)

        # Quit.
        self.tray_menu.addSeparator()
        self.tray_menu.addAction('退出').triggered.connect(self.quit)

        self.tray.setContextMenu(self.tray_menu)
        self.tray.show()

        # Connect signals.
        self.start_worker.connect(worker.setup)
        self.username_changed.connect(self.refresh_username)
        self.username_changed.connect(worker.username_changed)
        self.update_all.connect(acc.update_all)

        acc.status_changed.connect(self.status_changed)
        acc.info_updated.connect(self.refresh_account_info)
        acc.last_session_updated.connect(self.last_session_changed)
        acc.sessions_updated.connect(self.refresh_sessions)

        # About to show.
        self.tray_menu.aboutToShow.connect(self.update_time)
        self.tray_menu.aboutToShow.connect(self.refresh_status)

    def add_unabled_action(self, text=''):
        action = self.tray_menu.addAction(text)
        action.setEnabled(False)
        return action

    def exec(self):
#.........这里部分代码省略.........

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import moveToThread [as 别名]
class Handler(QtGui.QMainWindow):
    
    def __init__(self):
        super(Handler,self).__init__()
        
        self.USERNAME_ENTRY = ""
        self.PASSWORD_ENTRY = ""
    
        # Threading
        QtCore.QThread.currentThread().setObjectName("MAIN")
        self.thread = QtCore.QThread()
        self.thread.name = "auto_refresh"
   
        self.worker = Worker()
        self.worker.moveToThread(self.thread)
        self.worker.start()
        self.worker.refresh_signal.connect(Communicator.update_active_channel)
        self.worker.channel_notification.connect(Communicator.update_selected_channels)
        self.worker.update_online_list.connect(self.online_list)
        self.worker.channels_received.connect(self.generate_channels)
    
        self.com=Ui_hbsCommunicator()
        self.com.setupUi(self)
        self.USERNAME_ENTRY = self.com.usernameEntry
        self.PASSWORD_ENTRY = self.com.passwordEntry
       
        #channels = generate_channels(self.com)
        #channels.button_map.connect(self.channel_clicked)

        self.connect_elements()
        #self.connect_channels()
        #self.generate_channels()

        if os.path.exists('credentials.txt'):
            f = open('credentials.txt', 'r')
            username = f.readline()
            password = f.readline()
            Communicator.REMEMBER_LOGIN = True
            GUI.REMEMBER_LOGIN_CHECK.setChecked(True)            
            GUI.USERNAME_ENTRY.setText(username)
            GUI.PASSWORD_ENTRY.setText(password) 
       
        # Set the application icon
        self.app_icon = QtGui.QIcon()
        self.app_icon.addFile('icons/comms16x16.ico', QtCore.QSize(16,16))
        self.app_icon.addFile('icons/comms24x24.ico', QtCore.QSize(24,24))
        self.app_icon.addFile('icons/comms32x32.ico', QtCore.QSize(32,32))
        self.app_icon.addFile('icons/comms48x48.ico', QtCore.QSize(48,48))
        self.app_icon.addFile('icons/comms256x256.ico', QtCore.QSize(256,256))
        
        self.app_icon.addFile('icons/comms16x16.png', QtCore.QSize(16,16))
        self.app_icon.addFile('icons/comms24x24.png', QtCore.QSize(24,24))
        self.app_icon.addFile('icons/comms32x32.png', QtCore.QSize(32,32))
        self.app_icon.addFile('icons/comms48x48.png', QtCore.QSize(48,48))
        self.app_icon.addFile('icons/comms256x256.png', QtCore.QSize(256,256))

        if os.name=="nt":
            myappid = 'mathomastech.comms.0.10.0'
            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
            self.tray_icon = QtGui.QSystemTrayIcon(self)
            self.tray_icon.setIcon(self.app_icon)
            self.tray_icon.setVisible(True)
            self.tray_icon.show()
     
        self.setWindowIcon(self.app_icon)
        self.show()
   
    def channel_clicked(self,channel,flag):
        Communicator.switch_channel(channel)
    
    def connect_elements(self):
        GUI.CHANNEL_DISPLAY = self.com.channelDisplay
        GUI.CHAT_ENTRY = self.com.chatEntry
        GUI.SUBMIT_BTN = self.com.submitButton
        GUI.ROSTER_DISPLAY = self.com.rosterDisplay
        GUI.LOGIN_STATUS_LABEL = self.com.loginStatusLabel
        GUI.USER_BTN = self.com.userButton
        GUI.REFRESH_BUTTON = self.com.refreshButton        
        GUI.CHANNEL_NOTEBOOK = self.com.channelNotebook
        GUI.CONTENT_NOTEBOOK = self.com.contentNotebook
        GUI.ANNOUNCEMENT_LABEL = self.com.announcementLabel
        GUI.LOGIN_GROUP_BOX = self.com.loginGroupBox
        GUI.USERNAME_ENTRY = self.com.usernameEntry 
        GUI.PASSWORD_ENTRY = self.com.passwordEntry
        GUI.REMEMBER_LOGIN_CHECK = self.com.rememberLoginCheck
        GUI.CHANNEL_TAB = self.com.channelNotebook
        # Disabled the Roster tab. 
        # Move this line into ui_communicator.py either manually or
        # through QTDesigner somehow. Qt Designer does not appear
        # to allow me to disable individual tabs in a notebook,
        # only the notebook as a while.
        GUI.USERNAME_ENTRY.setFocus()
        GUI.CONTENT_NOTEBOOK.setTabEnabled(1, False)
        GUI.ONLINE_LAYOUT = self.com.onlineLayout

    def on_chatEntry_returnPressed(self, *args):
        self.on_submitButton_clicked(self, *args)
    
    def generate_channels(self):
        for i in range(0,len(Communicator.CHANNEL_LIST)):
#.........这里部分代码省略.........