def test(self):
     if self.widget is not None and self.widget.isVisible():
         QMessageBox.warning(self.iface.mainWindow(), "Tester plugin", "A test cycle is currently being run")
         return
     dlg = TestSelector()
     dlg.exec_()
     if dlg.tests:
         settings = {}
         for test in dlg.tests:
             settings.update(test.settings)
         settings.update(self.lastSettings)
         if settings:
             settingsDlg = SettingsWindow(settings)
             settingsDlg.exec_()
             if not settingsDlg.settings:
                 return
             self.lastSettings = settingsDlg.settings
             for key, value in list(settingsDlg.settings.items()):
                 os.environ[key] = value
         self.widget = TesterWidget()
         self.widget.testingFinished.connect(self.testingFinished)
         self.iface.addDockWidget(Qt.TopDockWidgetArea, self.widget)
         self.widget.show()
         self.widget.setTests(dlg.tests)
         self.widget.startTesting()

    def on_btnLoad_clicked(self):
        fileName, _ = QFileDialog.getOpenFileName(None,
                                                  self.tr('Import Colors and elevations from XML'),
                                                  QDir.homePath(),
                                                  self.tr('XML files (*.xml *.XML)'))
        if fileName == '':
            return

        doc = QDomDocument()
        with codecs.open(fileName, 'r', encoding='utf-8') as f:
            content = f.read()

        if not doc.setContent(content):
            QMessageBox.critical(None,
                                 self.tr('Error parsing XML'),
                                 self.tr('The XML file could not be loaded'))
            return

        self.reliefClassTree.clear()
        reliefColorList = doc.elementsByTagName('ReliefColor')
        for i in range(reliefColorList.length()):
            elem = reliefColorList.at(i).toElement()
            item = QTreeWidgetItem()
            item.setText(0, elem.attribute('MinElevation'))
            item.setText(1, elem.attribute('MaxElevation'))
            item.setBackground(2, QBrush(QColor(int(elem.attribute('red')),
                                                int(elem.attribute('green')),
                                                int(elem.attribute('blue')))))
            self.reliefClassTree.addTopLevelItem(item)

    def saveScript(self, saveAs):
        newPath = None
        if self.filePath is None or saveAs:
            scriptDir = ScriptUtils.scriptsFolders()[0]
            newPath, _ = QFileDialog.getSaveFileName(self,
                                                     self.tr("Save script"),
                                                     scriptDir,
                                                     self.tr("Processing scripts (*.py *.PY)"))

            if newPath:
                if not newPath.lower().endswith(".py"):
                    newPath += ".py"

                self.filePath = newPath

        if self.filePath:
            text = self.editor.text()
            try:
                with codecs.open(self.filePath, "w", encoding="utf-8") as f:
                    f.write(text)
            except IOError as e:
                QMessageBox.warning(self,
                                    self.tr("I/O error"),
                                    self.tr("Unable to save edits:\n{}").format(str(e))
                                    )
                return

            self.setHasChanged(False)

        QgsApplication.processingRegistry().providerById("script").refreshAlgorithms()

    def saveModel(self, saveAs):
        if not self.can_save():
            return
        self.model.setName(str(self.textName.text()))
        self.model.setGroup(str(self.textGroup.text()))
        if self.model.sourceFilePath() and not saveAs:
            filename = self.model.sourceFilePath()
        else:
            filename, filter = QFileDialog.getSaveFileName(self,
                                                           self.tr('Save Model'),
                                                           ModelerUtils.modelsFolders()[0],
                                                           self.tr('Processing models (*.model3 *.MODEL3)'))
            if filename:
                if not filename.endswith('.model3'):
                    filename += '.model3'
                self.model.setSourceFilePath(filename)
        if filename:
            if not self.model.toFile(filename):
                if saveAs:
                    QMessageBox.warning(self, self.tr('I/O error'),
                                        self.tr('Unable to save edits. Reason:\n {0}').format(str(sys.exc_info()[1])))
                else:
                    QMessageBox.warning(self, self.tr("Can't save model"), QCoreApplication.translate('QgsPluginInstallerInstallingDialog', (
                        "This model can't be saved in its original location (probably you do not "
                        "have permission to do it). Please, use the 'Save as…' option."))
                    )
                return
            self.update_model.emit()
            if saveAs:
                self.bar.pushMessage("", self.tr("Model was correctly saved to <a href=\"{}\">{}</a>").format(QUrl.fromLocalFile(filename).toString(), QDir.toNativeSeparators(filename)), level=Qgis.Success, duration=5)
            else:
                self.bar.pushMessage("", self.tr("Model was correctly saved"), level=Qgis.Success, duration=5)

            self.hasChanged = False

    def batchFinished(self):
        self.base.stop()

        if len(self.errors) > 0:
            msg = u"Processing of the following files ended with error: <br><br>" + "<br><br>".join(self.errors)
            QErrorMessage(self).showMessage(msg)

        inDir = self.getInputFileName()
        outDir = self.getOutputFileName()
        if outDir is None or inDir == outDir:
            self.outFiles = self.inFiles

        # load layers managing the render flag to avoid waste of time
        canvas = self.iface.mapCanvas()
        previousRenderFlag = canvas.renderFlag()
        canvas.setRenderFlag(False)
        notCreatedList = []
        for item in self.outFiles:
            fileInfo = QFileInfo(item)
            if fileInfo.exists():
                if self.base.loadCheckBox.isChecked():
                    self.addLayerIntoCanvas(fileInfo)
            else:
                notCreatedList.append(item)
        canvas.setRenderFlag(previousRenderFlag)

        if len(notCreatedList) == 0:
            QMessageBox.information(self, self.tr("Finished"), self.tr("Operation completed."))
        else:
            QMessageBox.warning(self, self.tr("Warning"), self.tr("The following files were not created: \n{0}").format(', '.join(notCreatedList)))

 def show_api_error(self, result):
     if 'error' in result:
         QMessageBox.critical(None, "QGIS Cloud Error", "%s" % result['error'])
         self.status_bar.showMessage(u"Error")
         return True
     else:
         return False

 def okPressed(self):
     self.alg = self.createAlgorithm()
     if self.alg is not None:
         self.close()
     else:
         QMessageBox.warning(self, self.tr('Unable to add algorithm'),
                             self.tr('Wrong or missing parameter values'))

    def __init__(self, iface):
        'initialize'
        # 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", "nl")
        if not locale: locale == 'nl' 
        else: locale = locale[0:2]
        localePath = os.path.join(self.plugin_dir, 'i18n', 'geopunt4qgis_{}.qm'.format(locale))
        if os.path.exists(localePath):
            self.translator = QTranslator()
            self.translator.load(localePath)
            QCoreApplication.installTranslator(self.translator)

        #version check
        if locale == 'nl':  
           vc = versionChecker()
           if not vc.isUptoDate():
              QMessageBox.warning(self.iface.mainWindow(), QCoreApplication.translate("geopunt4Qgis", "Waarschuwing"), QCoreApplication.translate("geopunt4Qgis", 
          "Je versie van <a href='http://plugins.qgis.org/plugins/geopunt4Qgis' >geopunt4qgis</a> is niet meer up to date. <br/>Je kunt deze upgraden via het menu:<br/> "+
          "<strong>Plugins > Beheer en installeer Plugins > Op te waarderen.</strong><br/>Klik daarna op <strong>Plugin opwaarderen</strong>"))

        # Create the dialogs (after translation) and keep reference
        self.adresdlg = geopunt4QgisAdresDialog(self.iface)
        self.batchgeoDlg = geopunt4QgisBatcGeoCodeDialog(self.iface) 
        self.poiDlg = geopunt4QgisPoidialog(self.iface)        
        self.gipodDlg = geopunt4QgisGipodDialog(self.iface)
        self.settingsDlg = geopunt4QgisSettingsDialog()
        if mathplotlibWorks : self.elevationDlg = geopunt4QgisElevationDialog(self.iface)
        self.datacatalogusDlg = geopunt4QgisDataCatalog(self.iface)
        self.parcelDlg = geopunt4QgisParcelDlg(self.iface)
        self.aboutDlg = geopunt4QgisAboutDialog()

    def copy_layer_settings(self, source_layer, target_layer):
        # copy filter

        if target_layer.type() == QgsVectorLayer:
            target_layer.setSubsetString(source_layer.subsetString())

        # copy symbology
        error = ""
        doc = QDomDocument()
        node = doc.createElement("symbology")
        doc.appendChild(node)
        source_layer.writeSymbology(node, doc, error,  QgsReadWriteContext())

        if not error:
            target_layer.readSymbology(node, error,  QgsReadWriteContext())
        if error:
            QMessageBox.warning(None, "Could not copy symbology", error)

        # copy scale based visibility
        try:
            target_layer.setScaleBasedVisibility(source_layer.hasScaleBasedVisibility())
        except:
            # Fall back to the deprecated function
            target_layer.toggleScaleBasedVisibility(source_layer.hasScaleBasedVisibility())
        target_layer.setMinimumScale(source_layer.minimumScale())
        target_layer.setMaximumScale(source_layer.maximumScale())

        #copy CRS
        target_layer.setCrs(source_layer.crs(), False)

    def check_layers(self):
        local_layers, unsupported_layers,  local_raster_layers = self.update_local_layers()
        
        
        if ((local_layers or local_raster_layers) and self.clouddb) or unsupported_layers:
            message = ""

            if local_layers or local_raster_layers:
                title = self.tr("Local layers found")
                message += self.tr(
                    "Some layers are using local data. Please upload local layers to your cloud database in the 'Upload Data' tab before publishing.\n\n")

            if unsupported_layers:
                title = self.tr("Unsupported layers found")
                message += self.tr(
                    "Raster, plugin or geometryless layers are not supported:\n\n")
                layer_types = ["No geometry", "Raster", "Plugin"]
                for layer in sorted(unsupported_layers, key=lambda layer: layer.name()):
                    message += self.tr("  -  %s (%s)\n") % (
                        layer.name(), layer_types[layer.type()])
                message += self.tr(
                    "\nPlease remove or replace above layers before publishing your map.\n")
                message += self.tr(
                    "For raster data you can use public WMS layers or the OpenLayers Plugin.")

            QMessageBox.warning(self, title, message)

            self.refresh_databases()
            self.ui.tabWidget.setCurrentWidget(self.ui.uploadTab)
            return False

        return True

 def create_database(self):
     if self.numDbs < self.maxDBs:
         db = self.api.create_database()
         self.show_api_error(db)
         self.refresh_databases()
     else:
         QMessageBox.warning(None, self.tr('Warning!'),  self.tr('Number of %s permitted databases exceeded! Please upgrade your account!') % self.maxDBs)

 def check_existing_id(self, group_id):
     gl = GroupsList()
     if group_id in gl.groups.keys():
         QMessageBox.critical(self, self.tr('Error on save group'),
                              self.tr('Group with such id already exists! Select new id for group!'))
         return False
     return True

 def accept(self):
     try:
         self.setParamValues()
         msg = self.alg._checkParameterValuesBeforeExecuting()
         if msg:
             QMessageBox.warning(
                 self, self.tr('Unable to execute algorithm'), msg)
             return
         description = algAsDict(self.alg)
         description["name"] = self.settingsPanel.txtName.text().strip()
         description["group"] = self.settingsPanel.txtGroup.text().strip()
         if not (description["name"] and description["group"]):
             self.tabWidget.setCurrentIndex(self.tabWidget.count() - 1)
             return
         validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
         filename = ''.join(c for c in description["name"] if c in validChars).lower() + ".json"
         filepath = os.path.join(preconfiguredAlgorithmsFolder(), filename)
         with open(filepath, "w") as f:
             json.dump(description, f)
         algList.reloadProvider('preconfigured')
     except AlgorithmDialogBase.InvalidParameterValue as e:
         try:
             self.buttonBox.accepted.connect(lambda:
                                             e.widget.setPalette(QPalette()))
             palette = e.widget.palette()
             palette.setColor(QPalette.Base, QColor(255, 255, 0))
             e.widget.setPalette(palette)
             self.lblProgress.setText(
                 self.tr('<b>Missing parameter value: %s</b>') % e.parameter.description)
             return
         except:
             QMessageBox.critical(self,
                                  self.tr('Unable to execute algorithm'),
                                  self.tr('Wrong or missing parameter values'))
     self.close()

    def exportTxt(self):
        delimiter = self.__getDelimiter()
        decimalDelimiter = self.__getDecimalDelimiter()
        if delimiter == decimalDelimiter:
            msg = QApplication.translate("code", "Gleiches Dezimal- und Spaltentrennzeichen gewählt!")
            QMessageBox.warning(self.iface.mainWindow(), "VoGIS-Profiltool", msg)
            return

        u = Util(self.iface)
        caption = QApplication.translate("code", "Textdatei exportieren")
        fileName, file_ext = u.getFileName(caption, [["txt", "txt"]], self.filePath)
        if fileName == "":
            return
        fInfo = QFileInfo(fileName)
        self.filePath = fInfo.path()
        QgsSettings().setValue("vogisprofiltoolmain/savepath", self.filePath)
        hekto = (self.ui.IDC_chkHekto.checkState() == Qt.Checked)
        attribs = (self.ui.IDC_chkLineAttributes.checkState() == Qt.Checked)
        txt = open(fileName, "w")

        txt.write(self.profiles[0].writeHeader(self.settings.mapData.rasters.selectedRasters(), hekto, attribs, delimiter))
        for p in self.profiles:
            #txt.write("=====Profil {0}======{1}".format(p.id, os.linesep))
            #txt.write("Segments:{0}{1}".format(len(p.segments), os.linesep))
            #for s in p.segments:
            #    txt.write("Vertices:{0}{1}".format(len(s.vertices), os.linesep))
            txt.write(p.toString(hekto,
                                 attribs,
                                 delimiter,
                                 decimalDelimiter
                                 ))
        txt.close()

    def setParamValues(self):
        if self.mUpdateExistingGroupBox.isChecked():
            fieldName = self.mExistingFieldComboBox.currentText()
        else:
            fieldName = self.mOutputFieldNameLineEdit.text()

        layer = dataobjects.getObjectFromName(self.cmbInputLayer.currentText())

        self.alg.setParameterValue('INPUT_LAYER', layer)
        self.alg.setParameterValue('FIELD_NAME', fieldName)
        self.alg.setParameterValue('FIELD_TYPE',
                                   self.mOutputFieldTypeComboBox.currentIndex())
        self.alg.setParameterValue('FIELD_LENGTH',
                                   self.mOutputFieldWidthSpinBox.value())
        self.alg.setParameterValue('FIELD_PRECISION',
                                   self.mOutputFieldPrecisionSpinBox.value())
        self.alg.setParameterValue('NEW_FIELD',
                                   self.mNewFieldGroupBox.isChecked())
        self.alg.setParameterValue('FORMULA', self.builder.expressionText())
        self.alg.setOutputValue('OUTPUT_LAYER', self.leOutputFile.text().strip() or None)

        msg = self.alg.checkParameterValuesBeforeExecuting()
        if msg:
            QMessageBox.warning(
                self, self.tr('Unable to execute algorithm'), msg)
            return False
        return True

    def addToLayout(self):
        mgr = QgsProject.instance().layoutManager()
        layout = None
        layouts = mgr.layouts()
        if len(layouts) == 0:
            QMessageBox.warning(self,
                                QApplication.translate("code", "Keine Layouts"),
                                QApplication.translate("code", "Zuerst ein Layout erstellen"))
            return
        elif len(layouts) == 1:
            layout = layouts[0]
        else:
            d = VoGISProfilToolLayoutsDialog(self, layouts)
            result = d.exec_()
            if result == QDialog.Accepted:
                layout = mgr.layoutByName(d.ui.cmbLayouts.currentText())
            else:
                return

        u = Util(self.iface)
        caption = QApplication.translate("code", "PNG Datei")
        file_format = []
        file_format.append(["PNG files", "png"])
        fileName, fileExt = u.getFileName(caption, file_format, QgsProject.instance().homePath())
        if fileName == "":
            return
        fInfo = QFileInfo(fileName)
        self.filePath = fInfo.path()
        figure = self.subplot.figure
        figure.savefig(fileName, format="png")

        image = QgsLayoutItemPicture(layout)
        image.setPicturePath(fileName)
        image.attemptResize(QgsLayoutSize(200, 200))
        layout.addLayoutItem(image)

 def saveMessages(self):
     """
     Saves each KLIC message using pickle in textfile in a folder KLIC
     next to Quantum GIS projectfile. Save also reference to this
     pickled object in project file itself.
     """
     l_project = QgsProject.instance()
     l_project_file = str(l_project.fileName())
     l_title = self.tr("Opslaan in project")
     if l_project_file == "":
         l_msg = self.tr("Nog niet opgeslagen als project!\nKies Bestand - Project opslaan...")
         QMessageBox.warning(self, l_title, l_msg)
     else:
         # save the project setting 'b4udignl' 'wv_docs_file' in project.
         # first it is added to the project object
         l_wvs_file = l_project_file.replace(".qgs", "_wv_docs.txt")
         l_wvs_file_name = os.path.basename(l_wvs_file)
         # write project setting
         l_project.writeEntry('b4udignl', 'wv_docs_file', l_wvs_file_name)
         l_file = open(l_wvs_file, 'w')
         l_wv_docs = self.docsToPickle()
         # use pickle to write a textfile holding object instance
         # that can be recreated.
         pickle.dump(l_wv_docs, l_file)
         # save the project immediately, this should be done otherwise
         # the project setting 'wv_docs_file' could be missing when
         # user decides upon leaving the project to Discard the changes.
         # Adding the project setting was considered a project change.
         l_action = self.__iface.actionSaveProject()
         # activate(0) triggers the action save project!
         l_action.activate(0)
         # inform the user that changes have been included in project.
         l_msg = self.tr("KLIC berichten opgeslagen in project")
         QMessageBox.warning(self, l_title, l_msg)

 def checkPdokJson(self):
     myversion = self.getSettingsValue('pdokversion', '1')
     msgtxt = ''
     msglvl = 0  # QgsMessageBar.INFO
     try:
         response = urllib.request.urlopen('http://www.qgis.nl/pdok.version')
         str_response = response.read().decode('utf-8')
         pdokversion = json.loads(str_response)
         if pdokversion > int(myversion):
             response = urllib.request.urlopen('http://www.qgis.nl/pdok.json')
             str_response = response.read().decode('utf-8')
             pdokjson = json.loads(str_response)
             with open(self.plugin_dir +'/pdok.json', 'w') as outfile:
                 json.dump(pdokjson, outfile)
             msgtxt = "De laatste versie is opgehaald en zal worden gebruikt " + \
                 str(pdokversion) + ' (was ' + myversion +')'
             self.servicesLoaded = False # reset reading of json
             self.run()
             self.setSettingsValue('pdokversion', pdokversion)
         else:
             msgtxt = "Geen nieuwere versie beschikbaar dan " + str(pdokversion)
     except Exception as e:
         #print e
         msgtxt = "Fout bij ophalen van service info. Netwerk probleem?"
         msglvl = 2 # QgsMessageBar.CRITICAL
     # msg
     if hasattr(self.iface, 'messageBar'):
         self.iface.messageBar().pushMessage("PDOK services update", msgtxt, level=msglvl, duration=10)
     else: # 1.8
         QMessageBox.information(self.iface.mainWindow(), "Pdok Services Plugin", msgtxt)

 def calculateKappa(self):
     currentLayer = self.iface.mapCanvas().currentLayer()
     if currentLayer:
         d = CalculateKappaAndConvergenceDialog(self.iface)
         d.exec_()
     else:
         QMessageBox.warning(self.iface.mainWindow(), self.tr("Warning!"), self.tr("Please, open a layer and select a line or polygon feature."))

    def openModel(self):
        filename = unicode(QFileDialog.getOpenFileName(self,
                                                       self.tr('Open Model'), ModelerUtils.modelsFolder(),
                                                       self.tr('Processing models (*.model *.MODEL)')))
        if filename:
            try:
                alg = ModelerAlgorithm.fromFile(filename)
                self.alg = alg
                self.alg.setModelerView(self)
                self.textGroup.setText(alg.group)
                self.textName.setText(alg.name)
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            except WrongModelException as e:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       self.tr('Could not load model %s\n%s') % (filename, e.msg))
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
            except Exception as e:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       self.tr('Could not load model %s\n%s') % (filename, e.args[0]))
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))