def disconnect_projectsignals(self):
     safe_disconnect(QgsMapLayerRegistry.instance().layerWasAdded, self.connect_layer_signals)
     safe_disconnect(QgsMapLayerRegistry.instance().layersRemoved, self.layers_removed)
     safe_disconnect(self.canvas.layersChanged, self.layers_changed)
     safe_disconnect(self.iface.projectRead, self.connect_signals)
     safe_disconnect(self.canvas.selectionChanged, self.selection_changed)
     safe_disconnect(self.canvas.selectionChanged, self.viewer.selection_changed)

 def viewerReady(self):
     """
     Called once the viewer is loaded and ready to get location events.
     """
     self.disconnect_signals()
     self.connect_signals()
     self.iface.projectRead.connect(self.connect_signals)
     self.canvas.layersChanged.connect(self.layers_changed)
     self.canvas.selectionChanged.connect(self.selection_changed)
     self.canvas.selectionChanged.connect(self.viewer.selection_changed)
     QgsMapLayerRegistry.instance().layersRemoved.connect(self.layers_removed)
     QgsMapLayerRegistry.instance().layerWasAdded.connect(self.connect_layer_signals)
     self.center_on_canvas()
     self.viewer.activelayercombo.setLayer(self.iface.activeLayer())

def getAllLayerIds(filter_func):
    # FIXME Make this nicer
    res = []
    for (id, layer) in QgsMapLayerRegistry.instance().mapLayers().iteritems():
        if filter_func(layer):
            res.append(id)
    return res

def layer_from_name(layerName):
    # Important: If multiple layers with same name exist, it will return the
    # first one it finds
    for (id, layer) in QgsMapLayerRegistry.instance().mapLayers().iteritems():
        if unicode(layer.name()) == layerName:
            return layer
    return None

def getLayerFromId(layerId):
    try:
        layer = QgsMapLayerRegistry.instance().mapLayers()[layerId]
        return layer
    except:
        warn("Could not get layer for id {}".format(layerId))
        return None

def get_layer(layer_name):
    layermap = QgsMapLayerRegistry.instance().mapLayers()
    for name, layer in layermap.iteritems():
        if layer.name() == layer_name:
            if layer.isValid():
                return layer
            else:
                return None

def getLayerAttributes(layerId):
    try:
        layer = QgsMapLayerRegistry.instance().mapLayers()[layerId]
        fieldmap = layer.pendingFields()
        return fieldmap
    except:
        # OpenLayers, Raster layers don't work with this
        warn("Could not get attributes of layer {}".format(layerId))
        return None

def getLayerAttributes(layerId):
    try:
        layer=QgsMapLayerRegistry.instance().mapLayers()[layerId]
        fieldmap = layer.pendingFields() 
        #TODO v1.7 figure out what to do for fields with fieldmap.fieldOrigin(idx) = QgsFields.OriginEdit/OriginExpression
        return fieldmap
    except:
        # OpenLayers, Raster layers don't work with this
        warn("Could not get attributes of layer {}".format(layerId))
        return None

def getAllJoinedLayers(layerIds):
    """get the ids of the layers that are joined on the given layerIds"""
    allJoined = set()
    allLayers = QgsMapLayerRegistry.instance().mapLayers()
    for (id, layer) in allLayers.iteritems():
        if isRaster(layer):
            continue
        if id in layerIds:  # let's see what the given layers are joined on
            allJoined |= getAllJoinIdsOfLayer(layer)
        else:  # let's see if the other layers join with the given layers
            joinsOfCurrentLayer = getAllJoinIdsOfLayer(layer)
            if len(joinsOfCurrentLayer & layerIds) > 0:
                allJoined.add(id)

    return allJoined

    def populate(self, layerIds):
        self.tempLayerIndexToId = {}
        i = 0
        for (id,layer) in QgsMapLayerRegistry.instance().mapLayers().iteritems():
            if id in layerIds:
                unicode_name = unicode(layer.name())
                self.add_layer_to_select(unicode_name)
                self.tempLayerIndexToId[i] = id
                i+=1

        if self.layer_count()== 0:
            msg = 'There are no unmanaged layers of requested type in the project!'
            QMessageBox.information(self.dialog,'Error', msg)
            raise Exception(msg)

        # add the attributes of the first layer in the select for gui initialization
        self.add_layer_attributes(0)
        self.add_connections()

def remove_layer_from_qgis(id):
    QgsMapLayerRegistry.instance().removeMapLayer(id)
    sleep(0.1)

def load_layer_to_qgis(layer):
    QgsMapLayerRegistry.instance().addMapLayer(layer)
    sleep(0.2)

def get_all_layer_names():
     return QgsMapLayerRegistry.instance().mapLayers().keys()

def layer_count():
    return len(QgsMapLayerRegistry.instance().mapLayers())

def getNameFromLayerId(layerId):
    layer = QgsMapLayerRegistry.instance().mapLayers()[layerId]
    return unicode(layer.name())

 def populate(self, layerIds):
     idlayers_it = QgsMapLayerRegistry.instance().mapLayers().iteritems()
     selected_idlayers = filter(lambda idlayer: idlayer[0] in layerIds, idlayers_it)
     self.populateFromLayers(selected_idlayers)

def layer_by_id(layerid):
    return QgsMapLayerRegistry.instance().mapLayer(layerid)

def layer_by_name(name):
    return QgsMapLayerRegistry.instance().mapLayersByName(name)[0]

def maplayers():
    return QgsMapLayerRegistry.instance().mapLayers().values()