def getVectorWriter(self, fields, geomType, crs, options=None):
        """Returns a suitable writer to which features can be added as
        a result of the algorithm. Use this to transparently handle
        output values instead of creating your own method.

        Executing this method might modify the object, adding additional
        information to it, so the writer can be later accessed and
        processed within QGIS. It should be called just once, since a
        new call might result in previous data being replaced, thus
        rendering a previously obtained writer useless.

        @param fields   a list  of QgsField
        @param geomType a suitable geometry type, as it would be passed
                        to a QgsVectorFileWriter constructor
        @param crs      the crs of the layer to create

        @return writer  instance of the vector writer class
        """

        if self.encoding is None:
            settings = QSettings()
            self.encoding = settings.value('/Processing/encoding', 'System', str)

        w = VectorWriter(self.value, self.encoding, fields, geomType,
                         crs, options)
        self.layer = w.layer
        self.value = w.destination
        return w

    def canvasReleaseEvent(self, e):
        point = self.plugin.transform(
            self.iface.mapCanvas().getCoordinateTransform().toMapCoordinates(e.x(), e.y())
        )

        QApplication.setOverrideCursor(Qt.WaitCursor)

        fs = self.plugin.highlight(
            where=u"st_contains(wkb_geometry,st_geomfromtext('POINT(%.3lf %.3lf)'::text,%d))" % (
                point.x(), point.y(), self.plugin.getepsg()
            )
        )

        if len(fs) == 0:
            QApplication.restoreOverrideCursor()
            QMessageBox.information(None, u"Fehler", u"Kein Flurstück gefunden.")
            return

        try:
            s = QSettings("norBIT", "EDBSgen/PRO")
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.connect(("localhost", int(s.value("norGISPort", "6102"))))
            sock.send("NORGIS_MAIN#EDBS#ALBKEY#{}#".format(fs[0]['flsnr']).encode("utf-8"))
            sock.close()

            if win32:
                window = win32gui.FindWindow(None, s.value("albWin", "norGIS"))
                win32gui.SetForegroundWindow(window)
        except socket.error:
            QMessageBox.information(None, u"Fehler", u"Verbindung zu norGIS schlug fehl.")

        QApplication.restoreOverrideCursor()

    def showFileSelectionDialog(self):
        settings = QSettings()
        text = str(self.text.text())
        if os.path.isdir(text):
            path = text
        elif os.path.isdir(os.path.dirname(text)):
            path = os.path.dirname(text)
        elif settings.contains('/Processing/LastInputPath'):
            path = str(settings.value('/Processing/LastInputPath'))
        else:
            path = ''

        ret, selected_filter = QFileDialog.getOpenFileNames(self, self.tr('Open file'), path,
                                                            self.tr('All files(*.*);;') + self.param.getFileFilter())
        if ret:
            files = list(ret)
            settings.setValue('/Processing/LastInputPath',
                              os.path.dirname(str(files[0])))
            for i, filename in enumerate(files):
                files[i] = dataobjects.getRasterSublayer(filename, self.param)
            if len(files) == 1:
                self.text.setText(files[0])
                self.textEditingFinished()
            else:
                if isinstance(self.param, ParameterMultipleInput):
                    self.text.setText(';'.join(str(f) for f in files))
                else:
                    rowdif = len(files) - (self._table().rowCount() - self.row)
                    for i in range(rowdif):
                        self._panel().addRow()
                    for i, f in enumerate(files):
                        self._table().cellWidget(i + self.row,
                                                 self.col).setValue(f)

    def initGui(self):
        layout = QVBoxLayout()
        self.tab = QTabWidget()
        self.table = QTableView()

        self.setLayout(layout)
        self.canvas = QgsMapCanvas()
        self.canvas.setCanvasColor(Qt.white)
        settings = QSettings()
        self.canvas.enableAntiAliasing(settings.value("/qgis/enable_anti_aliasing", False, type = bool))
        self.canvas.useImageToRender(settings.value("/qgis/use_qimage_to_render", False, type = bool))
        self.canvas.mapSettings().setDestinationCrs(self.crs)
        action = settings.value("/qgis/wheel_action", 0, type = float)
        zoomFactor = settings.value("/qgis/zoom_factor", 2, type = float)
        self.canvas.setWheelAction(QgsMapCanvas.WheelAction(action), zoomFactor)
        self.panTool = QgsMapToolPan(self.canvas)
        self.canvas.setMapTool(self.panTool)

        execute(self.createLayers)

        model = GeomDiffTableModel(self.data)
        self.table.setModel(model)
        self.table.resizeColumnsToContents()
        self.table.resizeRowsToContents()
        self.tab.addTab(self.canvas, "Map view")
        self.tab.addTab(self.table, "Table view")
        layout.addWidget(self.tab)

        self.resize(600, 500)
        self.setWindowTitle("Geometry comparison")

def main():
    datestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    if QT5:
        ini_out_dir = QStandardPaths.writableLocation(QStandardPaths.DesktopLocation)
    else:
        ini_out_dir = QDesktopServices.storageLocation(QDesktopServices.DesktopLocation)
    ini_name = 'org.qgis.{0}-settings_{1}.ini'.format(QGIS_APP_NAME, datestamp)
    ini_out = QDir(ini_out_dir).absoluteFilePath(ini_name)

    if not os.path.exists(ini_out_dir):
        print('INI output directory does not exist: {0}'.format(ini_out_dir))
        return

    if not os.access(ini_out_dir, os.W_OK | os.X_OK):
        print('INI output directory is not writeable: {0}'.format(ini_out_dir))
        return

    # QGIS settings
    if HAS_QGSSETTINGS:
        qgis_settings = QgsSettings()
    else:
        qgis_settings = QSettings()

    # Output INI settings
    ini_settings = QSettings(ini_out, QSettings.IniFormat)

    qgis_keys = qgis_settings.allKeys()
    for k in qgis_keys:
        ini_settings.setValue(k, qgis_settings.value(k))

    ini_settings.sync()

    print("Settings output to: {0}".format(QDir.toNativeSeparators(ini_out)))

 def export(self):
     """ Export the results to a CSV file """
     
     # Remember the last location in which we saved
     settings = QSettings()
     lastFolder = str(settings.value("constraintchecker/lastSaveFolder", os.sep))
     
     outFileName, ext_selector = QFileDialog.getSaveFileName(self, 'Save Query Results', lastFolder,
                                                   'Comma Separated Variable Files (*.csv)')
     
     # Store the path we just looked in
     head, tail = os.path.split(outFileName)
     if head != os.sep and head.lower() != 'c:\\' and head != '':
         settings.setValue("constraintchecker/lastSaveFolder", head)
     
     if len(outFileName) == 0:
         # User hit cancel
         return
     
     # Export the file
     try:
         csvfile = open(outFileName+'.csv', 'w')
     except:
         msg = 'Failed to open %s for writing - perhaps it is open in another application?' % outFileName
         QMessageBox.critical(self, 'Failed to Open File', msg)
         return
     
     resWriter = csv.writer(csvfile)
     resWriter.writerow(self.resultModel.headerNames)
     for i in range(self.resultModel.rowCount()):
         resWriter.writerow(self.resultModel.fetchRow(i))
     csvfile.close()

    def load_directories(self):
        """Load directories of repository registered in settings."""
        self._directories = {}
        settings = QSettings()
        settings.beginGroup(repo_settings_group())

        # Write online directory first to QSettings if needed
        for online_dir_name in self._online_directories:
            repo_present = False
            for repo_name in settings.childGroups():
                url = settings.value(repo_name + '/url', '', type=unicode)
                if url == self._online_directories[online_dir_name]:
                    repo_present = True
                    break
            if not repo_present:
                self.add_directory(
                    online_dir_name, self._online_directories[online_dir_name])

        for repo_name in settings.childGroups():
            self._directories[repo_name] = {}
            url = settings.value(
                repo_name + '/url', '', type=unicode)
            self._directories[repo_name]['url'] = url
            auth_cfg = settings.value(
                repo_name + '/auth_cfg', '', type=unicode).strip()
            self._directories[repo_name]['auth_cfg'] = auth_cfg
        settings.endGroup()

    def execute(self):
        settings = QSettings()
        lastDir = settings.value('Processing/lastModelsDir', '')
        filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
                                                                self.tr('Open model', 'AddModelFromFileAction'), lastDir,
                                                                self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
        if filename:
            try:
                settings.setValue('Processing/lastModelsDir',
                                  QFileInfo(filename).absoluteDir().absolutePath())

                ModelerAlgorithm.fromFile(filename)
            except WrongModelException:
                QMessageBox.warning(
                    self.toolbox,
                    self.tr('Error reading model', 'AddModelFromFileAction'),
                    self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
                return
            except:
                QMessageBox.warning(self.toolbox,
                                    self.tr('Error reading model', 'AddModelFromFileAction'),
                                    self.tr('Cannot read file', 'AddModelFromFileAction'))
                return
            destFilename = os.path.join(ModelerUtils.modelsFolders()[0], os.path.basename(filename))
            shutil.copyfile(filename, destFilename)
            algList.reloadProvider('model')

    def processAlgorithm(self, progress):
        connection = self.getParameterValue(self.DATABASE)
        settings = QSettings()
        mySettings = '/PostgreSQL/connections/' + connection
        try:
            database = settings.value(mySettings + '/database')
            username = settings.value(mySettings + '/username')
            host = settings.value(mySettings + '/host')
            port = settings.value(mySettings + '/port', type=int)
            password = settings.value(mySettings + '/password')
        except Exception as e:
            raise GeoAlgorithmExecutionException(
                self.tr('Wrong database connection name: %s' % connection))
        try:
            self.db = postgis_utils.GeoDB(host=host, port=port,
                                          dbname=database, user=username, passwd=password)
        except postgis_utils.DbError as e:
            raise GeoAlgorithmExecutionException(
                self.tr("Couldn't connect to database:\n%s") % unicode(e))

        sql = self.getParameterValue(self.SQL).replace('\n', ' ')
        try:
            self.db._exec_sql_and_commit(unicode(sql))
        except postgis_utils.DbError as e:
            raise GeoAlgorithmExecutionException(
                self.tr('Error executing SQL:\n%s') % unicode(e))

    def processAlgorithm(self, progress):
        """Here is where the processing itself takes place."""

        # The first thing to do is retrieve the values of the parameters
        # entered by the user
        inputFilename = self.getParameterValue(self.INPUT_LAYER)
        output = self.getOutputValue(self.OUTPUT_LAYER)

        # Input layers vales are always a string with its location.
        # That string can be converted into a QGIS object (a
        # QgsVectorLayer in this case) using the
        # processing.getObjectFromUri() method.
        vectorLayer = dataobjects.getObjectFromUri(inputFilename)

        # And now we can process

        # First we create the output layer. The output value entered by
        # the user is a string containing a filename, so we can use it
        # directly
        settings = QSettings()
        systemEncoding = settings.value('/UI/encoding', 'System')
        writer = QgsVectorFileWriter(output,
                                     systemEncoding,
                                     vectorLayer.fields(),
                                     vectorLayer.wkbType(),
                                     vectorLayer.crs())

        # Now we take the features from input layer and add them to the
        # output. Method features() returns an iterator, considering the
        # selection that might exist in layer and the configuration that
        # indicates should algorithm use only selected features or all
        # of them
        features = vector.features(vectorLayer)
        for f in features:
            writer.addFeature(f)

 def read(self):
     qsettings = QSettings()
     value = qsettings.value(self.qname, None)
     if value is not None:
         if isinstance(self.value, bool):
             value = str(value).lower() == str(True).lower()
         self.value = value

    def showSelectionDialog(self):
        if isinstance(self.output, OutputDirectory):
            self.selectDirectory()
            return

        filefilter = self.output.getFileFilter(self.alg)
        settings = QSettings()
        if settings.contains('/Processing/LastBatchOutputPath'):
            path = str(settings.value('/Processing/LastBatchOutputPath'))
        else:
            path = ''
        filename, selectedFileFilter = QFileDialog.getSaveFileName(self,
                                                                   self.tr('Save file'), path, filefilter)
        if filename:
            if not filename.lower().endswith(
                    tuple(re.findall("\*(\.[a-z]{1,10})", filefilter))):
                ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
                if ext:
                    filename += ext.group(1)
            settings.setValue('/Processing/LastBatchOutputPath', os.path.dirname(filename))
            dlg = AutofillDialog(self.alg)
            dlg.exec_()
            if dlg.mode is not None:
                try:
                    if dlg.mode == AutofillDialog.DO_NOT_AUTOFILL:
                        self.table.cellWidget(self.row,
                                              self.col).setValue(filename)
                    elif dlg.mode == AutofillDialog.FILL_WITH_NUMBERS:
                        n = self.table.rowCount() - self.row
                        for i in range(n):
                            name = filename[:filename.rfind('.')] \
                                + str(i + 1) + filename[filename.rfind('.'):]
                            self.table.cellWidget(i + self.row,
                                                  self.col).setValue(name)
                    elif dlg.mode == AutofillDialog.FILL_WITH_PARAMETER:
                        n = self.table.rowCount() - self.row
                        for i in range(n):
                            widget = self.table.cellWidget(i + self.row,
                                                           dlg.param)
                            param = self.alg.parameters[dlg.param]
                            if isinstance(param, (ParameterRaster,
                                                  ParameterVector, ParameterTable,
                                                  ParameterMultipleInput)):
                                s = str(widget.getText())
                                s = os.path.basename(s)
                                s = os.path.splitext(s)[0]
                            elif isinstance(param, ParameterBoolean):
                                s = str(widget.currentIndex() == 0)
                            elif isinstance(param, ParameterSelection):
                                s = str(widget.currentText())
                            elif isinstance(param, ParameterFixedTable):
                                s = str(widget.table)
                            else:
                                s = str(widget.text())
                            name = filename[:filename.rfind('.')] + s \
                                + filename[filename.rfind('.'):]
                            self.table.cellWidget(i + self.row,
                                                  self.col).setValue(name)
                except:
                    pass

    def chooseOutputFile(self):
        # get last used dir
        settings = QSettings()
        lastUsedDir = settings.value(self.lastUsedVectorDirSettingsKey, ".")

        # get selected filter
        selectedFilter = self.cboFileFormat.itemData(self.cboFileFormat.currentIndex())

        # ask for a filename
        filename, filter = QFileDialog.getSaveFileName(self, self.tr("Choose where to save the file"), lastUsedDir,
                                                       selectedFilter)
        if filename == "":
            return

        filterString = QgsVectorFileWriter.filterForDriver(selectedFilter)
        ext = filterString[filterString.find('.'):]
        ext = ext[:ext.find(' ')]

        if not filename.lower().endswith(ext):
            filename += ext

        # store the last used dir
        settings.setValue(self.lastUsedVectorDirSettingsKey, QFileInfo(filename).filePath())

        self.editOutputFile.setText(filename)

    def __init__(self, repo, path):
        super(VersionViewerDialog, self).__init__(config.iface.mainWindow(), Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
        self.repo = repo
        self.path = path
        self.setupUi(self)

        self.listWidget.itemClicked.connect(self.commitClicked)

        settings = QSettings()
        horizontalLayout = QHBoxLayout()
        horizontalLayout.setSpacing(0)
        horizontalLayout.setMargin(0)
        self.mapCanvas = QgsMapCanvas()
        self.mapCanvas.setCanvasColor(Qt.white)
        self.mapCanvas.enableAntiAliasing(settings.value("/qgis/enable_anti_aliasing", False, type = bool))
        self.mapCanvas.useImageToRender(settings.value("/qgis/use_qimage_to_render", False, type = bool))
        action = settings.value("/qgis/wheel_action", 0, type = float)
        zoomFactor = settings.value("/qgis/zoom_factor", 2, type = float)
        self.mapCanvas.setWheelAction(QgsMapCanvas.WheelAction(action), zoomFactor)
        horizontalLayout.addWidget(self.mapCanvas)
        self.mapWidget.setLayout(horizontalLayout)
        self.panTool = QgsMapToolPan(self.mapCanvas)
        self.mapCanvas.setMapTool(self.panTool)

        versions = repo.log(path = path)
        if versions:
            for commit in versions:
                item = CommitListItem(commit, repo, path)
                self.listWidget.addItem(item)
                ''''w = CommitListItemWidget(commit)
                self.ui.listWidget.setItemWidget(item, w)'''
        else:
            raise GeoGigException("The selected feature is not versioned yet")

def qgisLocale():
    settings = QSettings();
    overrideLocale = settings.value("locale/overrideFlag", False, bool)
    if overrideLocale:
        return settings.value("locale/userLocale", "")
    else:
        return QLocale.system().name()[:2]

 def initGui(self):
     #Models
     self.tblChanges.setModel( ChangeModel() )
     proxyChanges = HistoryProxyModel()
     proxyChanges.setSourceModel( HistoryModel() )
     self.tblHistory.setModel( proxyChanges )
     #Signals
     self.plugin.tvIdentificationResult.model().sourceModel().on_history.connect( self.historyChanged )
     self.tblHistory.selectionModel().currentChanged.connect( self.currentHistoryChanged )
     #Widgets
     settings = QSettings()
     self.mapCanvas = QgsMapCanvas(self.vSplitter)
     self.mapCanvas.setDestinationCrs( QgsCoordinateReferenceSystem('EPSG:4326') )
     zoomFactor = settings.value( "/qgis/zoom_factor", 2.0, type=float )
     action = settings.value( "/qgis/wheel_action", 0, type=int)
     self.mapCanvas.setWheelFactor( zoomFactor )
     self.mapCanvas.enableAntiAliasing( settings.value( "/qgis/enable_anti_aliasing", False, type=bool ))
     #self.mapCanvas.useImageToRender( settings.value( "/qgis/use_qimage_to_render", False, type=bool ))
     self.toolPan = QgsMapToolPan( self.mapCanvas )
     self.mapCanvas.setMapTool( self.toolPan )
     #Canvas items
     self.new_geometry = QgsRubberBand(self.mapCanvas)
     self.new_geometry.setWidth(2)
     self.new_geometry.setIcon( QgsRubberBand.ICON_CIRCLE )
     g = QColor(0, 128, 0, 100)
     self.new_geometry.setColor( g )
     self.old_geometry = QgsRubberBand(self.mapCanvas)
     self.old_geometry.setWidth(2)
     self.old_geometry.setIcon( QgsRubberBand.ICON_CIRCLE )
     r = QColor(255, 0, 0, 100)
     self.old_geometry.setColor( r )

 def browse(self):
     settings = QSettings()
     key = '/UI/lastShapefileDir'
     outDir = settings.value(key)
     home = outDir
     #outDir = expanduser("~")
     #filter = (self.DEFAULTPROVIDER + " (*" +
     #             self.DEFAULTEXTENSION + ");;All files (*)")
     filter = (self.DEFAULTPROVIDER + " (*" +
                  self.DEFAULTEXTENSION + self.EXTRAEXTENSION + ")")
     #if (self.gdalprovider != self.DEFAULTPROVIDER and
     #                                     (self.canCreateCopy or
     #                                           self.canCreate)):
     #    filter = (self.gdalprovider + " (*" + self.gdalext +
     #                                          ");;" + filter)
     outFilePath = QFileDialog.getSaveFileName(self,
                                'Specify file name for skeleton',
                                                  outDir, filter)
     outFilePath = unicode(outFilePath)
     if outFilePath:
         root, ext = splitext(outFilePath)
         if ext.lower() != '.tif' and ext.lower() != '.tiff':
             outFilePath = '%s.tif' % outFilePath
         outDir = dirname(outFilePath)
         settings.setValue(key, outDir)
     #        (self.canCreateCopy or self.canCreate):
     #    fileName = splitext(str(fileName))[0]+self.gdalext
     self.outputRaster.setText(outFilePath)

    def save_state(self):
        """Store current state of GUI to configuration file.

        .. versionadded: 3.3
        """
        settings = QSettings()
        settings.setValue('directory', self.output_directory.text())

def exportVectorLayer(layer, supported=None):
    """Takes a QgsVectorLayer and returns the filename to refer to it,
    which allows external apps which support only file-based layers to
    use it. It performs the necessary export in case the input layer
    is not in a standard format suitable for most applications, it is
    a remote one or db-based (non-file based) one, or if there is a
    selection and it should be used, exporting just the selected
    features.

    Currently, the output is restricted to shapefiles, so anything
    that is not in a shapefile will get exported. It also export to
    a new file if the original one contains non-ascii characters.
    """

    supported = supported or ["shp"]
    settings = QSettings()
    systemEncoding = settings.value('/UI/encoding', 'System')

    filename = os.path.basename(unicode(layer.source()))
    idx = filename.rfind('.')
    if idx != -1:
        filename = filename[:idx]

    filename = unicode(layer.name())
    validChars = \
        'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
    filename = ''.join(c for c in filename if c in validChars)
    if len(filename) == 0:
        filename = 'layer'
    output = getTempFilenameInTempFolder(filename + '.shp')
    provider = layer.dataProvider()
    useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
    if useSelection and layer.selectedFeatureCount() != 0:
        writer = QgsVectorFileWriter(output, systemEncoding,
                                     layer.pendingFields(),
                                     provider.geometryType(), layer.crs())
        selection = layer.selectedFeatures()
        for feat in selection:
            writer.addFeature(feat)
        del writer
        return output
    else:
        isASCII = True
        try:
            unicode(layer.source()).decode('ascii')
        except UnicodeEncodeError:
            isASCII = False
        if not os.path.splitext()[1].lower() in supported or not isASCII:
            writer = QgsVectorFileWriter(
                output, systemEncoding,
                layer.pendingFields(), provider.geometryType(),
                layer.crs()
            )
            for feat in layer.getFeatures():
                writer.addFeature(feat)
            del writer
            return output
        else:
            return unicode(layer.source())

 def updateSeenPluginsList(self):
     """ update the list of all seen plugins """
     settings = QSettings()
     seenPlugins = settings.value(seenPluginGroup, self.mPlugins.keys(), type=unicode)
     for i in self.mPlugins.keys():
         if seenPlugins.count(i) == 0:
             seenPlugins += [i]
     settings.setValue(seenPluginGroup, seenPlugins)