# -*- coding: latin-1 -*-

import copy

from PySide import QtCore, QtGui

from Code.Traducir import tr
from Code.Constantes import *

import QTUtil
import TabTipos
import TabElementos
import TabFlechas
import TabMarcos
import Iconos
import Controles

#==========================================================================================================================================
class Tablero(QtGui.QGraphicsView):

    def __init__(self, parent, confTablero ):
        super(Tablero, self).__init__(None)

        self.setRenderHint(QtGui.QPainter.Antialiasing)
        self.setRenderHint(QtGui.QPainter.TextAntialiasing)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.escena = QtGui.QGraphicsScene(self)
        self.escena.setItemIndexMethod(self.escena.NoIndex)
        self.setScene(self.escena)

        self.pantalla = parent

        self.mensajero = None

        self.confTablero = confTablero

        self.opacidad = [ 1.0, 1.0 ]

        # print "( %d, %d, %d, %d ),"%(confTablero.colorExterior,confTablero.colorBlancas,confTablero.colorNegras,confTablero.colorTexto)

        # self.opacidad = [ 0.06, 0.06 ]
        # confTablero.colorBlancas=4294967295
        # confTablero.colorNegras=4294638330
        # confTablero.colorExterior=4294967295
        # confTablero.colorTexto=4294967295

        self.ponVariables( confTablero )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponVariables( self, confTablero ) :
        self.tipoPieza = confTablero.tipoPieza
        self.anchoPieza = confTablero.anchoPieza
        self.margenPieza = 2

        self.siMaximizado = self.anchoPieza == 1000
        if self.siMaximizado :
            self.setRenderHint(QtGui.QPainter.SmoothPixmapTransform)
            if QTUtil.altoEscritorio() > 800 :
                self.anchoPieza = 80
            else :
                self.anchoPieza = 64

        self.anchoCasilla = self.anchoPieza+self.margenPieza*2

        dTam = { 16:(9,23,+1,-1,+1), 24:(10,29,-1,+1,+2), 32:(12,33,-1,+2,+2), 48:(14,38,-1,+2,+2), 64:(16,42,-3,+3,+3), 80:(18,46,-3,+3,+1) }
        self.puntos, self.margenCentro, self.ajusteI, self.ajusteD, self.ajusteV = dTam[self.anchoPieza]

        self.colorBlancas = confTablero.colorBlancas
        self.colorNegras = confTablero.colorNegras

        self.colorExterior = confTablero.colorExterior

        self.colorTexto = confTablero.colorTexto

        self.liPiezas = [] # Pieza + posL

        self.liFlechas = []
        self.flechaSC = None

        self.exePulsadoNum = None
        self.atajosRaton = None
        self.siActivasPiezas = False # Control adicional, para responder a eventos del raton
        self.siActivasPiezasColor = None

        self.siPosibleRotarTablero = True

        self.dicMovibles = {} # Flechas, Marcos
        self.idUltimoMovibles = 0

        self.siBlancasAbajo = True

    #--------------------------------------------------------------------------------------------------------------------------------
    def crea( self ) :
        self.siBlancasAbajo = True

        # base
        cajon = TabTipos.Caja( )
        self.ancho = ancho = cajon.posicion.alto = cajon.posicion.ancho = self.anchoCasilla*8 + self.margenCentro*2+4

        cajon.posicion.orden = 1
        cajon.colorRelleno = self.colorExterior
        cajon.tipo = QtCore.Qt.NoPen
        # cajon.tipo = QtCore.Qt.SolidLine
        # cajon.color = self.colorBlancas

        self.setFixedSize( ancho, ancho )

        self.cajonSC = TabElementos.CajaSC( self.escena, cajon )

        # exterior casillas
        baseCasillas = TabTipos.Caja( )
        baseCasillas.posicion.x = baseCasillas.posicion.y = self.margenCentro
        baseCasillas.posicion.alto = baseCasillas.posicion.ancho = self.anchoCasilla*8
        baseCasillas.posicion.orden = 3
        baseCasillas.colorRelleno = self.colorBlancas
        baseCasillas.tipo = QtCore.Qt.NoPen

        self.baseCasillasSC = TabElementos.CajaSC( self.escena, baseCasillas )

        # casillas pares
        casilla = TabTipos.Caja( )
        casilla.posicion.orden = 4
        casilla.posicion.alto = casilla.posicion.ancho = self.anchoCasilla
        casilla.colorRelleno = self.colorNegras
        casilla.tipo = QtCore.Qt.NoPen
        self.liCasillasSC = []
        for x in range(4) :
            for y in range(8) :
                una = casilla.copia()

                k = self.margenCentro
                if y%2==0 :
                    k += self.anchoCasilla
                una.posicion.x = k + x*2*self.anchoCasilla
                una.posicion.y = self.margenCentro+y*self.anchoCasilla
                casillaSC = TabElementos.CajaSC( self.escena, una )
                self.liCasillasSC.append( casillaSC )

        # Coordenadas
        self.liCoordenadasVerticales = []
        self.liCoordenadasHorizontales = []

        anchoTexto = int(self.margenCentro*2/3)
        coord = TabTipos.Texto()
        coord.tipoLetra = TabTipos.TipoLetra( "Arial",self.puntos,peso=75 )
        coord.posicion.ancho = anchoTexto
        coord.posicion.alto = anchoTexto
        coord.posicion.orden = 2
        coord.colorTexto = self.colorTexto

        margenInterior = (self.margenCentro-anchoTexto)/2
        margenBaseV = self.margenCentro + (self.anchoCasilla-anchoTexto)/2
        margenBaseH = margenBaseV
        margenUltimo = self.margenCentro + self.anchoCasilla*8 + margenInterior

        for x in range( 8 ) :

            hor = coord.copia()
            hor.valor = chr(97+x)
            hor.alineacion = "c"
            hor.posicion.x = margenBaseH + x*self.anchoCasilla
            hor.posicion.y = margenUltimo
            horSC = TabElementos.TextoSC( self.escena, hor )
            self.liCoordenadasHorizontales.append( horSC )

            hor = hor.copia()
            hor.posicion.y = margenInterior
            horSC = TabElementos.TextoSC( self.escena, hor )
            self.liCoordenadasHorizontales.append( horSC )

            ver = coord.copia()
            ver.valor = chr(56-x)
            ver.alineacion = "d"
            ver.posicion.x = margenInterior + self.ajusteI - 5
            ver.posicion.y = margenBaseV + x*self.anchoCasilla + self.ajusteV
            verSC = TabElementos.TextoSC( self.escena, ver, self.pulsadoNum )
            self.liCoordenadasVerticales.append( verSC )

            ver = ver.copia()
            ver.alineacion = "i"
            ver.posicion.x = margenUltimo + self.ajusteD + 5
            verSC = TabElementos.TextoSC( self.escena, ver, self.pulsadoNum )
            self.liCoordenadasVerticales.append( verSC )

        # Indicador de color activo
        indicador = TabTipos.Circulo( )
        indicador.posicion.x = margenUltimo-2
        indicador.posicion.y = margenUltimo-2
        indicador.posicion.ancho = indicador.posicion.alto = anchoTexto
        indicador.posicion.orden = 2
        indicador.tipo = QtCore.Qt.NoPen
        indicador.colorRelleno = self.colorBlancas
        indicador.margenUltimo = margenUltimo
        indicador.margenInterior = margenInterior
        self.indicadorSC = TabElementos.CirculoSC( self.escena, indicador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def reset( self, confTablero ) :
        self.ponVariables( confTablero )
        for item in self.escena.items() :
            self.escena.removeItem( item )
            del item
        self.crea()

    #--------------------------------------------------------------------------------------------------------------------------------
    def mousePressEvent(self, event) :
        if self.siActivasPiezas and self.atajosRaton :
            pos = event.pos()
            x = pos.x()
            y = pos.y()
            minimo = self.margenCentro
            maximo = self.margenCentro+(self.anchoCasilla*8)
            if not ((minimo < x < maximo) and (minimo < y < maximo)) :
                self.atajosRaton( None )
                return
            xc = 1 + int(float(x-self.margenCentro) / self.anchoCasilla)
            yc = 1 + int(float(y-self.margenCentro) / self.anchoCasilla)

            if self.siBlancasAbajo :
                yc = 9-yc
            else :
                xc = 9-xc

            f = chr(48+yc)
            c = chr(96+xc)

            self.atajosRaton( c + f )

        QtGui.QGraphicsView.mousePressEvent(self,event)
    #--------------------------------------------------------------------------------------------------------------------------------
    def mouseDoubleClickEvent(self, event) :
        item = self.itemAt( event.pos() )
        if item :
            if item == self.flechaSC :
                self.flechaSC.hide()
            elif item == self.indicadorSC :
                if self.siPosibleRotarTablero :
                    self.rotaTablero()

    #--------------------------------------------------------------------------------------------------------------------------------
    def wheelEvent( self, event ) :
        if hasattr( self.pantalla, "tableroWheelEvent" ) :
            self.pantalla.tableroWheelEvent( self, event.delta() > 0 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def keyPressEvent( self, event ) :
        if hasattr( self.pantalla, "teclaPulsada" ) :
            self.pantalla.teclaPulsada( "T", event.key() )
        # else :
            # QtGui.QGraphicsView.keyPressEvent( self, event )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponMensajero( self, mensajero, atajosRaton = None ) :
        self.mensajero = mensajero
        if atajosRaton :
            self.atajosRaton = atajosRaton

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponPosicion( self, posicion ) :
        self.siActivasPiezas = False
        for x in self.liPiezas :
            if x[2] :
                piezaSC = x[1]
                self.escena.removeItem( piezaSC )
                x[2] = False

        self.liPiezas = []
        casillas = posicion.casillas
        for k in casillas.keys() :
            if casillas[k] :
                self.ponPieza( casillas[k], k )

        self.escena.update()
        self.setFocus()
        self.ponIndicador( posicion.siBlancas )
        if self.flechaSC :
            self.escena.removeItem( self.flechaSC )
            del self.flechaSC
            self.flechaSC = None
        QtCore.QCoreApplication.processEvents (QtCore.QEventLoop.ExcludeUserInputEvents)

    #--------------------------------------------------------------------------------------------------------------------------------
    def fila2punto( self, fila ) :
        factor = (8-fila) if self.siBlancasAbajo else (fila-1)
        return factor*(self.anchoPieza+self.margenPieza*2)+self.margenCentro+self.margenPieza

    #--------------------------------------------------------------------------------------------------------------------------------
    def columna2punto( self, columna ) :
        factor = (columna-1) if self.siBlancasAbajo else (8-columna)
        return factor*(self.anchoPieza+self.margenPieza*2)+self.margenCentro+self.margenPieza

    #--------------------------------------------------------------------------------------------------------------------------------
    def punto2fila( self, pos ) :
        pos -= self.margenCentro+self.margenPieza
        pos /= (self.anchoPieza+self.margenPieza*2)
        if self.siBlancasAbajo :
            return int( 8 - pos )
        else :
            return int( pos + 1 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def punto2columna( self, pos ) :
        pos -= self.margenCentro+self.margenPieza
        pos /= (self.anchoPieza+self.margenPieza*2)
        if self.siBlancasAbajo :
            return int( pos + 1 )
        else :
            return int( 8 - pos )

    #--------------------------------------------------------------------------------------------------------------------------------
    def colocaPieza( self, bloquePieza, posA1H8 ) :
        bloquePieza.fila = int(posA1H8[1])
        bloquePieza.columna = ord(posA1H8[0])-96
        self.recolocaPieza( bloquePieza )

    #--------------------------------------------------------------------------------------------------------------------------------
    def recolocaPieza( self, bloquePieza ) :
        posicion = bloquePieza.posicion
        posicion.x = self.columna2punto( bloquePieza.columna )
        posicion.y = self.fila2punto( bloquePieza.fila )

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaPieza( self, cpieza, posA1H8 ) :
        pieza = TabTipos.Pieza()
        p = pieza.posicion
        p.ancho = self.anchoPieza
        p.alto = self.anchoPieza
        p.orden = kZvalue_pieza
        pieza.pieza = cpieza
        self.colocaPieza( pieza, posA1H8 )
        piezaSC = TabElementos.PiezaSC( self.escena, pieza, self, self.tipoPieza )

        piezaSC.setOpacity( self.opacidad[0 if cpieza.isupper() else 1] )

        self.liPiezas.append( [cpieza, piezaSC, True] )
        return piezaSC

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponPieza( self, pieza, posA1H8 ) :
        for x in self.liPiezas :
            if not x[2] and x[0] == pieza :
                piezaSC = x[1]
                self.colocaPieza( piezaSC.bloquePieza, posA1H8 )
                self.escena.addItem( piezaSC )
                piezaSC.update()
                x[2] = True
                return

        self.creaPieza( pieza, posA1H8 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def mostrarPiezas( self, si_b, si_n ) :
        ob, on = self.opacidad
        if si_b is not None :
            ob = 1.0 if si_b else 0.01
        if si_n is not None :
            on = 1.0 if si_n else 0.01
        self.opacidad = ob, on
        for num,x in enumerate(self.liPiezas) :
            if x[2] :
                piezaSC = x[1]
                if x[0].isupper() :
                    piezaSC.setOpacity( ob )
                else :
                    piezaSC.setOpacity( on )
                piezaSC.update()
        self.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def buscaPieza( self, posA1H8 ) :
        fila = int(posA1H8[1])
        columna = ord(posA1H8[0])-96
        for num,x in enumerate(self.liPiezas) :
            if x[2] :
                pieza = x[1].bloquePieza
                if pieza.fila == fila and pieza.columna == columna :
                    return num
        return -1

    #--------------------------------------------------------------------------------------------------------------------------------
    def damePiezaEn( self, posA1H8 ) :
        npieza = self.buscaPieza( posA1H8 )
        if npieza >= 0 :
            return self.liPiezas[npieza][1]
        return None

    #--------------------------------------------------------------------------------------------------------------------------------
    def muevePiezaTemporal( self, desdeA1H8, hastaA1H8 ) :
        npieza = self.buscaPieza( desdeA1H8 )
        if npieza >= 0 :
            piezaSC = self.liPiezas[npieza][1]
            fila = int(hastaA1H8[1])
            columna = ord(hastaA1H8[0])-96
            x = self.columna2punto( columna )
            y = self.fila2punto( fila )
            piezaSC.setPos(x,y)

    #--------------------------------------------------------------------------------------------------------------------------------
    def muevePieza( self, desdeA1H8, hastaA1H8 ) :
        npieza = self.buscaPieza( desdeA1H8 )
        if npieza >= 0 :
            self.borraPieza( hastaA1H8 )
            piezaSC = self.liPiezas[npieza][1]
            self.colocaPieza( piezaSC.bloquePieza, hastaA1H8 )
            piezaSC.rehazPosicion()
            piezaSC.update()
            self.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def reponPieza( self, posA1H8 ) :
        npieza = self.buscaPieza( posA1H8 )
        if npieza >= 0 :
            piezaSC = self.liPiezas[npieza][1]
            piezaSC.rehazPosicion()
            piezaSC.update()
            self.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def borraPieza( self, posA1H8 ) :
        npieza = self.buscaPieza( posA1H8 )
        if npieza >= 0 :
            piezaSC = self.liPiezas[npieza][1]
            self.escena.removeItem( piezaSC )
            self.liPiezas[npieza][2] = False
            self.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def borraPiezaTipo( self, posA1H8, tipo ) :
        fila = int(posA1H8[1])
        columna = ord(posA1H8[0])-96
        for num,x in enumerate(self.liPiezas) :
            if x[2] :
                pieza = x[1].bloquePieza
                if pieza.fila == fila and pieza.columna == columna and pieza.pieza == tipo :
                    piezaSC = self.liPiezas[num][1]
                    self.escena.removeItem( piezaSC )
                    self.liPiezas[num][2] = False
                    self.escena.update()
                    return

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaPieza( self, posA1H8, nueva ) :
        self.borraPieza( posA1H8 )
        self.creaPieza( nueva, posA1H8 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def activaColor( self, siBlancas ) :
        self.siActivasPiezas = True
        self.siActivasPiezasColor = siBlancas
        for pieza, piezaSC, siActiva in self.liPiezas :
            if siActiva :
                if pieza.isupper() :
                    resp = siBlancas
                else :
                    resp = not siBlancas
                piezaSC.activa( resp )

    #--------------------------------------------------------------------------------------------------------------------------------
    def desactivaTodas( self ) :
        self.siActivasPiezas = False
        for pieza, piezaSC, siActiva in self.liPiezas :
            if siActiva :
                piezaSC.activa( False )

    #--------------------------------------------------------------------------------------------------------------------------------
    def num2alg( self, fila, columna ) :
        return chr( 96+columna ) + str(fila)

    #--------------------------------------------------------------------------------------------------------------------------------
    def intentaMover( self, piezaSC, posCursor ) :

        pieza = piezaSC.bloquePieza
        desde = self.num2alg( pieza.fila, pieza.columna )

        x = int(posCursor.x())
        y = int(posCursor.y())
        cx = self.punto2columna(x)
        cy = self.punto2fila(y)

        if cx in range( 1, 9 ) and cy in range( 1, 9 ) :
            hasta = self.num2alg( cy, cx )

            self.mensajero( desde, hasta )

        piezaSC.rehazPosicion()
        piezaSC.update()
        self.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponIndicador( self, siBlancas ) :
        bd = self.indicadorSC.bloqueDatos
        if siBlancas :
            bd.colorRelleno = self.colorBlancas
            siAbajo = self.siBlancasAbajo
        else :
            bd.colorRelleno = self.colorNegras
            siAbajo = not self.siBlancasAbajo
        bd.posicion.y = bd.margenUltimo-2 if siAbajo else bd.margenInterior-2
        self.indicadorSC.mostrar()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponFlechaSC( self, desdeA1h8, hastaA1h8 ) :
        a1h8 = desdeA1h8+hastaA1h8
        if self.flechaSC is None :
            self.flechaSC = self.creaFlechaSC( a1h8 )
        self.flechaSC.show()
        self.ultMovFlecha = (desdeA1h8, hastaA1h8) # Lo usamos si se cambia la posición del tablero
        self.flechaSC.ponA1H8( a1h8 )
        self.flechaSC.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def pulsadaFlechaSC(self) :
        self.flechaSC.hide()

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaFlechaSC( self, a1h8 ) :

        bf = copy.deepcopy( self.confTablero.fTransicion )
        bf.a1h8 = a1h8
        bf.anchoCasilla = self.anchoCasilla

        return self.creaFlecha( bf, self.pulsadaFlechaSC )

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaFlechaMov( self, desdeA1h8, hastaA1h8, modo ) :

        bf = TabTipos.Flecha()
        bf.trasparencia = 0.9
        bf.posicion.orden = kZvalue_pieza+1
        bf.anchoCasilla = self.anchoCasilla
        bf.color = self.confTablero.fTransicion.color
        bf.redondeos = False
        bf.forma = "a"

        siPieza = self.buscaPieza( hastaA1h8 ) > -1
        if modo == "m" : #movimientos
            bf.tipo = QtCore.Qt.DotLine
            bf.grosor = 2
            bf.altocabeza = 6
            bf.destino = "m" if siPieza else "c"

        elif modo == "c" : # captura
            bf.tipo = QtCore.Qt.SolidLine
            bf.grosor = 2
            bf.altocabeza = 8
            bf.destino = "m" if siPieza else "c"

        elif modo == "b" : # base para doble movimiento
            bf.tipo = QtCore.Qt.SolidLine
            bf.grosor = 2
            bf.altocabeza = 0
            bf.destino = "c"

        elif modo == "bm" : # base para doble movimiento
            bf.tipo = QtCore.Qt.DotLine
            bf.grosor = 2
            bf.altocabeza = 0
            bf.destino = "c"

        if modo == "2" : #m2
            bf = copy.deepcopy( self.confTablero.fTransicion )
            bf.trasparencia = 1.0
            bf.destino = "c"

        if modo == "3" : #m2+
            bf.tipo = QtCore.Qt.DotLine
            # bf.trasparencia = 0.7
            bf.grosor = 3
            bf.altocabeza = 0
            bf.destino = "m"
            bf.posicion.orden = kZvalue_pieza-1

        if modo == "4" : #m2+
            bf.tipo = QtCore.Qt.SolidLine
            # bf.trasparencia = 0.7
            bf.grosor = 2
            bf.altocabeza = 0
            bf.destino = "m"
            bf.posicion.orden = kZvalue_pieza-1

        if self.anchoPieza > 24 :
            bf.grosor = bf.grosor*15/10
            bf.altocabeza = bf.altocabeza*15/10

        bf.a1h8 = desdeA1h8 + hastaA1h8

        flecha = self.creaFlecha( bf )
        self.liFlechas.append( flecha )
        flecha.show()

    #--------------------------------------------------------------------------------------------------------------------------------
    def quitaFlechas( self ) :
        for flecha in self.liFlechas :
            flecha.hide()
            del flecha
        self.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponerPiezasAbajo( self, siBlancasAbajo ) :
        if self.siBlancasAbajo == siBlancasAbajo :
            return
        self.siBlancasAbajo = siBlancasAbajo
        for ver in self.liCoordenadasVerticales :
            ver.bloqueDatos.valor = str( 9-int(ver.bloqueDatos.valor) )
            ver.update()

        for hor in self.liCoordenadasHorizontales :
            hor.bloqueDatos.valor = chr( 97 + 104 - ord(hor.bloqueDatos.valor)  )
            hor.update()

        for pieza,piezaSC,siVisible in self.liPiezas :
            if siVisible :
                self.recolocaPieza( piezaSC.bloquePieza )
                piezaSC.rehazPosicion()
                piezaSC.update()

        self.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def peonCoronando( self, siBlancas ) :
        menu = QtGui.QMenu(self)

        liOpciones = ( ( tr( "DAMA" ), "Q"), (tr( "TORRE" ), "R"), (tr( "ALFIL" ), "B"), (tr( "CABALLO" ), "N") )
        for txt, pieza in liOpciones :
            if not siBlancas :
                pieza = pieza.lower()

            icono = eval( "Iconos.%s_16c()"%pieza )

            accion = QtGui.QAction( icono, txt, menu )
            accion.clave = pieza
            menu.addAction( accion )

        resp = menu.exec_(QtGui.QCursor.pos())
        if resp :
            return resp.clave
        else :
            return None

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaColores( self, confTablero ) :
        self.confTablero = confTablero
        self.colorBlancas = confTablero.colorBlancas
        self.colorNegras = confTablero.colorNegras
        self.colorExterior = confTablero.colorExterior
        self.colorTexto = confTablero.colorTexto

        # base
        self.cajonSC.bloqueDatos.colorRelleno = self.colorExterior

        # exterior casillas
        self.baseCasillasSC.bloqueDatos.colorRelleno = self.colorBlancas

        # casillas pares
        for casillaSC in self.liCasillasSC :
            casillaSC.bloqueDatos.colorRelleno = self.colorNegras

        # Coordenadas
        for coord in self.liCoordenadasVerticales :
            coord.bloqueDatos.colorTexto = self.colorTexto
        for coord in self.liCoordenadasHorizontales :
            coord.bloqueDatos.colorTexto = self.colorTexto

        # Indicador de color activo
        self.indicadorSC.bloqueDatos.colorRelleno = self.colorBlancas

        if self.flechaSC :
            self.escena.removeItem( self.flechaSC )
            self.flechaSC = None
            self.ponFlechaSC( self.ultMovFlecha[0], self.ultMovFlecha[1] )

        self.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def refresh( self ) :
        self.escena.update()
        QTUtil.refreshGUI()

    #--------------------------------------------------------------------------------------------------------------------------------
    def pulsadoNum( self, siIzq, siActivar, numero ) :
        if self.exePulsadoNum :
            self.exePulsadoNum( siIzq, siActivar, int(numero) )

    #--------------------------------------------------------------------------------------------------------------------------------
    def salvaEnImagen( self, fichero = None, tipo = None ) :
        pm = QtGui.QPixmap.grabWidget(self)
        if fichero is None :
            QTUtil.ponPortapapeles( pm, tipo="p" )
        else :
            pm.save( fichero, tipo )

    #--------------------------------------------------------------------------------------------------------------------------------
    def a1h8_fc( self, a1h8 ) :

        df = int(a1h8[1])
        dc = ord(a1h8[0])-96
        hf = int(a1h8[3])
        hc = ord(a1h8[2])-96
        if self.siBlancasAbajo :
            df = 9 - df
            hf = 9 - hf
        else :
            dc = 9 - dc
            hc = 9 - hc

        return df, dc, hf, hc

    #--------------------------------------------------------------------------------------------------------------------------------
    def fc_a1h8( self, df, dc, hf, hc ) :

        if self.siBlancasAbajo :
            df = 9 - df
            hf = 9 - hf
        else :
            dc = 9 - dc
            hc = 9 - hc

        a1h8 = chr(dc+96) + str(df) + chr(hc+96) + str(hf)

        return a1h8

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaMarco( self, bloqueMarco ) :

        bloqueMarcoN = copy.deepcopy(bloqueMarco)
        bloqueMarcoN.anchoCasilla = self.anchoCasilla

        return TabMarcos.MarcoSC( self.escena, bloqueMarcoN )

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaFlecha( self, bloqueFlecha, rutina = None ) :

        bloqueFlechaN = copy.deepcopy(bloqueFlecha)
        bloqueFlechaN.anchoCasilla = self.anchoCasilla

        return TabFlechas.FlechaSC( self.escena, bloqueFlechaN, rutina )

    #--------------------------------------------------------------------------------------------------------------------------------------------
    def rotaTablero( self ) :
        self.ponerPiezasAbajo( not self.siBlancasAbajo )
        if self.flechaSC  :
            self.ponFlechaSC( self.ultMovFlecha[0], self.ultMovFlecha[1])
        bd = self.indicadorSC.bloqueDatos
        self.ponIndicador( bd.colorRelleno == self.colorBlancas )
        for k, uno in self.dicMovibles.items() :
            uno.posicion2xy()
        self.escena.update()

        if hasattr( self.pantalla, "capturas" ) :
            self.pantalla.capturas.ponLayout( self.siBlancasAbajo )

    #--------------------------------------------------------------------------------------------------------------------------------------------
    def registraMovible( self, bloqueSC ) :
        self.idUltimoMovibles += 1
        bloqueSC.idMovible = self.idUltimoMovibles
        self.dicMovibles[self.idUltimoMovibles] = bloqueSC

#==========================================================================================================================================

#==========================================================================================================================================
class PosTablero( Tablero ) :
    def activaTodas( self ) :
        for pieza, piezaSC, siActiva in self.liPiezas :
            piezaSC.activa( True )
    def keyPressEvent( self, event ) :
        pass

    def mousePressEvent(self, event) :
        x = event.x()
        y = event.y()
        cx = self.punto2columna(x)
        cy = self.punto2fila(y)
        siEvent = True
        if cx in range( 1, 9 ) and cy in range( 1, 9 ) :
            a1h8 = self.num2alg( cy, cx )
            siIzq = event.button() == QtCore.Qt.LeftButton
            siDer = event.button() == QtCore.Qt.RightButton
            if self.casillas[a1h8] :
                self.parent().ultimaPieza = self.casillas[a1h8]
                #~ if siIzq :
                    #~ QtGui.QGraphicsView.mousePressEvent(self,event)
                if siDer :
                    self.mensBorrar( a1h8 )
                    siEvent = False
            else :
                if siDer :
                    self.mensCrear( a1h8 )
                    siEvent = False
                if siIzq :
                    self.mensRepetir( a1h8 )
                    siEvent = False
        if siEvent :
            QtGui.QGraphicsView.mousePressEvent(self,event)

    def ponDispatchDrop( self, dispatch ) :
        self.dispatchDrop = dispatch

    def dropEvent(self, event):
        if event.mimeData().hasFormat('image/x-lc-pieza'):
            pieza = event.mimeData().data('image/x-lc-pieza')
            p = event.pos()
            x = p.x()
            y = p.y()
            cx = self.punto2columna(x)
            cy = self.punto2fila(y)
            if cx in range( 1, 9 ) and cy in range( 1, 9 ) :
                a1h8 = self.num2alg( cy, cx )
                self.dispatchDrop( a1h8, str(pieza) )
            event.setDropAction(QtCore.Qt.IgnoreAction)
        event.ignore()

#==========================================================================================================================================

#==========================================================================================================================================
class TutTablero( Tablero ) :
    #--------------------------------------------------------------------------------------------------------------------------------------------
    def keyPressEvent( self, event ) :
        pass

    #--------------------------------------------------------------------------------------------------------------------------------------------
    def __init__(self, parent, confTablero ):
        super(TutTablero, self).__init__(parent, confTablero )
        self.ultGuerra = "",None

    #--------------------------------------------------------------------------------------------------------------------------------------------
    def mousePressEvent(self, event) :

        # Determinamos cual mover
        pa = event.pos()
        p = QtCore.QPointF( pa.x()-self.margenCentro, pa.y()-self.margenCentro)
        li = []
        for k,uno in self.dicMovibles.items() :
            if uno.contiene( p ) :
                li.append(uno)
            else :
                uno.activa(False)
        if li :
            if len(li) > 1 : # Guerra
                guerra = str(li)
                if self.ultGuerra[0] != guerra :
                    menu = Controles.LMenu(puntos=10)
                    icoAzul = Iconos.PuntoAzul()
                    for uno in li :
                        menu.opcion( uno, uno.nombre() + " %d"%(uno.idMovible), icoAzul )
                    p = QtGui.QCursor.pos()
                    elegido = menu.lanza()
                    if elegido is not None :
                        self.ultGuerra = guerra, elegido
                        QtGui.QCursor.setPos(p)
                    else :
                        self.ultGuerra = "", None
                    event.ignore()
                    return
                elegido = self.ultGuerra[1]
                self.ultGuerra = "", None
            else :
                elegido = li[0]

            for uno in li :
                uno.activa(uno == elegido)

            QtGui.QGraphicsView.mousePressEvent(self,event)
        else :
            event.ignore()

