def import_data_to_db(self, schema, convert2polygon=True, is_shp=False):
"""Imports the data into the database.
:param schema str, what kind of data is it
:param convert2polygon bool, is the data in the shp file already
polygons?
:param is_shp bool, is the data from a shp file?
"""
#TODO: fix the treading!
self.is_shp = is_shp
self.schema = schema
self.idata = InsertData(self.IH, self.defined_field, self.db, schema,
convert2polygon, is_shp)
worker_thread_work = QThread()
self.idata.moveToThread(worker_thread_work)
worker_thread_work.started.connect(self.idata.import_data_to_db)
worker_thread_work.start()
waiting_thread = QThread()
waiting_thread.start()
wait_msg = 'Please wait while data is being prosecuted'
self.wait = Waiting(wait_msg)
self.wait.moveToThread(waiting_thread)
self.wait.start.connect(self.wait.start_work)
self.wait.start.emit('run')
while not self.idata.finish:
time.sleep(1)
self.end_method()
def fn(self):
'QThread-Objekt instanziieren'
thread_empfaenger = QThread()
thread_sender = QThread()
'Motor-Objekt instanziieren'
self.empfaenger = Server_empfaenger()
self.sender = Server_sender()
'Motor-Objekt an den Thread übergeben'
self.empfaenger.moveToThread(thread_empfaenger)
self.sender.moveToThread(thread_sender)
'Signale und Slots verbinden'
thread_empfaenger.started.connect(self.empfaenger.starten)
# self.empfaenger.finished.connect(thread_empfaenger.quit)
# self.empfaenger.finished.connect(self.empfaenger.deleteLater)
thread_empfaenger.finished.connect(thread_empfaenger.deleteLater)
thread_sender.started.connect(self.sender.starten)
# self.sender.finished.connect(thread_sender.quit)
# self.sender.finished.connect(self.sender.deleteLater)
thread_sender.finished.connect(thread_sender.deleteLater)
'Methode start des Thread-Objektes aufrufen'
thread_empfaenger.start()
thread_sender.start()
'Methode exec des Thread-Objektes aufrufen'
thread_empfaenger.exec()
thread_sender.exec()
def __init__(self, filename, controller, done_loading_callback,
done_writing_callback):
self.controller = controller
self.done_loading_callback = done_loading_callback
self.writing_done_callback = done_writing_callback
self.data = defaultdict(list)
self.all_data = []
self.data_keys = set()
self.color_change_data = []
self.actual_z = '0.0'
self.speed = 0.0
self.z_hop = False
self.last_point = np.array([0.0, 0.0, 0.0])
self.actual_point = [0.0, 0.0, 0.0]
self.printing_time = 0.0
self.filament_length = 0.0
#print("Filename type: " + str(type(filename)))
#print("Filename: " + filename)
#if type(filename)==:
#self.filename = u'c:\\models\\super mega testovací Jindřich šložka čěýáéůú\\anubis_PLA_OPTIMAL.gcode'
self.filename = filename
self.is_loaded = False
self.gcode_parser = GcodeParserRunner(controller, self.filename)
self.gcode_parser_thread = QThread()
self.gcode_copy = GcodeCopyRunner(
self.filename, "", color_change_lst=self.color_change_data)
self.gcode_copy_thread = QThread()
def insert_to_db(self):
self.waiting_thread = QThread()
self.waiting_thread.start()
wait_msg = 'Please wait while data is being prosecuted'
self.wait = Waiting(wait_msg)
self.wait.moveToThread(self.waiting_thread)
self.worker2 = InsertHarvestToDB(self.IH, self.iface, self.polygon,
self.db)
#self.worker2.insert_to_db()
self.worker_thread_work = QThread()
self.worker_thread_work.start()
time.sleep(1)
self.worker2.moveToThread(self.worker_thread_work)
self.worker2.starts.connect(self.worker2.insert_to_db)
self.worker2.starts.emit('run')
self.wait.start.connect(self.wait.start_work)
self.wait.start.emit('run')
self.dock_widget.PBAddFieldToDB.setEnabled(False)
while not self.worker2.finished:
time.sleep(1)
self.CreateLayer.create_layer_style(
self.worker2.layer, check_text(self.worker2.harvest_yield_col),
self.worker2.tbl_name.lower(), 'harvest')
QgsMapLayerRegistry.instance().addMapLayer(self.worker2.layer)
QgsMapLayerRegistry.instance().removeMapLayer(self.IH.input_layer.id())
self.wait.stop_work()
def __init__(self):
super(Form, self).__init__()
self.initUI()
self.worker = {}
self.threadx = {}
self.i = 0
i = 0
#Establish the maximum number of threads the machine can optimally handle
#Generally relates to the number of processors
self.threadtest = QThread(self)
self.idealthreadcount = self.threadtest.idealThreadCount()
print("This machine can handle {} threads optimally".format(
self.idealthreadcount))
while i < self.idealthreadcount:
self.setupThread(i)
i += 1
i = 0
while i < self.idealthreadcount:
self.startThread(i)
i += 1
print("Main Gui running in thread {}.".format(self.thread()))
def server_starten(self):
self.mode = 0
self.g_code_modus = False
self.message_lenght = 1024
self.verb = socket(AF_INET, SOCK_STREAM)
self.verb.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
try:
self.verb.bind(('127.0.0.1', 60112))
print("Osterhase" + str(self.verb))
except Exception as e:
print(e)
self.thread_server_emp = QThread()
'Server-Objekt instanziieren'
self.server_emp = Server_empfaenger()
'Server-Objekt an den Thread übergeben'
self.server_emp.moveToThread(self.thread_server_emp)
'Signale und Slots verbinden'
self.thread_server_emp.started.connect(self.server_emp.server_starten)
self.server_emp.nachricht_empfangen.connect(self.nachricht_empfangen)
print("server_emp.nachricht_empfangen connected")
self.thread_server_emp.finished.connect(
self.thread_server_emp.deleteLater)
'Methode start des Thread-Objektes aufrufen'
self.thread_server_emp.start()
'Methode exec des Thread-Objektes aufrufen'
self.thread_server_emp.exec()
def start_thread(self):
self.weight_monitor = ArduinoMonitor()
self.t = QThread(self)
self.weight_monitor.weight_signal.connect(self.update_weight)
self.weight_monitor.moveToThread(self.t)
self.t.started.connect(self.weight_monitor.check_weight)
self.t.start()
def __accepted(self):
steps = self.addonwidget.item_state()
if steps:
# Move all uninstall steps to the front
steps = sorted(steps,
key=lambda step: 0 if step[0] == Uninstall else 1)
self.__installer = Installer(steps=steps,
user_install=self.user_install)
self.__thread = QThread(self)
self.__thread.start()
self.__installer.moveToThread(self.__thread)
self.__installer.finished.connect(self.__on_installer_finished)
self.__installer.error.connect(self.__on_installer_error)
self.__installer.installStatusChanged.connect(
self.__progress.setLabelText)
self.__progress.show()
self.__progress.setLabelText("Installing")
self.__installer.start()
else:
self.accept()
def startWorker(self, layer):
# Initialize worker with selected layer
worker = Worker(layer)
# Disable run button
self.dlg.runButton.setEnabled(False)
# Ensure worker is killed if dialog is "killed" (either by the user clicking Cancel, closing the dialog, or by pressing the Escape key)
self.dlg.rejected.connect(worker.kill)
# Initialize new thread and move worker to it
thread = QThread(self.dlg)
worker.moveToThread(thread)
# Connect signals to slots
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.progress.connect(self.dlg.progressBar.setValue)
thread.started.connect(worker.run)
# Start thread and run worker
thread.start()
# Save reference to thread and worker
self.thread = thread
self.worker = worker
def search_thread(self):
'''
Creates Qt thread for searching so that the GUI does not freeze and
QGIS does not crash.
'''
#
# Disable search button while searching.
#
self.dlg.btnSearch.setEnabled(False)
self.dlg.btnSearchCancel.setEnabled(True)
self.worker = SentinelSearch(self.dlg)
self.thread = QThread()
self.worker.moveToThread(self.thread)
self.thread.start()
self.thread.started.connect(self.worker.get_query_xml)
#
# Signal handelling from thread.
#
self.worker.query_check.connect(self.query_search_check)
self.worker.connecting_message.connect(self.set_search_label)
self.worker.searching_message.connect(self.set_search_label)
self.worker.enable_btnSearch.connect(self.enable_btnSearch)
self.worker.search_progress_max.connect(self.set_progress_max)
self.worker.search_progress_set.connect(self.set_progress)
self.worker.set_message.connect(self.set_messageBar)
self.worker.finished.connect(self.search_finished)
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.button = QtGui.QPushButton("Run", self)
self.button.clicked.connect(self.onButton)
self.progress = QtGui.QProgressBar(self)
self.progress.setTextVisible(False)
self.layout = QtGui.QVBoxLayout()
self.layout.setContentsMargins(5, 5, 5, 5)
self.layout.addWidget(self.button)
self.layout.addWidget(self.progress)
self.layout.addStretch()
self.worker_thread = QThread()
self.worker_thread.run = run_gestures #self.worker
self.worker_thread.should_close = False
self.signals = Signals()
self.signals.update.connect(self.progress.setValue)
self.signals.enable_button.connect(self.button.setEnabled)
self.setLayout(self.layout)
self.show()
self.resize(self.size().width(), 0)
def __init__(self, iface, parent=None):
super(ComposersDialog, self).__init__(parent)
self.setupUi(self)
self.iface = iface
self.btnSave = QPushButton(self.tr("Save"))
self.btnSave.setIcon(
QgsApplication.getThemeIcon("/mActionFileSave.svg"))
self.btnSave.clicked.connect(self.saveToFile)
#self.btnCopy = QPushButton(self.tr("Copy"))
#self.btnCopy.setIcon(QgsApplication.getThemeIcon("/mActionEditCopy.svg"))
#self.btnCopy.clicked.connect(self.copyToClipboard)
self.buttonBox.addButton(self.btnSave, QDialogButtonBox.ActionRole)
#self.buttonBox.addButton(self.btnCopy, QDialogButtonBox.ActionRole)
#self.buttonBox.helpRequested.connect()
self.progressBar.hide()
self.thread = QThread()
self.writer = TemplateWriter()
self.writer.moveToThread(self.thread)
self.writer.finished.connect(self.thread.quit)
self.writer.finished.connect(self.exportFinished)
self.writer.composerExported.connect(self.updateProgress)
self.thread.started.connect(self.writer.export)
self.composers = None
self.loadComposers()
def startWorker(self, dsm, dem, dsm_build, poly, poly_field, vlayer, prov, fields, idx, dir_poly, iface, plugin_dir,
folderPath, dlg, imid, radius, degree, rm):
# create a new worker instance
# Skapar en instans av metoden som innehaller det arbete som ska utforas i en trad
worker = Worker(dsm, dem, dsm_build, poly, poly_field, vlayer, prov, fields, idx, dir_poly, iface,
plugin_dir, folderPath, dlg, imid, radius, degree, rm)
# andrar knappen som startar verktyget till en knapp som avbryter tradens arbete.
self.dlg.runButton.setText('Cancel')
self.dlg.runButton.clicked.disconnect()
self.dlg.runButton.clicked.connect(worker.kill)
self.dlg.closeButton.setEnabled(False)
# Skapar en trad som arbetet fran worker ska utforas i.
thread = QThread(self.dlg)
worker.moveToThread(thread)
# kopplar signaler fran traden till metoder i denna "fil"
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.progress.connect(self.progress_update)
thread.started.connect(worker.run)
# startar traden
thread.start()
self.thread = thread
self.worker = worker
def _initThread(self):
self.thread = QThread(self)
self.thread.setObjectName("QGIS_Plugin_%s" %
NAME_PLUGIN.replace(' ', '_'))
self.worker = WorkerPopulateGroup(self.addLegendLayerWorker)
self.worker.moveToThread(self.thread)
self._connectWorker()
def __init__(self, iface, parent=None):
super(Photo2ShapeDialog, self).__init__(parent)
self.setupUi(self)
self.iface = iface
self.settings = QSettings('alexbruy', 'photo2shape')
self.thread = QThread()
self.importer = PhotoImporter()
self.btnOk = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.btnSelectInput.clicked.connect(self.selectDirectory)
self.btnSelectOutput.clicked.connect(self.selectFile)
self.importer.moveToThread(self.thread)
self.importer.importError.connect(self.thread.quit)
self.importer.importError.connect(self.importCanceled)
self.importer.importMessage.connect(self.logMessage)
self.importer.importFinished.connect(self.thread.quit)
self.importer.importFinished.connect(self.importCompleted)
self.importer.photoProcessed.connect(self.updateProgress)
self.thread.started.connect(self.importer.importPhotos)
self.manageGui()
def build_index(self, project):
self.searchbox.setEnabled(False)
self.resultsView.setEnabled(False)
self.resultsView.addItem("building search index...")
validformat, settings = valid_search_settings(project.settings)
if not validformat:
RoamEvents.raisemessage("Searching", "Invalid search config.", level=1)
self.searchbox.hide()
self.resultsView.clear()
self.resultsView.addItem("Invalid search config found")
return
self.indexthread = QThread()
path = os.path.join(os.environ['APPDATA'], "roam", project.name)
roam.utils.info("Search index path: {0}".format(path))
if not os.path.exists(path):
os.makedirs(path)
self.indexbuilder = IndexBuilder(path, settings)
self.indexbuilder.moveToThread(self.indexthread)
QgsMapLayerRegistry.instance().removeAll.connect(self.indexthread.quit)
self.indexbuilder.indexBuilt.connect(self.index_built)
self.indexbuilder.finished.connect(self.indexthread.quit)
self.indexthread.started.connect(self.indexbuilder.build_index)
self.indexthread.finished.connect(self.indexbuilder.quit)
self.indexthread.start()
def start(self, *args, **kwargs):
"""Starts worker in separate thread"""
# stop any previously running workers
self.stop()
self.result = None
self.error = None
self.running = True
self.thread = QThread()
self.worker = self.cls(*args, **kwargs)
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.start)
# graceful stop does not work without direct connection (?)
self.worker.finished.connect(self.thread.quit, Qt.DirectConnection)
self.worker.finished.connect(self.worker.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
# also save result/error on finish (useful for testing)
self.worker.finished.connect(self.handlefinished, Qt.DirectConnection)
self.worker.raised.connect(self.handleraised, Qt.DirectConnection)
self.worker.completed.connect(self.handlecompleted,
Qt.DirectConnection)
self.worker.killed.connect(self.handlekilled, Qt.DirectConnection)
self.thread.start()
# returns worker so caller can connect signals, etc.
return self.worker
def startWorker(self, dsm, scale, building_slope, building_aspect,
voxelheight, sizey, sizex, vegdsm, vegdsm2, wheight,
waspect, albedo, psi, radmatI, radmatD, radmatR, usevegdem,
calc_month, dlg):
# create a new worker instance
worker = Worker(dsm, scale, building_slope, building_aspect,
voxelheight, sizey, sizex, vegdsm, vegdsm2, wheight,
waspect, albedo, psi, radmatI, radmatD, radmatR,
usevegdem, calc_month, dlg)
self.dlg.runButton.setText('Cancel')
self.dlg.runButton.clicked.disconnect()
self.dlg.runButton.clicked.connect(worker.kill)
self.dlg.pushButtonClose.setEnabled(False)
# start the worker in a new thread
thread = QThread(self.dlg)
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.progress.connect(self.progress_update)
thread.started.connect(worker.run)
thread.start()
self.thread = thread
self.worker = worker
def build_index(self, project):
self.searchbox.setEnabled(False)
self.resultsView.setEnabled(False)
self.resultsView.addItem(
"Just let me build the search index first....")
validformat, settings = valid_search_settings(project.settings)
if not validformat:
RoamEvents.raisemessage("Searching",
"Invalid search config.",
level=1)
self.searchbox.hide()
self.resultsView.clear()
self.resultsView.addItem("Invalid search config found")
return
self.indexthread = QThread()
self.indexbuilder = IndexBuilder(project.folder, settings)
self.indexbuilder.moveToThread(self.indexthread)
QgsMapLayerRegistry.instance().removeAll.connect(self.indexthread.quit)
self.indexbuilder.indexBuilt.connect(self.index_built)
self.indexbuilder.finished.connect(self.indexthread.quit)
self.indexthread.started.connect(self.indexbuilder.build_index)
self.indexthread.finished.connect(self.indexbuilder.quit)
self.indexthread.start()
def startCleaning(self):
self.dlg.cleaningProgress.reset()
self.settings = self.dlg.get_settings()
if self.settings['output_type'] == 'postgis':
db_settings = self.dlg.get_dbsettings()
self.settings.update(db_settings)
if self.settings['input']:
cleaning = self.clean(self.settings, self.iface)
# start the cleaning in a new thread
thread = QThread()
cleaning.moveToThread(thread)
cleaning.finished.connect(self.cleaningFinished)
cleaning.error.connect(self.cleaningError)
cleaning.warning.connect(self.giveMessage)
cleaning.cl_progress.connect(self.dlg.cleaningProgress.setValue)
thread.started.connect(cleaning.run)
# thread.finished.connect(self.cleaningFinished)
self.thread = thread
self.cleaning = cleaning
self.thread.start()
if is_debug: print 'started'
else:
self.giveMessage('Missing user input!', QgsMessageBar.INFO)
return
def runSearch(self):
'''Called when the user pushes the Search button'''
selectedLayer = self.layerListComboBox.currentIndex()
comparisonMode = self.comparisonComboBox.currentIndex()
self.noSelection = True
try:
str = unicode(self.findStringEdit.text()).strip()
except:
self.showErrorMessage('Invalid Search String')
return
if str == '':
self.showErrorMessage('Search string is empty')
return
if selectedLayer == 0:
# Include all vector layers
layers = self.iface.legendInterface().layers()
elif selectedLayer == 1:
# Include all selected vector layers
layers = self.iface.legendInterface().selectedLayers()
else:
# Only search on the selected vector layer
layers = [self.searchLayers[selectedLayer]]
self.vlayers = []
# Find the vector layers that are to be searched
for layer in layers:
if isinstance(layer, QgsVectorLayer):
self.vlayers.append(layer)
if len(self.vlayers) == 0:
self.showErrorMessage(
'There are no vector layers to search through')
return
# vlayers contains the layers that we will search in
self.searchButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.doneButton.setEnabled(False)
self.clearButton.setEnabled(False)
self.clearResults()
self.resultsLabel.setText('')
infield = self.searchFieldComboBox.currentIndex() >= 1
if infield is True:
selectedField = unicode(self.searchFieldComboBox.currentText())
else:
selectedField = None
# Because this could take a lot of time, set up a separate thread
# for a worker function to do the searching.
thread = QThread()
worker = Worker(self.vlayers, infield, str, comparisonMode,
selectedField, self.maxResults)
worker.moveToThread(thread)
thread.started.connect(worker.run)
worker.finished.connect(self.workerFinished)
worker.foundmatch.connect(self.addFoundItem)
worker.error.connect(self.workerError)
self.thread = thread
self.worker = worker
self.noSelection = False
thread.start()
def startWorker(self, ExtrairShape, CalcShape, OutShape, Ref, TypeUnits):
# create a new worker instance
worker = Worker(ExtrairShape, CalcShape, OutShape, Ref, TypeUnits)
# configure the QgsMessageBar
qgis.utils.iface.messageBar().clearWidgets()
progressMessageBar = qgis.utils.iface.messageBar().createMessage('Calculating area...')
progressBar = QProgressBar()
progressBar.setMaximum(100)
progressMessageBar.layout().addWidget(progressBar)
qgis.utils.iface.messageBar().pushWidget(progressMessageBar)
self.progressMessageBar = progressMessageBar
# start the worker in a new thread
thread = QThread()
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.progress.connect(progressBar.setValue)
thread.started.connect(worker.runCalc)
thread.start()
self.thread = thread
self.worker = worker
self.output = OutShape
def cancel_analyz(self):
self.analyzer_runner.is_running = False
self.analyzer_runner_thread.quit()
self.analyzer_runner_thread.wait()
self.analyzer_runner_thread = QThread()
self.analyzer_runner = AnalyzerRunner(self.controller)
def start(self):
self.__thread = QThread(self)
self.__worker.moveToThread(self.__thread)
self.__worker.finished.connect(self.finishProcess)
self.__thread.started.connect(self.__worker.run)
self.__thread.start()
def start_worker(worker, iface, message, with_progress=True):
# configure the QgsMessageBar
message_bar_item = iface.messageBar().createMessage(message)
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
if not with_progress:
progress_bar.setMinimum(0)
progress_bar.setMaximum(0)
cancel_button = QPushButton()
cancel_button.setText('Cancel')
cancel_button.clicked.connect(worker.kill)
message_bar_item.layout().addWidget(progress_bar)
message_bar_item.layout().addWidget(cancel_button)
iface.messageBar().pushWidget(message_bar_item, iface.messageBar().INFO)
# start the worker in a new thread
# let Qt take ownership of the QThread
thread = QThread(iface.mainWindow())
worker.moveToThread(thread)
worker.set_message.connect(
lambda message: set_worker_message(message, message_bar_item))
worker.toggle_show_progress.connect(
lambda show: toggle_worker_progress(show, progress_bar))
worker.toggle_show_cancel.connect(
lambda show: toggle_worker_cancel(show, cancel_button))
worker.finished.connect(lambda result: worker_finished(
result, thread, worker, iface, message_bar_item))
worker.error.connect(lambda e: worker_error(e))
worker.progress.connect(progress_bar.setValue)
thread.started.connect(worker.run)
thread.start()
return thread, message_bar_item
def test_task(self):
results = []
task = Task(function=QThread.currentThread)
task.resultReady.connect(results.append)
task.start()
self.app.processEvents()
self.assertSequenceEqual(results, [QThread.currentThread()])
results = []
thread = QThread()
thread.start()
task = Task(function=QThread.currentThread)
task.moveToThread(thread)
self.assertIsNot(task.thread(), QThread.currentThread())
self.assertIs(task.thread(), thread)
task.resultReady.connect(results.append, Qt.DirectConnection)
task.start()
f = task.future()
self.assertIsNot(f.result(3), QThread.currentThread())
self.assertIs(f.result(3), results[-1])
def startWorker(self, iface, layer):
self.dlg.header.setText("Calculating...")
worker = Worker(iface, layer)
messageBar = self.iface.messageBar().createMessage(
'Calculating range...', )
progressBar = QProgressBar()
progressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
cancelButton = 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
#start the worker in a new thread
thread = QThread()
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.progress.connect(progressBar.setValue)
thread.started.connect(worker.run)
thread.start()
self.thread = thread
self.worker = worker
pass
def start_worker_files(self, checked, src, dst, selected_images,
local_config):
# create a new worker instance
worker = WorkerFiles(checked, src, dst, selected_images, local_config)
# configure the QgsMessageBar
messageBar = self.iface.messageBar().createMessage(
'List and copy files...', )
progressBarList = QProgressBar()
progressBarCopy = QProgressBar()
progressBarList.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressBarCopy.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
cancelButton = QPushButton()
cancelButton.setText('Cancel')
cancelButton.clicked.connect(worker.kill)
messageBar.layout().addWidget(progressBarList)
messageBar.layout().addWidget(progressBarCopy)
messageBar.layout().addWidget(cancelButton)
self.iface.messageBar().pushWidget(messageBar,
self.iface.messageBar().INFO)
self.messageBarFiles = messageBar
# start the worker in a new thread
thread = QThread()
worker.moveToThread(thread)
worker.finished.connect(self.finished_worker_files)
worker.error.connect(self.workerError)
worker.progressList.connect(progressBarList.setValue)
worker.progressCopy.connect(progressBarCopy.setValue)
thread.started.connect(worker.run)
thread.start()
self.thread_files = thread
self.worker_files = worker
def uploadDoc(self):
"""
Upload the file to the central repository in a separate thread using the specified file manager
"""
if isinstance(self.fileManager, NetworkFileManager):
self.pgBar.setVisible(True)
self._docSize = self.fileInfo.size()
'''
Create document transfer helper for multi-threading capabilities.
Use of queued connections will guarantee that signals and slots are captured
in any thread.
'''
workerThread = QThread(self)
docWorker = DocumentTransferWorker(
self.fileManager,
self.fileInfo,
"%s"%(self._source_entity),
"%s"%(self._doc_type),
self
)
docWorker.moveToThread(workerThread)
workerThread.started.connect(docWorker.transfer)
docWorker.blockWrite.connect(self.onBlockWritten)
docWorker.complete.connect(self.onCompleteTransfer)
workerThread.finished.connect(docWorker.deleteLater)
workerThread.finished.connect(workerThread.deleteLater)
workerThread.start()
# Call transfer() to get fileUUID early
#docWorker.transfer()
self.fileUUID = docWorker.file_uuid
def run_update(self):
#self.update_pic()
from PyQt4.QtCore import QThread
#TODO: Fix threading
self.next_thread = QThread()
self.next_thread.started.connect(self.update_pic)
self.next_thread.start()
