# Original sources Copyright (c) 2006 by Tim Sutton
#
# ported to Python by Martin Dobias
#
# licensed under the terms of GNU GPL 2
#
# Adaptado por German Carrillo
# GeoTux
# http://geotux.tuxfamily.org
#

import sys

from PyQt4.QtCore import *
from PyQt4.QtGui import *

from qgis.core import *
from qgis.gui import *

from visor_shapefiles_ui import Ui_MainWindow

qgis_prefix = "/usr" 


class VisorShapefiles(QMainWindow, Ui_MainWindow):
    """ Clase Visor de Shapefiles. """
    def __init__(self):
        """ Inicializador de la clase Visor de Shapefiles. """
        QMainWindow.__init__(self)
        
        # Requerido por Qt4 para inicializar la UI
        self.setupUi(self)
		
		# Fijar el titulo
        self.setWindowTitle("GeoTux, Visor de Shapefiles con QGis")        

        # Crear el Map Canvas
        self.canvas = QgsMapCanvas()
        self.canvas.setCanvasColor(QColor(255,255,255))
        self.canvas.enableAntiAliasing(True)
        self.canvas.useImageToRender(False)   
        self.canvas.show()

        # Se agrega el Map canvas a la ventana principal, dentro del marco		
        self.layout = QVBoxLayout(self.frame)
        self.layout.addWidget(self.canvas)

        # Crear los comportamientos de los botones		
        self.actionAddLayer = QAction(QIcon(qgis_prefix +
            '/share/qgis/themes/classic/mActionAddOgrLayer.png'), 
            "Agregar capa", self.frame)
        self.connect(self.actionAddLayer, SIGNAL("activated()"), self.addLayer)
		
        self.actionZoomIn = QAction(QIcon(qgis_prefix + 
            '/share/qgis/themes/classic/mActionZoomIn.png'), 
            "Acercar", self.frame)
        self.connect(self.actionZoomIn, SIGNAL("activated()"), self.zoomIn)
		
        self.actionZoomOut = QAction(QIcon(qgis_prefix + 
            '/share/qgis/themes/classic/mActionZoomOut.png'), 
            "Alejar", self.frame)
        self.connect(self.actionZoomOut, SIGNAL("activated()"), self.zoomOut)
		
        self.actionPan = QAction(QIcon(qgis_prefix + 
            '/share/qgis/themes/classic/mActionPan.png'), "Panear", self.frame)
        self.connect(self.actionPan, SIGNAL("activated()"), self.pan)
		
        self.actionZoomFull = QAction(QIcon(qgis_prefix + 
            '/share/qgis/themes/classic/mActionZoomFullExtent.png'), 
            "Vista completa", self.frame)
        self.connect(self.actionZoomFull, SIGNAL("activated()"), self.zoomFull)	

        # Crear una toolbar
        self.toolbar = self.addToolBar("Map")
        self.toolbar.addAction(self.actionAddLayer)
        self.toolbar.addAction(self.actionZoomIn)
        self.toolbar.addAction(self.actionZoomOut)
        self.toolbar.addAction(self.actionPan)
        self.toolbar.addAction(self.actionZoomFull)

        # Crear las herramientas (tools) para el mapa
        self.toolPan = QgsMapToolPan(self.canvas)    
        self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = Acercar
        self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = Alejar   
		
        self.layers = [] # Lista de capas del canvas, para poder agregar capas a las existentes
		
    def zoomIn(self):
        """ Acercar """
        self.canvas.setMapTool(self.toolZoomIn)

    def zoomOut(self):
        """ Alejar """		
        self.canvas.setMapTool(self.toolZoomOut)

    def pan(self):
        """ Panear """
        self.canvas.setMapTool(self.toolPan)

    def zoomFull(self):
        """ Vista total """
        self.canvas.zoomToFullExtent()
		
    def addLayer(self):
        """ Agregar capa al canvas """
        layerPath = QFileDialog.getOpenFileName(self, "Abrir shapefile", ".", "Shapefiles (*.shp)")
        layerInfo = QFileInfo(layerPath)
        layerProvider = "ogr"

        # Crear el layer
        layer = QgsVectorLayer(layerPath, layerInfo.fileName(), layerProvider)

        if not layer.isValid():
            return

        #Cambiar el color del layer
        symbols = layer.renderer().symbols()
        symbol = symbols[0]        
        symbol.setFillColor(QColor.fromRgb(176,251,163))            
            
        # Agregar el layer al registro
        QgsMapLayerRegistry.instance().addMapLayer(layer);

        # Fijar el extent al extent del primer layer cargado
        if self.canvas.layerCount() == 0: 
            self.canvas.setExtent(layer.extent())
            
        # Fijar el conjunto de capas (LayerSet) para el map canvas        
        self.layers.insert(0, QgsMapCanvasLayer(layer))                         
        self.canvas.setLayerSet(self.layers)        

def main(argv):

    app = QApplication(argv)	
    
	# Inicializar las librerias de QGIS
    QgsApplication.setPrefixPath(qgis_prefix, True)
    QgsApplication.initQgis()

    # Crear y mostrar la ventana principal
    wnd = VisorShapefiles()
    wnd.move(100,100)
    wnd.show()

    # Ejecutar un loop para correr el programa
    retval = app.exec_()
    
	# Salir
    QgsApplication.exitQgis()
    sys.exit(retval)


if __name__ == "__main__": 
	# Si el modulo es importado __name__= VisorShapefiles  ,
	#    si es ejecutado: __name__ = __main__    
    main(sys.argv) # Crear la aplicacion Qt