def addTiles(self, layer, files):
        count = 0
        layers = []

        QApplication.setOverrideCursor( Qt.WaitCursor )       
        iface.mapCanvas().freeze(True)

        for fileName in files:
            print("TileIndex plugin : loading raster file %s" % fileName)           
            fileInfo = QFileInfo(fileName)
            rlayer = QgsRasterLayer(fileName, fileInfo.baseName())
            if rlayer is None:
                print("TileIndex plugin : raster file %s could not be loaded..." % fileName)
                continue
            layers.append(rlayer)
            count = count + 1

        print("TileIndex plugin : adding %d layers to map registry" % count) 
        QgsMapLayerRegistry.instance().addMapLayers(layers)
        iface.mapCanvas().freeze(False)
        iface.mapCanvas().refresh()
        print("TileIndex plugin : done adding layers")
        QApplication.restoreOverrideCursor()
                    
        # restore active layer if qgis >= 1.9
        if count > 0:
            if QGis.QGIS_VERSION_INT >= 10900:
                iface.legendInterface().setCurrentLayer(layer)
            else:
                iface.setActiveLayer(layer)
                

        return count

	def populateLayers(self):	
		groups = {}	
		rels = iface.legendInterface().groupLayerRelationship()
		groupedLayers = {}
		for rel in rels:
			groupName = rel[0] 
			if groupName != '':
				groupLayers = rel[1]			
				groups[groupName] = []
				for layerid in groupLayers:
					groups[groupName].append(QgsMapLayerRegistry.instance().mapLayer(layerid))
					groupedLayers[layerid] = groupName 
		self.layersItem = QTreeWidgetItem()
		self.layersItem.setText(0, "Layers and Groups")										 
		layers = iface.legendInterface().layers()
		for layer in layers:
			print layer.type()
			if layer.id() not in groupedLayers:
				item = TreeLayerItem(layer, self.layersTree)				
				self.layersItem.addChild(item)
			else:
				groupName = groupedLayers[layer.id()]
				try:
					groupLayers = groups[groupName]
				except KeyError:
					continue
				item = TreeGroupItem(groupName, groupLayers, self.layersTree)		   				 					
				self.layersItem.addChild(item)
				del groups[groupName]

		self.layersTree.addTopLevelItem(self.layersItem) 
		self.layersTree.expandAll()
			
		self.layersTree.resizeColumnToContents(0)
		self.layersTree.resizeColumnToContents(1)

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 load(self, crs, idSubgrupo = None):
        vlayerQml = os.path.join(self.abstractDb.getQmlDir(), self.qmlName+'.qml')
        

        database = self.abstractDb.db.databaseName()

        vlayer = iface.addVectorLayer(self.uri.uri(), self.layer_name, self.provider)
        if not vlayer:
            return None

        vlayer.setCrs(crs)
        if self.schema <> 'views':
            vlayer.loadNamedStyle(vlayerQml, False)
            attrList = vlayer.pendingFields()
            for field in attrList:
                i = vlayer.fieldNameIndex(field.name())
                if vlayer.editorWidgetV2(i) == 'ValueRelation':
                    groupList = iface.legendInterface().groups()
                    groupRelationshipList = iface.legendInterface().groupLayerRelationship()
                    filename = os.path.basename(database).split('.')[0]
                    if filename not in groupList:
                        idx = iface.legendInterface().addGroup(filename, True,-1)
                        domainIdGroup = iface.legendInterface().addGroup(self.tr("Dominios"), True, idx)
                    else:
                        idx = groupList.index(filename)
                        if "Dominios" not in groupList[idx::]:
                            domainIdGroup = iface.legendInterface().addGroup(self.tr("Dominios"), True, idx)
                        else:
                            domainIdGroup = groupList[idx::].index("Dominios")
    
                    valueRelationDict = vlayer.editorWidgetV2Config(i)
                    domainTableName = valueRelationDict['Layer']
                    loadedLayers = iface.legendInterface().layers()
                    domainLoaded = False
                    for ll in loadedLayers:
                        if ll.name() == domainTableName:
                            candidateUri = QgsDataSourceURI(ll.dataProvider().dataSourceUri())
                            if database == candidateUri.database():
                                domainLoaded = True
                                domLayer = ll
                    if not domainLoaded:
                        uri = QgsDataSourceURI()
                        uri.setDatabase(database)
                        uri.setDataSource('', 'dominios_'+domainTableName, None)
                        #TODO Load domain layer into a group
                        domLayer = iface.addVectorLayer(uri.uri(), domainTableName, self.provider)
                        iface.legendInterface().moveLayer(domLayer, domainIdGroup)
                    valueRelationDict['Layer'] = domLayer.id()
                    vlayer.setEditorWidgetV2Config(i,valueRelationDict)
    
            self.qmlLoaded.emit()
        

        iface.legendInterface().moveLayer(vlayer, idSubgrupo)
            
        if not vlayer.isValid():
            QgsMessageLog.logMessage(vlayer.error().summary(), "DSG Tools Plugin", QgsMessageLog.CRITICAL)

        return vlayer

 def prepareLoad(self):
     dbName = self.abstractDb.getDatabaseName()
     groupList =  iface.legendInterface().groups()
     if dbName in groupList:
         return groupList.index(dbName)
     else:
         parentTreeNode = iface.legendInterface().addGroup(self.abstractDb.getDatabaseName(), -1)
         return parentTreeNode

    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(filename)

        style = self.getParameterValue(self.STYLE)
        layer.loadNamedStyle(style)

        self.setOutputValue(self.OUTPUT, filename)
        iface.mapCanvas().refresh()
        iface.legendInterface().refreshLayerSymbology(layer)

    def loadLayer(self, inputParam, idSubgrupo, loadedLayers, useInheritance, useQml, uniqueLoad, stylePath, domainDict, multiColumnsDict, domLayerDict, edgvVersion, geomColumn = None, isView = False):
        """
        Loads a layer
        :param lyrName: Layer nmae
        :param loadedLayers: list of loaded layers
        :param idSubgrupo: sub group id
        :param uniqueLoad: boolean to mark if the layer should only be loaded once
        :param stylePath: path to the styles used
        :param domLayerDict: domain dictionary
        :return:
        """
        if isinstance(inputParam,dict):
            lyrName = inputParam['lyrName']
            schema = inputParam['tableSchema']
            geomColumn = inputParam['geom']
            tableName = inputParam['tableName']
            srid =  self.geomDict['tablePerspective'][tableName]['srid']
        else:
            lyrName = inputParam
            tableName = self.geomDict['tablePerspective'][lyrName]['tableName']
            schema = self.geomDict['tablePerspective'][lyrName]['schema']
            geomColumn = self.geomDict['tablePerspective'][lyrName]['geometryColumn']
            srid =  self.geomDict['tablePerspective'][lyrName]['srid']
        if uniqueLoad:
            lyr = self.checkLoaded(tableName, loadedLayers)
            if lyr:
                return lyr
        fullName = '''"{0}"."{1}"'''.format(schema, tableName)
        pkColumn = self.abstractDb.getPrimaryKeyColumn(fullName)
        if useInheritance or self.abstractDb.getDatabaseVersion() in ['3.0', 'Non_Edgv']:
            sql = ''
        else:
            sql = self.abstractDb.gen.loadLayerFromDatabase(fullName, pkColumn=pkColumn)            
        self.setDataSource(schema, tableName, geomColumn, sql, pkColumn=pkColumn)

        vlayer = iface.addVectorLayer(self.uri.uri(), tableName, self.provider)
        crs = QgsCoordinateReferenceSystem(int(srid), QgsCoordinateReferenceSystem.EpsgCrsId)
        if vlayer:
            vlayer.setCrs(crs)
            if useQml:
                vlayer = self.setDomainsAndRestrictionsWithQml(vlayer)
            else:
                vlayer = self.setDomainsAndRestrictions(vlayer, tableName, domainDict, multiColumnsDict, domLayerDict)
            if stylePath:
                fullPath = self.getStyle(stylePath, tableName)
                if fullPath:
                    vlayer.applyNamedStyle(fullPath)
            iface.legendInterface().moveLayer(vlayer, idSubgrupo)   
            if not vlayer.isValid():
                QgsMessageLog.logMessage(vlayer.error().summary(), "DSG Tools Plugin", QgsMessageLog.CRITICAL)
        vlayer = self.createMeasureColumn(vlayer)
        return vlayer

    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(filename)

        style = self.getParameterValue(self.STYLE)
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
            self.getOutputFromName(self.OUTPUT).open = False
        else:
            layer.loadNamedStyle(style)
            iface.mapCanvas().refresh()
            iface.legendInterface().refreshLayerSymbology(layer)

    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        style = self.getParameterValue(self.STYLE)

        dataobjects.resetLoadedLayers()
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            layer.loadNamedStyle(style)
            layer.triggerRepaint()
            iface.legendInterface().refreshLayerSymbology(layer)
        self.setOutputValue(self.OUTPUT, filename)

    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(filename)

        style = self.getParameterValue(self.STYLE)
        with open(style) as f:
            xml = "".join(f.readlines())
        d = QDomDocument();
        d.setContent(xml);
        n = d.firstChild();
        layer.readSymbology(n, '')
        self.setOutputValue(self.OUTPUT, filename)
        iface.mapCanvas().refresh()
        iface.legendInterface().refreshLayerSymbology(layer)

def load(fileName, name=None, crs=None, style=None):
    """Loads a layer/table into the current project, given its file.
    """

    if fileName is None:
        return
    prjSetting = None
    settings = QSettings()
    if crs is not None:
        prjSetting = settings.value('/Projections/defaultBehaviour')
        settings.setValue('/Projections/defaultBehaviour', '')
    if name is None:
        name = path.split(fileName)[1]
    qgslayer = QgsVectorLayer(fileName, name, 'ogr')
    if qgslayer.isValid():
        if crs is not None and qgslayer.crs() is None:
            qgslayer.setCrs(crs, False)
        if style is None:
            if qgslayer.geometryType == 0:
                style = ProcessingConfig.getSetting(
                        ProcessingConfig.VECTOR_POINT_STYLE)
            elif qgslayer.geometryType == 1:
                style = ProcessingConfig.getSetting(
                        ProcessingConfig.VECTOR_LINE_STYLE)
            else:
                style = ProcessingConfig.getSetting(
                        ProcessingConfig.VECTOR_POLYGON_STYLE)
        qgslayer.loadNamedStyle(style)
        QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
    else:
        qgslayer = QgsRasterLayer(fileName, name)
        if qgslayer.isValid():
            if crs is not None and qgslayer.crs() is None:
                qgslayer.setCrs(crs, False)
            if style is None:
                style = ProcessingConfig.getSetting(
                        ProcessingConfig.RASTER_STYLE)
            qgslayer.loadNamedStyle(style)
            QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
            iface.legendInterface().refreshLayerSymbology(qgslayer)
        else:
            if prjSetting:
                settings.setValue('/Projections/defaultBehaviour', prjSetting)
            raise RuntimeError(
                    'Could not load layer: ' + unicode(fileName)
                    + '\nCheck the procesing framework log to look for errors')
    if prjSetting:
        settings.setValue('/Projections/defaultBehaviour', prjSetting)

    return qgslayer

    def updateColorMap(self, ds):
        """ update color map of the current data set given the settings """

        if not ds.custom["c_basic"]:
            cm = ds.custom["c_advancedColorMap"]
        else:
            cm = self._colorMapBasic(ds)

        if not cm:
            return

        cm.alpha = ds.custom["c_alpha"]
        ds.config["c_colormap"] = cm

        iface.legendInterface().refreshLayerSymbology(self)

    def _onNewLayerGroupGenerated(self, groupObject, layerList):
        """
        Currently only used to show the first image of a newly created group
        so the user knows when the operation finishes.

        :param groupObject: The legend group object which was created.
        :type  groupObject: QgsLayerTreeGrupo

        :param layerList: The layers which are held in the group object.
        :type  layerList: [QgsLayer]
        """
        if (layerList[0]).isValid() is True:
            iface.legendInterface().setLayerVisible(layerList[0], True)
        else:
            self.postInformationMessageToUser("There was a problem showing a layer.")

def AddRasterLayer(theRaster):

    # Loop over all the parent group layers for this raster
    # ensuring they are in the tree in correct, nested order
    parentGroup = None
    if len(theRaster.data()) > 0:
        for aGroup in theRaster.data()["group_layers"]:
            parentGroup = AddGroup(aGroup, parentGroup)

    assert parentGroup, "All rasters should be nested and so parentGroup should be instantiated by now"

    # Only add the layer if it's not already in the registry
    if not QgsMapLayerRegistry.instance().mapLayersByName(theRaster.text()):
        rOutput = QgsRasterLayer(theRaster.data()["filepath"], theRaster.text())
        QgsMapLayerRegistry.instance().addMapLayer(rOutput, False)
        parentGroup.addLayer(rOutput)
        
        # call Konrad's symbology method here using data()["symbology"]
        RasterSymbolizer(rOutput).render_GCD(theRaster.data()["symbology"])

        if theRaster.data()["symbology"].lower() == "dem":
            demPath, demExtension = os.path.splitext( theRaster.data()["filepath"])
            hillshadePath = demPath + "HS" + demExtension
            
            if os.path.isfile(hillshadePath):
                rHillshade = QgsRasterLayer(hillshadePath, "Hillshade")
                QgsMapLayerRegistry.instance().addMapLayer(rHillshade, False)
                lHillshade = parentGroup.addLayer(rHillshade)
                legend = iface.legendInterface()
                legend.setLayerExpanded(rHillshade, False)

    # if the layer already exists trigger a refresh
    else:
        print "REFRESJH"
        QgsMapLayerRegistry.instance().mapLayersByName(theRaster.text())[0].triggerRepaint()

def get_raster_layer_list(iface, visibility='all'):
    """
    Iterate over all layers and return a list of the currently visible WMS-files.
    :param iface: The Qgis-interface that will be accessed
    :type iface: QgisInterface
    :return: A list containing raster layers with the given visibility-value
    :rtype: list
    """
    active_raster_layers = []
    layer_list = QgsMapLayerRegistry.instance().mapLayers()
    interface = iface.legendInterface()

    if visibility == 'visible':
        for key, layer in layer_list.iteritems():
            if layer.type() == QgsMapLayer.RasterLayer and interface.isLayerVisible(layer):
                active_raster_layers.append(layer)

        return active_raster_layers

    elif visibility == 'invisible':
        for key, layer in layer_list.iteritems():
            if layer.type() == QgsMapLayer.RasterLayer and not interface.isLayerVisible(layer):
                active_raster_layers.append(layer)

        return active_raster_layers

    else:
        for key, layer in layer_list.iteritems():
            if layer.type() == QgsMapLayer.RasterLayer:
                active_raster_layers.append(layer)

        return active_raster_layers

 def initGui(self):
     # define icons
     self.undoEnabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/undo.png")
     self.undoDisabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/undo-disabled.png")
     self.redoEnabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/redo.png")
     self.redoDisabledIcon=icon = QIcon(os.path.dirname(__file__) + "/icons/redo-disabled.png")
     #define undo and redo actions
     self.uaction = QAction(self.undoDisabledIcon,"undo", self.iface.mainWindow())
     self.uaction.triggered.connect(self.undoAction)
     self.uaction.setDisabled(True)
     self.raction = QAction(self.redoDisabledIcon,"redo", self.iface.mainWindow())
     self.raction.triggered.connect(self.redoAction)
     self.raction.setDisabled(True)
     #define signals connections
     self.mapLayerRegistry = QgsMapLayerRegistry.instance()
     self.mapLayerRegistry.layersWillBeRemoved.connect(self.layersRemovedAction)
     self.mapLayerRegistry.legendLayersAdded.connect(self.layersAddedAction)
     self.iface.legendInterface().currentLayerChanged.connect(self.currentLayerChanges)
     # Add toolbar button and menu item
     self.toolBar = self.iface.addToolBar("Undo properties changes")
     self.toolBar.setObjectName("Undo properties changes")
     self.toolBar.addAction(self.uaction)
     self.toolBar.addAction(self.raction)
     self.iface.addPluginToMenu(u"&undo properties changes", self.uaction)
     self.iface.addPluginToMenu(u"&undo properties changes", self.raction)
     # register currently loaded layers
     self.layersAddedAction(iface.legendInterface().layers())

def get_layers(): 
              
    global schema_name, layer_other_x_sector
                                                           
    layers = iface.legendInterface().layers()
    if len(layers) == 0:
        return
    
    # Initialize variables                       
    layer_other_x_sector = None
    table_other_x_sector = dao_controller.getSettingsParameter('database', 'table_other_x_sector')    
    table_other_x_sector = '"'+schema_name+'"."'+table_other_x_sector+'"'   
    
    # Iterate over all layers to get the ones set in config file        
    for cur_layer in layers:     
        uri = cur_layer.dataProvider().dataSourceUri().lower()   
        pos_ini = uri.find('table=')
        pos_fi = uri.find('" ')  
        uri_table = uri   
        if pos_ini <> -1 and pos_fi <> -1:
            uri_table = uri[pos_ini+6:pos_fi+1]                                     
            if table_other_x_sector == uri_table:  
                layer_other_x_sector = cur_layer                
    
    if layer_other_x_sector is None:
        utils_pavements.showWarning("No s'ha trobat la capa: "+table_other_x_sector)
        return

def all_legend_layers():
    legend = iface.legendInterface()
    layers = legend.layers()
    list_layers = []
    for each_layer in layers:
        list_layers.append(each_layer.name())
    return list_layers

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 db_view_sel(self,lista):
        # sele="Nomefile IN ('G994_000100') AND ((EXT='') or (Ext is Null))"
        # index=0
        # for group in iface.legendInterface().groupLayerRelationship() :
        #   if group[0]=="Catasto":
        #    index+=1
        # if index==0:
        #   db_view_all(self,lista)
        # else:
        #  layers = QgsMapLayerRegistry.instance().mapLayers()
        #  for name, layer in layers.iteritems():
        #   layerType = layer.type()
        #   if layerType == QgsMapLayer.VectorLayer:
        #     layer.setSubsetString(lista)

        index = 0
        for group in iface.legendInterface().groupLayerRelationship():
            if group[0] == "Catasto":
                index+=1
                gruppo = group[1]
                layers = QgsMapLayerRegistry.instance().mapLayers()
                for name, layer in layers.iteritems():
                    if name in gruppo:
                        if layer.type() == QgsMapLayer.VectorLayer:
                         layer.setSubsetString(lista)
        if index == 0:
                db_view_all(self, lista)


        db_view_change_style()