def loadLayerTable(self, carhabLayer, tableName):

        # Retrieve layer from provider.
        uri = QgsDataSourceURI()
        uri.setDatabase(carhabLayer.dbPath)

        schema = ''
        geom_column = 'the_geom'
        uri.setDataSource(schema, tableName, geom_column)

        display_name = carhabLayer.getName()+'_'+tableName

        layer = QgsVectorLayer(uri.uri(), display_name, 'spatialite')
        crsType = QgsCoordinateReferenceSystem.EpsgCrsId
        crsVal = 2154
        crs = QgsCoordinateReferenceSystem(crsVal, crsType)
        layer.setCrs(crs)

        # "Bind" layer to carhab layer.
        if self.getCarhabLayerByDbPath(carhabLayer.dbPath):
            layer.setCustomProperty('carhabLayer', carhabLayer.id)

        # Add layer to map (False to add to group)
        QgsMapLayerRegistry.instance().addMapLayer(layer, False)

        iface.mapCanvas().setExtent(layer.extent())

        return layer

 def setExpressionObj(self):
     #set expression calculator if not empty
     self.expA = dict()
     self.expB = dict()
     if bool(self.expressionLayerA) or bool(self.expressionLayerB):
         if bool(self.expressionLayerA):
             for field in self.expressionLayerA.keys():
                 tempDict = {'exp':None,'val':None}
                 tempDict['exp'] = QgsExpression(self.expressionLayerA[field])
 
                 da = QgsDistanceArea()
                 da.setSourceCrs(self.vproviderA.crs().srsid())
                 canvas = iface.mapCanvas()
                 da.setEllipsoidalMode(canvas.mapRenderer().hasCrsTransformEnabled())
                 da.setEllipsoid(QgsProject.instance().readEntry('Measure',
                                                                 '/Ellipsoid',
                                                                 GEO_NONE)[0])
                 tempDict['exp'].setGeomCalculator(da)
                 self.expA[field] = tempDict
         else:
             for field in self.expressionLayerB.keys():
                 tempDict = {'exp':None,'val':None}
                 tempDict['exp'] = QgsExpression(self.expressionLayerB[field])
 
                 da = QgsDistanceArea()
                 da.setSourceCrs(self.vproviderA.crs().srsid())
                 canvas = iface.mapCanvas()
                 da.setEllipsoidalMode(canvas.mapRenderer().hasCrsTransformEnabled())
                 da.setEllipsoid(QgsProject.instance().readEntry('Measure',
                                                                 '/Ellipsoid',
                                                                 GEO_NONE)[0])
                 tempDict['exp'].setGeomCalculator(da)
                 self.expB[self.mapBFields[field]] = tempDict

def change_color():
    active_layer = iface.activeLayer()
    renderer = active_layer.rendererV2()
    symbol = renderer.symbol()
    symbol.setColor(QColor(Qt.red))
    iface.mapCanvas().refresh()
    iface.legendInterface().refreshLayerSymbology(active_layer)

    def checkSettings(self):
        s = QSettings()

        # pixmap preview width
        self.previewWidth = s.value('TileIndexPlugin/previewWidth', 1000, type=int)

        # activate/deactivate map canvas event filter
        self.transparentFix = ( s.value('TileIndexPlugin/transparentFix', True, type=bool ) == True )

        # activate/deactivate map canvas event filter
        if s.value('TileIndexPlugin/contextMenu', True, type=bool):
            if not self.filterActive:
                iface.mapCanvas().installEventFilter(self) 
                self.filterActive = True
        else:
            if self.filterActive:
                iface.mapCanvas().removeEventFilter(self) 
                self.filterActive = False

        # which attribute(s) should we look for to get raster file names?
        self.locationAttr=['location']
        if s.value('TileIndexPlugin/attribute', False, type=bool):
            # TODO change this
            attr=s.value('TileIndexPlugin/attributeStr', '', type=str).split(' ') #,QString.SkipEmptyParts)
            for a in attr:
                self.locationAttr.append(a)

    def processAlgorithm(self, feedback):
        fileName = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(fileName)
        crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))

        provider = layer.dataProvider()
        ds = provider.dataSourceUri()
        p = re.compile("\|.*")
        dsPath = p.sub("", ds)

        if dsPath.lower().endswith(".shp"):
            dsPath = dsPath[:-4]

        wkt = crs.toWkt()
        with open(dsPath + ".prj", "w") as f:
            f.write(wkt)

        qpjFile = dsPath + ".qpj"
        if os.path.exists(qpjFile):
            with open(qpjFile, "w") as f:
                f.write(wkt)

        layer.setCrs(crs)
        iface.mapCanvas().refresh()

        self.setOutputValue(self.OUTPUT, fileName)

def db_view_change_style():  
        in_file =open(os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/setting.sty', 'r')     
        for line in in_file:
           if line[:4]=="att:":            
            dirstili=line.split (":",2)[2].replace("\n","")
            if(os.path.exists(dirstili) ==False):
                dirstili=  os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/QML_Default'
            
        in_file.close()
        layers = iface.legendInterface().layers()
        for layer in layers:
          if layer.name() == "Particelle":
            layer.loadNamedStyle(dirstili+'/part.qml')
          elif layer.name() == "Fabbricati":
            layer.loadNamedStyle(dirstili+'/fab.qml') 
          elif layer.name() == "Strade":
            layer.loadNamedStyle(dirstili+'/strade.qml')
          elif layer.name() == "Confine":
            layer.loadNamedStyle(dirstili+'/conf.qml')        
          elif layer.name() == "Acque":           
            layer.loadNamedStyle(dirstili+'/acque.qml')
          elif layer.name() == "Linee":
            layer.loadNamedStyle(dirstili+'/linee.qml')
          elif layer.name() == "Simboli":         
            layer.loadNamedStyle(dirstili+'/Simboli.qml')
          elif layer.name() == "Testi":         
            layer.loadNamedStyle(dirstili+'/testo.qml')
          elif layer.name() == "Fiduciali":
            layer.loadNamedStyle(dirstili+'/fidu.qml')  
          iface.mapCanvas().refresh()

 def picker_clicked(self):
     if iface.mapCanvas().mapTool() != self.tool:
         self.pick_mode = self.PICK_MAP
         iface.mapCanvas().setMapTool(self.tool)
         self.clear_plot()
     else:
         self.stop_picking()

    def get_bounding_box(self):
        """
        Get the geometry of the bbox in WGS84

        @rtype: QGsRectangle in WGS84
        @return: the extent of the map canvas
        """

        # If mapCanvas is checked
        if self.radioButton_extentMapCanvas.isChecked():
            geom_extent = iface.mapCanvas().extent()
            if hasattr(iface.mapCanvas(), "mapSettings"):
                source_crs = iface.mapCanvas().mapSettings().destinationCrs()
            else:
                source_crs = iface.mapCanvas().mapRenderer().destinationCrs()
        else:
            # Else if a layer is checked
            layer = self.comboBox_extentLayer.currentLayer()
            geom_extent = layer.extent()
            source_crs = layer.crs()

        geom_extent = QgsGeometry.fromRect(geom_extent)
        epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326')
        crs_transform = QgsCoordinateTransform(source_crs, epsg_4326)
        geom_extent.transform(crs_transform)
        return geom_extent.boundingBox()

    def get_bounding_box(self):
        """
        Get the geometry of the bbox in WGS84

        @rtype: QGsRectangle in WGS84
        @return: the extent of the map canvas
        """

        # If mapCanvas is checked
        if self.radioButton_extentMapCanvas.isChecked():
            geom_extent = iface.mapCanvas().extent()
            if hasattr(iface.mapCanvas(), "mapSettings"):
                source_crs = iface.mapCanvas().mapSettings().destinationCrs()
            else:
                source_crs = iface.mapCanvas().mapRenderer().destinationCrs()
        else:
            # Else if a layer is checked
            index = self.comboBox_extentLayer.currentIndex()
            layer_id = self.comboBox_extentLayer.itemData(index)
            layers = iface.legendInterface().layers()
            for layer in layers:
                if layer.id() == layer_id:
                    geom_extent = layer.extent()
                    source_crs = layer.crs()
                    break
            else:
                # the layer could be deleted before
                layer_name = self.comboBox_extentLayer.itemText(index)
                raise NoLayerException(suffix=layer_name)

        geom_extent = QgsGeometry.fromRect(geom_extent)
        epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326')
        crs_transform = QgsCoordinateTransform(source_crs, epsg_4326)
        geom_extent.transform(crs_transform)
        return geom_extent.boundingBox()

    def viewsel( self ):
        #ocon = sqlite3.connect(globals.dbName)
        ocur = globals.ocon.cursor()
        ocur.execute("select distinct Nomefile,Sel from " + globals.schema + "selezione order by Nomefile")

        lista="("
        for d in ocur:
          if d[1] == "1":
            lista+="'"+d[0]+"',"
        lista=lista[:-1]+")"

        if lista!=")": 

         lista="Nomefile IN "+lista 
         if self.ui.singolfg.isChecked() :
          lista = lista + " AND ((EXT='') or (Ext is Null))"  

          db_view_sel(self,lista)
          
        else:
         lista="Nomefile=='9999'"

        db_view_sel(self,lista)
        
        iface.mapCanvas().zoomToFullExtent()

def show_neighbors(skip):
    layer_neighbors = get_layer(LAYER_NEIGHBORS)
    layer_vols = get_layer(LAYER_VOLUMES)
    features = load_feature_dict_id(layer_neighbors)
    features_uuid = load_feature_dict_UUID(layer_vols)

    idx = 0
    for f in features.values():
        # Skip first elements.
        if idx < skip:
            idx += 1
            continue

        neighbors = f[FIELD_NEIGHBORS_UUID].split(",")
        selection = []
        for x in neighbors:
            selection.append(features_uuid[x].id())
            layer_vols.setSelectedFeatures(selection)
        box = layer_vols.boundingBoxOfSelected()
        iface.mapCanvas().setExtent(box)
        iface.mapCanvas().refresh()
        reply = QMessageBox.question(
            None, "Message", "Continue?\n (seeing feature " + str(idx) + ")", QMessageBox.No, QMessageBox.Yes
        )
        if reply == QMessageBox.No:
            break
        idx += 1

 def useLayerExtent(self):
     CANVAS_KEY = "Use canvas extent"
     extentsDict = {}
     extentsDict[CANVAS_KEY] = {
         "extent": iface.mapCanvas().extent(),
         "authid": iface.mapCanvas().mapSettings().destinationCrs().authid(),
     }
     extents = [CANVAS_KEY]
     layers = dataobjects.getAllLayers()
     for layer in layers:
         authid = layer.crs().authid()
         if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) and authid is not None:
             layerName = u"{} [{}]".format(layer.name(), authid)
         else:
             layerName = layer.name()
         extents.append(layerName)
         extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
     (item, ok) = QInputDialog.getItem(self, self.tr("Select extent"), self.tr("Use extent from"), extents, False)
     if ok:
         self.setValueFromRect(extentsDict[item]["extent"])
         if extentsDict[item]["authid"] != iface.mapCanvas().mapSettings().destinationCrs().authid():
             iface.messageBar().pushMessage(
                 self.tr("Warning"),
                 self.tr(
                     "The projection of the chosen layer is not the same as canvas projection! The selected extent might not be what was intended."
                 ),
                 QgsMessageBar.WARNING,
                 8,
             )

def filterLayer(layerName, criteria):
    lyrs = QgsMapLayerRegistry.instance().mapLayers()
    schema = ''
    for l in lyrs:
        if QgsMapLayerRegistry.instance().mapLayer(l).name() == layerName:

            desc=layers[layerName]
            uri = QgsDataSourceURI()
            uri.setDatabase(root+desc[0])
            schema = ''
            table = desc[1]
            geom_column = desc[2]

            uri.setDataSource(schema, table, geom_column, criteria)

            layer=QgsMapLayerRegistry.instance().mapLayer(l)
            print layer.dataProvider().dataSourceUri()

            layer.dataProvider().setDataSourceUri(uri.uri())
            layer.rendererV2().symbol().setAlpha(1)
            QgsMapLayerRegistry.instance().reloadAllLayers()
            layer.dataProvider().reloadData()
            layer.dataProvider().forceReload()
            layer.triggerRepaint()

            QgsMapCanvas().refresh()
            qgis.utils.iface.mapCanvas().refresh()
            iface.mapCanvas().refresh()
            #layer.setDataSource(uri.uri(),  table, geom_column)


    return

def dms (lat, lon):
    """
    Add a point at the lat and lon for the current layer using DMS notation
    """

    lat,lon = lat, lon

    l_lat = lat.upper().split()
    l_lon = lon.upper().split()

    # need to add validation tests

    if l_lat[3] == 'N':
        ddlat = float(l_lat[0])+(float(l_lat[1])/60)+float(l_lat[2])/3600
    elif l_lat[3] == 'S':
        ddlat = (float(l_lat[0])+float(l_lat[1])/60+float(l_lat[2])/3600)*-1
    else:
        ddlat = '0'

    if l_lon [3] == 'E':
        ddlon = float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600
    elif l_lon[3] == 'W':
        ddlon = (float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600)*-1
    else:
        ddlon = '0'

    layer = iface.activeLayer()
    f = QgsFeature(layer.pendingFields())
    geom = QgsGeometry.fromPoint(QgsPoint(ddlon,ddlat))
    f.setGeometry(geom)
    layer.addFeature(f)
    iface.mapCanvas().refresh()

 def manageFinished(self, success, reason):
     ''' Do action after notify that alg is finished. These are the postprocessing steps
     1) merge result to the output layer
     2) add the layer to canvas in case it is new
     3) notify edn of processing
     4) terminate the thread
     '''
     # finish the thread
     self.thread.quit()
     
     # check result
     if not success:
         QgsMessageLog.logMessage('Failed execution: {}'.format(reason), 'QTraffic', QgsMessageLog.CRITICAL)
         iface.messageBar().pushCritical('QTraffic', self.tr("Error executing the algorithm: {}".format(reason)))
         return
     
     # prepare result
     try:
         self.alg.addResultToLayer(self.outLayer)
     except Exception as ex:
         traceback.print_exc()
         QgsMessageLog.logMessage('Cannot add result to layer: {}'.format(str(ex)), 'QTraffic', QgsMessageLog.CRITICAL)
         iface.messageBar().pushCritical('QTraffic', self.tr("Cannot add result to layer"))
         return
     
     # add or refresh rsult vector layer
     addToInputLayer = self.gui.addToOriginaLayer_RButton.isChecked()
     if not addToInputLayer:
         QgsMapLayerRegistry.instance().addMapLayer(self.outLayer)
     iface.mapCanvas().refresh()
     
     # notify the user the end of process
     iface.messageBar().pushSuccess('QTraffic', self.tr('Alg terminated successfully'))

 def stop_picking(self):
     if self.pick_mode == self.PICK_MAP:
         iface.mapCanvas().unsetMapTool(self.tool)
     elif self.pick_mode == self.PICK_LAYER:
         self.pick_layer.selectionChanged.disconnect(self.on_pick_selection_changed)
         self.pick_layer = None
     self.pick_mode = self.PICK_NO

    def processAlgorithm(self, parameters, context, feedback):
        fileName = self.getParameterValue(self.INPUT)
        layer = QgsProcessingUtils.mapLayerFromString(fileName, context)
        crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))

        provider = layer.dataProvider()
        ds = provider.dataSourceUri()
        p = re.compile('\|.*')
        dsPath = p.sub('', ds)

        if dsPath.lower().endswith('.shp'):
            dsPath = dsPath[:-4]

        wkt = crs.toWkt()
        with open(dsPath + '.prj', 'w') as f:
            f.write(wkt)

        qpjFile = dsPath + '.qpj'
        if os.path.exists(qpjFile):
            with open(qpjFile, 'w') as f:
                f.write(wkt)

        layer.setCrs(crs)
        iface.mapCanvas().refresh()

        self.setOutputValue(self.OUTPUT, fileName)

 def closeClicked(self):
     self.animating = False
     if isinstance(self.layer, QgsVectorLayer):
         self.layer.setSubsetString("")
     else:
         self.layer.dataProvider().setDataSourceUri(self.originalUri)
     iface.mapCanvas().refresh()
     self.setVisible(False)

def show_features(layer, features, neighbors):
    selection = []
    for x in neighbors:
        selection.append(features[x].id())
    layer.setSelectedFeatures(selection)
    box = layer.boundingBoxOfSelected()
    iface.mapCanvas().setExtent(box)
    iface.mapCanvas().refresh()

def on_scale_changed():
    print(scale_widget.scale(),
          QgsScaleWidget.toString(scale_widget.scale()))
    print(scale_widget.scaleString(),
          QgsScaleWidget.toDouble(scale_widget.scaleString()))
    print(scale_widget.showCurrentScaleButton())
    print("Scale changed")
    iface.mapCanvas().zoomScale(1 / scale_widget.scale())