def download_data(self, url, path, msg):
if not os.path.exists(path):
try:
progressMessageBar = self.iface.messageBar().createMessage(
"Downloading " + msg)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
self.iface.messageBar().pushWidget(progressMessageBar,
Qgis.Info)
http = urllib3.PoolManager()
response = http.request('GET', url, preload_content=False)
content_length = response.headers['Content-Length']
total_size = int(content_length)
downloaded = 0
CHUNK = 256 * 10240
self.progress.setMinimum(0)
self.progress.setMaximum(total_size)
with open(path, 'wb') as fp:
while True:
time.sleep(1)
chunk = response.read(CHUNK)
downloaded += len(chunk)
self.progress.setValue(downloaded)
if not chunk:
break
fp.write(chunk)
response.release_conn()
self.iface.messageBar().clearWidgets()
except urllib3.exceptions.MaxRetryError:
QMessageBox.information(self.iface.mainWindow(), "HTTP Error",
"Unable to download file")
def on_button_box_accepted(self):
if self.filenameEdit.text() == '':
QMessageBox.warning(
self, self.tr("Warning!"),
self.tr("Please, select a location to save the file."))
return
# Initiating processing
osmRequest = OSMRequest(self.filenameEdit.text())
osmRequest.setParameters(self.wEdit.text(), self.sEdit.text(),
self.eEdit.text(), self.nEdit.text())
# Connecting end signal
osmRequest.signals.processFinished.connect(self.processFinished)
osmRequest.signals.sizeReported.connect(self.reportSize)
osmRequest.signals.proxyOpened.connect(self.proxy)
osmRequest.signals.errorOccurred.connect(self.errorOccurred)
osmRequest.signals.userCanceled.connect(self.userCanceled)
# Setting the progress bar
# << Updated by SIGMOÉ
self.msgBar = self.iface.messageBar()
self.progressMessageBar = self.msgBar.createMessage(
'Downloading data...')
# >>
self.progressBar = QProgressBar()
self.progressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progressBar)
self.iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progressBar.setRange(0, 0)
self.progressMessageBar.destroyed.connect(osmRequest.signals.cancel)
# Starting process
self.threadpool.start(osmRequest)
def on_downloaded(self):
widget = self.iface.messageBar().createMessage(
"Géofoncier", "Téléchargement du RFU.")
progress_bar = QProgressBar()
progress_bar.setMinimum(0)
progress_bar.setMaximum(2)
widget.layout().addWidget(progress_bar)
self.iface.messageBar().pushWidget(widget)
progress_bar.setValue(1)
# https://pro.geofoncier.fr/index.php?¢re=-196406,5983255&context=metropole
url = self.permalinkCmb.currentText()
if not url:
return self.abort_action(msg="Veuillez renseigner le permalien.")
self.url = url
try:
self.download(self.url)
except Exception as e:
return self.abort_action(msg=str(e))
self.save_permalinks(self.url)
progress_bar.setValue(2)
self.iface.messageBar().clearWidgets()
return
def publish(self):
progressMessageBar = self.bar.createMessage(
self.tr("Publishing layers"))
progress = QProgressBar()
progress.setMaximum(100)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.bar.pushWidget(progressMessageBar, Qgis.Info)
QCoreApplication.processEvents()
task = self.getPublishTask(self.parent)
task.progressChanged.connect(progress.setValue)
ret = execute(task.run)
self.bar.clearWidgets()
task.finished(ret)
if task.exception is not None:
self.bar.clearWidgets()
self.bar.pushMessage(self.tr("Error while publishing"),
self.tr("See QGIS log for details"),
level=Qgis.Warning,
duration=5)
QgsMessageLog.logMessage(task.exception,
'GeoCat Bridge',
level=Qgis.Critical)
self.updateLayersPublicationStatus(task.geodataServer is not None,
task.metadataServer is not None)
def progress_bar(iface, min_value=1, max_value=100):
"""
If you want more control over the layout of your progress bar and want
to be able to add messages to it etc, use the StatusProgressBar object
usage::
with progress_bar(iface) as pb:
pb.setValue(value)
"""
# clear the message bar
iface.messageBar().clearWidgets()
# set a new message bar
try:
progressMessageBar = iface.messageBar()
_progress_bar = QProgressBar()
# Maximum is set to 100, making it easy to work with
# percentage of completion
_progress_bar.setMinimum(min_value)
_progress_bar.setMaximum(max_value)
# pass the progress bar to the message Bar
progressMessageBar.pushWidget(_progress_bar)
yield _progress_bar
finally:
iface.messageBar().clearWidgets()
def init_progress_dialog(self):
"""
Initializes the progress dialog.
"""
self.progress = QProgressBar(self)
self.progress.resize(self.width(), 10)
self.progress.setTextVisible(False)
def start_computing(self):
"""computing called in new thread and showing a progressBar"""
computation = Move(self.input.text(), self.output.text(),
self.ellipsoidSelector.text(),
self.units.currentText(), self.value.text())
messageBar = self.iface.messageBar().createMessage('Computing...')
progressBar = QProgressBar()
cancelButton = QPushButton()
cancelButton.setText('Cancel')
messageBar.layout().addWidget(progressBar)
messageBar.layout().addWidget(cancelButton)
computationThread = QThread(self)
computation.moveToThread(computationThread)
computation.finished.connect(self.computing_finished)
computation.progress.connect(progressBar.setValue)
cancelButton.clicked.connect(self.cancel_computing)
computationThread.started.connect(computation.shift)
computation.error.connect(self.value_error)
self.iface.messageBar().pushWidget(messageBar, Qgis.Info)
if not computationThread.isRunning():
self.computationRunning = True
computationThread.start()
self.computation = computation
self.computationThread = computationThread
self.messageBar = messageBar
def progress_bar(self):
try:
return self._progress_bar
except AttributeError:
message_bar_item = QgsMessageBarItem("")
label = QLabel(self.tr("Computing cartogram"))
label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
message_bar_item.layout().addWidget(label)
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progress_bar.setMaximum(100)
message_bar_item.layout().addWidget(progress_bar)
cancel_button = QPushButton(self.tr("Cancel"))
cancel_button.clicked.connect(self.cancel_task)
message_bar_item.layout().addWidget(cancel_button)
self.iface.messageBar().pushWidget(message_bar_item)
self._progress_bar_message_bar_item = message_bar_item
self._progress_bar = progress_bar
self._cancel_button = cancel_button
return self._progress_bar
def __init__(self, min, max, message, parent=None, timeout=1.5):
"""
Constructs a progress widget
"""
super(self.__class__, self).__init__(parent)
self.min = min
self.max = max
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
if parent:
self.setMinimumSize(parent.width(), 40)
else:
self.setMinimumSize(766, 40)
self.setSizePolicy(sizePolicy)
self.progressBar = QProgressBar()
self.progressBar.setMinimum(min)
self.progressBar.setMaximum(max)
self.parent = parent
self.msgBarItem = QgsMessageBarItem(self.tr("INFO: "),
message,
self.progressBar,
level=Qgis.Info,
duration=timeout,
parent=self.parent)
self.pushItem(self.msgBarItem)
self.parent.repaint()
def process_meta_file(self):
meta_file = self.select_meta_file()
if meta_file:
# process peaks
processed_peaks = get_peaks(meta_file)
self.peaks.append(processed_peaks)
self.populate_lists()
self.iface.messageBar().pushSuccess(
"Success", "Meta file processed successfully!")
# process hydrographs
progressMessageBar = self.iface.messageBar().createMessage(
"Processing hydrographs...")
progress = QProgressBar()
progress.setMaximum(
len(self.peaks[0]["storm"].sort_values().unique()))
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
processed_hydrographs = get_hydrographs(meta_file,
progress=progress)
self.hydrographs.append(processed_hydrographs)
self.iface.messageBar().clearWidgets()
self.iface.messageBar().pushSuccess(
"Success", "Hydrographs processed successfully!")
model = DataFrameModel(self.peaks[0])
self.dockwidget.dataTableView.setModel(model)
def on_restore_pressed(self):
try:
barra = QProgressBar(self)
barra.show()
barra.setMinimum(0)
barra.setMaximum(9)
for a in range(10):
time.sleep(1)
barra.setValue(a)
path = self.percorso
os.popen('dropdb -U postgres pyarchinit')
os.popen(
'createdb -U postgres -p 5432 -h localhost -E UTF8 -T template_postgis_20 -e pyarchinit'
)
os.popen(
'pg_restore --host localhost --port 5432 --username postgres --dbname pyarchinit --role postgres --no-password --verbose %s'
% str(path))
QMessageBox.warning(self, 'Messaggio', 'Ripristino completato',
QMessageBox.Ok)
except Exception as e:
QMessageBox.warning(self, 'Messaggio',
'Ripristino fallito!!' + str(e),
QMessageBox.Ok)
def __init__(self, iFace):
# Save reference to the QGIS interface
self.iFace = iFace
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'BhuvanWebServices_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
self.dlg = BhuvanWebServicesDialog()
self.dlginfo = InfoDialog()
self.generatedService = None
self.bar = QProgressBar()
self.bar.setRange(0, 0)
self.bar.setGeometry(950, 500, 200, 25)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Bhuvan Web Services')
# Check if plugin was started the first time in current QGIS session
# Must be set in initGui() to survive plugin reloads
self.first_start = None
def create_progress_bar(self, message, size):
progress_message_bar = self.iface.messageBar().createMessage(message)
progress_b = QProgressBar()
progress_b.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progress_message_bar.layout().addWidget(progress_b)
self.iface.messageBar().pushWidget(progress_message_bar)
progress_b.setMaximum(size)
return progress_b
def progressWidget(self):
"""
Retrieves a progress widget bar.
"""
bar = QProgressBar()
bar.setTextVisible(True)
bar.setValue(0)
return bar
def __init__(self, iface):
QDialog.__init__(self, iface.mainWindow())
self.workerThread = None
self.state = False
self.resultStatus = None
self.doReRun = False
self.wasCanceled = False
self.wasSuccessful = False
self.savedProj = None
self.result = None
self.messageTxt = {
'msg_optimierung': self.tr('Berechnung der optimalen Stuetzenpositionen...'),
'msg_seillinie': self.tr('Berechnung der optimale Seillinie...')
}
# Build GUI Elements
self.setWindowTitle(self.tr("SEILAPLAN wird ausgefuehrt"))
self.resize(500, 100)
self.container = QVBoxLayout()
self.progressBar = QProgressBar(self)
self.progressBar.setMinimumWidth(500)
self.statusLabel = QLabel(self)
self.hbox = QHBoxLayout()
self.cancelButton = QDialogButtonBox()
self.closeButton = QDialogButtonBox()
self.resultLabel = QLabel(self)
self.resultLabel.setMaximumWidth(500)
self.resultLabel.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
self.resultLabel.setWordWrap(True)
spacer1 = QSpacerItem(20, 20, QSizePolicy.Fixed,
QSizePolicy.Fixed)
self.rerunButton = QPushButton(self.tr("zurueck zum Startfenster"))
self.rerunButton.setVisible(False)
spacer2 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.cancelButton.setStandardButtons(QDialogButtonBox.Cancel)
self.cancelButton.button(QDialogButtonBox.Cancel).setText(self.tr("Abbrechen"))
self.cancelButton.clicked.connect(self.onAbort)
self.closeButton.setStandardButtons(QDialogButtonBox.Close)
self.closeButton.button(QDialogButtonBox.Close).setText(self.tr("Schliessen"))
self.closeButton.clicked.connect(self.onClose)
self.hbox.addWidget(self.rerunButton)
self.hbox.addItem(spacer2)
self.hbox.addWidget(self.cancelButton)
self.hbox.setAlignment(self.cancelButton, Qt.AlignHCenter)
self.hbox.addWidget(self.closeButton)
self.hbox.setAlignment(self.closeButton, Qt.AlignHCenter)
self.closeButton.hide()
self.container.addWidget(self.progressBar)
self.container.addWidget(self.statusLabel)
self.container.addWidget(self.resultLabel)
self.container.addItem(spacer1)
self.container.addLayout(self.hbox)
self.container.setSizeConstraint(QLayout.SetFixedSize)
self.setLayout(self.container)
def initGui(self):
"""startup"""
parent = self.iface.mainWindow()
######## action, button
icon = QIcon("%s/%s" % (config.PLUGIN_DIR, "images/xyz.png"))
icon_bbox = QIcon("%s/%s" % (config.PLUGIN_DIR, "images/bbox.svg"))
self.action_connect = QAction(icon, "XYZ Hub Connection", parent)
self.action_connect.setWhatsThis(
QCoreApplication.translate(PLUGIN_NAME, "WhatsThis message"))
self.action_connect.setStatusTip(
QCoreApplication.translate(PLUGIN_NAME, "status tip message"))
self.action_magic_sync = QAction("Magic Sync (EXPERIMENTAL)", parent)
if self.iface.activeLayer() is None:
self.action_magic_sync.setEnabled(False)
# self.action_magic_sync.setVisible(False) # disable magic sync
######## CONNECT action, button
self.action_connect.triggered.connect(self.open_connection_dialog)
self.action_magic_sync.triggered.connect(self.open_magic_sync_dialog)
######## Add the toolbar + button
self.toolbar = self.iface.addToolBar(PLUGIN_NAME)
self.toolbar.setObjectName("XYZ Hub Connector")
self.actions = [self.action_connect]
for a in self.actions:
self.iface.addPluginToWebMenu(self.web_menu, a)
# # uncomment to use menu button
# tool_btn = QToolButton(self.toolbar)
# for a in self.actions:
# tool_btn.addAction(a)
# tool_btn.setDefaultAction(self.action_connect)
# tool_btn.setPopupMode(tool_btn.MenuButtonPopup)
# self.xyz_widget_action = self.toolbar.addWidget(tool_btn) # uncomment to use menu button
self.toolbar.addAction(self.action_connect)
self.action_help = None
progress = QProgressBar()
progress.setMinimum(0)
progress.setMaximum(0)
progress.reset()
progress.hide()
# progress = self.iface.statusBarIface().children()[2] # will be hidden by qgis
self.iface.statusBarIface().addPermanentWidget(progress)
self.pb = progress
def __init__(self, algname=None):
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar,
iface.messageBar().INFO)
def start(self, max=0, msg=''):
self.widget = self.iface.messageBar().createMessage(self.title, msg)
self.progressBar = QProgressBar()
self.progressBar.setRange(0, max)
self.progressBar.setValue(0)
self.progressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.widget.layout().addWidget(self.progressBar)
QApplication.processEvents()
self.iface.messageBar().pushWidget(self.widget, Qgis.Info, 50)
QApplication.processEvents()
def create_progress_bar(message):
progress_widget = QProgressBar()
progress_widget.setMaximum(100)
progress_widget.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
message_bar = iface.messageBar().createMessage(message)
message_bar.setWidget(progress_widget)
iface.messageBar().pushMessage('')
iface.messageBar().pushWidget(message_bar)
return progress_widget
def progressdialog(self, progress):
pdialog = QProgressDialog()
pdialog.setWindowTitle("Progress")
pdialog.setLabelText("Voortgang van importeren:")
pbar = QProgressBar(pdialog)
pbar.setTextVisible(True)
pbar.setValue(progress)
pdialog.setBar(pbar)
pdialog.setMinimumWidth(300)
pdialog.show()
return pdialog, pbar
def __init__(self, algname=None):
QgsProcessingFeedback.__init__(self)
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progressChanged.connect(self.progress.setValue)
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
def startProgressBar(self, iniMsg):
#iniMsg ="Disabling Snapping to Layer: "
#iface=self.iface
progressMessageBar = iface.messageBar().createMessage(
self.SETTINGS, iniMsg)
progress = QProgressBar()
progress.setMaximum(100)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
#pass the progress bar to the message Bar
progressMessageBar.layout().addWidget(progress)
iface.messageBar().pushWidget(progressMessageBar)
return progress, progressMessageBar
def OnGenerate(self):
"""Reads the directory and other input values. Loops the TIF files and runs the conversion."""
input_dir = self.textInput.toPlainText()
output_dir = self.textOutput.toPlainText()
if input_dir == output_dir:
iface.messageBar().pushMessage(
self.tr("Error"),
self.tr("The input and output directories must differ"),
level=Qgis.Critical)
return
directory = os.fsencode(input_dir)
# Sets the color values
r_color = self.mColorButton.color().red()
g_color = self.mColorButton.color().green()
b_color = self.mColorButton.color().blue()
# Sets the progress bar item to show progress in the loop
progressMessageBar = iface.messageBar().createMessage("Converting...")
progress = QProgressBar()
progress.setMaximum(len(os.listdir(directory)))
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
i = 0
# Loop the directory
for file in os.listdir(directory):
progress.setValue(i + 1)
filename = os.fsdecode(file)
if filename.endswith(".tif"):
src_filename = os.path.join(input_dir, filename)
dst_filename = os.path.join(output_dir, filename)
try:
self.addAlpha(src_filename, dst_filename, r_color, g_color,
b_color)
except:
iface.messageBar().pushMessage(
self.tr("Error"),
self.
tr("The conversion did not work. Please check input and out directories."
),
level=Qgis.Critical)
return
# If succeeded the message appears
iface.messageBar().clearWidgets()
iface.messageBar().pushMessage(
self.tr("Success"),
self.tr("Output layers saved to {}").format(output_dir),
level=Qgis.Success)
def setProgressBarAndMessages(self, val):
self.progressbar.setValue(val)
# --- Progress bar in the QGIS user messages (top)
if val <= 10:
message = "Starting..."
self.progressMessageBar = iface.messageBar().createMessage(message)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progress.setValue(val)
elif val < 50:
message = "First half"
self.progressMessageBar = iface.messageBar().createMessage(message)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progress.setValue(val)
elif val < 100:
message = "Second Half"
self.progressMessageBar = iface.messageBar().createMessage(message)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progress.setValue(val)
elif val == 100:
message = "Complete"
self.progressMessageBar = iface.messageBar().createMessage(message)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progress.setValue(val)
iface.messageBar().clearWidgets()
def __init__(self, title=None):
QDialog.__init__(self, None)
if title is not None:
self.setWindowTitle(title)
self.__label = QLabel(self)
self.__layout = QVBoxLayout()
self.__layout.addWidget(self.__label)
self.__progress = QProgressBar(self)
self.__layout.addWidget(self.__progress)
self.setLayout(self.__layout)
self.resize(600, 70)
self.setFixedSize(600, 70)
self.__progress.hide()
self.show()
def createProgressbar(self, loopnumber):
"""
Create a progress bar when iterating over features
"""
progressMessageBar = self.messageBar.createMessage(
str(u"Chargement des données..."))
progress = QProgressBar()
progress.setMinimum(0)
progress.setMaximum(loopnumber)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.messageBar.pushWidget(progressMessageBar)
return progress
def __init__(self, parent, title, progress=False):
super().__init__(parent, Qt.WindowTitleHint)
vbox = QVBoxLayout()
self.progress_bar = QProgressBar()
max_val = PROGRESS_BAR_MAX if progress else 0
self.progress_bar.setRange(0, max_val)
self.progress_bar.setTextVisible(False)
vbox.addWidget(self.progress_bar)
self.setModal(True)
self.setWindowTitle(title)
self.setLayout(vbox)
self.setMaximumHeight(0)
self.setFixedWidth(parent.width() * 0.25)
self.show()
def loading(self):
""" Loading progress bar """
self.dialog = QProgressDialog()
self.dialog.setWindowTitle("Loading")
self.dialog.setLabelText("That's your progress")
self.bar = QProgressBar()
self.bar.setTextVisible(True)
self.dialog.setBar(self.bar)
self.dialog.setMinimumWidth(300)
self.dialog.show()
self.timer = QTimer()
self.timer.timeout.connect(self.saver)
self.timer.start(1000)
def initField(self):
# get current layer
layer = self.iface.mapCanvas().currentLayer(
) # nF = layer.selectedFeatureCount() #print nF #self.ui.txX.setText("Yes, you can!")
layer.setLabelsEnabled(True)
vpr = layer.dataProvider()
# Get the field of current comobox
cbField_origin = str(
self.ui.cbField.currentText()) #print cbField_origin
print(cbField_origin)
# start to edit attributes of fields
layer.startEditing()
allFeatures = layer.getFeatures()
count = layer.featureCount()
infoString = str(
"<font color='red'> Creating and initializing the label fields......Wait this completed please......</font>"
)
progressMessageBar = self.iface.messageBar().createMessage(infoString)
progress = QProgressBar()
progress.setMaximum(count)
progress.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
# loop for initialization
n = -1
for feature in allFeatures:
feature[share.field_list[0][0]] = feature[cbField_origin]
feature[share.field_list[1][0]] = 999999999999999999.0
feature[share.field_list[2][0]] = 999999999999999999.0
feature[share.field_list[3][0]] = 0.0
feature[share.field_list[4][0]] = 1
feature[share.field_list[5][0]] = "Center"
feature[share.field_list[6][0]] = "Half"
n = n + 1
layer.updateFeature(feature)
progress.setValue(n + 1)
self.iface.messageBar().clearWidgets()
# updateExtents and refresh mapCanvas
#layer.updateExtents()
layer.commitChanges() # make sure that fields are initialize correctly
self.iface.mapCanvas().refresh()
def __init__(self, maximum=100, message_title=""):
self.maximum = maximum
self.message_bar = iface.messageBar().createMessage(message_title, "")
self.progress_bar = QProgressBar()
self.progress_bar.setMaximum(maximum)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.message_bar.layout().addWidget(self.progress_bar)
if iface is not None:
iface.messageBar().pushWidget(self.message_bar,
Qgis.MessageLevel())
self.step_size = 1
self.progress = 0
