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

#==========================================================================================================================================
import os
import copy

from PySide import QtGui

from Code.Traducir import tr

import Code.SQL as SQL
import Code.Tutoriales as Tutoriales
import Code.Tareas as Tareas
import Code.Configuracion as Configuracion
import Code.ControlPosicion as ControlPosicion
import Code.PGN as PGN

import QTUtil2
import Colocacion
import Iconos
import Controles
import Columnas
import Grid
import Tablero
import EntMaquina

import FormLayout

import PantallaPGN

#==========================================================================================================================================
def menu_insercion(  ) :
    menu = Controles.LMenu()

    f = Controles.TipoLetra( puntos=8, peso=75 )
    menu.ponFuente( f )

    ms = menu.submenu( tr("TUT_INSERCION"), Iconos.PuntoNaranja() )
    ms.opcion( "final", tr( "TUT_INSERCION_FINAL" ), Iconos.PuntoNaranja() )
    ms.opcion( "principio", tr( "TUT_INSERCION_PRINCIPIO" ), Iconos.PuntoNaranja() )
    ms.separador()
    ms.opcion( "antes_actual", tr( "TUT_INSERCION_ANTESACTUAL" ), Iconos.PuntoNaranja() )
    ms.opcion( "despues_actual", tr( "TUT_INSERCION_DESPUESACTUAL" ), Iconos.PuntoNaranja() )

    return menu.lanza()

#==========================================================================================================================================
class WET_EligeMovimientos( QtGui.QDialog ):

    def __init__( self, owner, partida ) :

        QtGui.QDialog.__init__(self, owner)

        self.setWindowTitle( tr("TUT_PARTIDA_ELEGIR") )

        self.configuracion = owner.configuracion

        self.owner = owner
        self.partida = partida
        self.siEmpiezaConNegras = partida.siEmpiezaConNegras
        siTodos = len(owner.liEscenas)==0
        self.liElegidos = [siTodos]*len(partida.liJugadas)

        liAcciones = [  ( tr( "ACEPTAR" ), Iconos.TB_Aceptar(), "mas" ), None,
                        ( tr( "CANCELAR" ), Iconos.TB_Cancelar(), "reject" ), None,
                        ( tr( "GM_MARCAR" ), Iconos.TB_Marcar(), "marcar" ), None,
                    ]
        tb = Controles.TB( self, liAcciones )

        # Tablero
        confTablero = Configuracion.ConfigTablero()
        confTablero.lee( self.configuracion.cTableroN.graba() )
        confTablero.anchoPieza = 32
        self.tablero = Tablero.TutTablero(self, confTablero)
        self.tablero.crea()
        self.tablero.desactivaTodas()

        # Pgn
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva( "ELEGIDO", "", 30, siCentrado = True, siChecked = True )
        oColumnas.nueva( "NUMERO", tr( "AB_NUM" ), 35, siCentrado = True )
        oColumnas.nueva( "BLANCAS", tr( "PGN_WHITE" ), 100, siCentrado = True )
        oColumnas.nueva( "NEGRAS", tr( "PGN_BLACK" ), 100, siCentrado = True )
        self.pgn = Grid.Grid( self, oColumnas, siCabeceraMovible = False, siSelecFilas=True )
        nAnchoPgn = self.pgn.anchoColumnas() + 20
        self.pgn.setMinimumWidth( nAnchoPgn )
        self.pgn.gotop()

        ly = Colocacion.H().control(self.tablero).control(self.pgn)

        layout = Colocacion.V().control(tb).otro(ly)
        self.setLayout(layout)
        self.pgn.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        accion = self.sender().clave
        eval( "self.%s()"%accion )

    #--------------------------------------------------------------------------------------------------------------------------------
    def mas( self ) :
        self.donde = "final"
        if self.owner.liEscenas :

            resp = menu_insercion()
            if resp is None :
                return

            self.donde = resp

        self.accept()

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridNumDatos( self, grid ) :
        return len(self.partida.liJugadas)

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridDato( self, grid, fila, oColumna ) :
        clave = oColumna.clave
        if clave == "ELEGIDO" :
            return self.liElegidos[fila]
        elif clave == "NUMERO" :
            if self.siEmpiezaConNegras :
                fila += 1
            return str(fila/2+1)
        else :
            valor = self.partida.liJugadas[fila].pgnSP()
            siBlancas = self.partida.liJugadas[fila].posicionBase.siBlancas
            if clave == "BLANCAS" :
                return valor if siBlancas else ""
            else :
                return valor if not siBlancas else ""

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridPonValor( self, grid, fila, oColumna, valor ) :
        self.liElegidos[fila] = valor

    #--------------------------------------------------------------------------------------------------------------------------------
    def marcar( self ) :
        menu = Controles.LMenu()
        f = Controles.TipoLetra( puntos=8, peso=75 )
        menu.ponFuente( f )
        menu.opcion( 1, tr("GM_MARCARTODOS"), Iconos.PuntoVerde() )
        menu.opcion( 2, tr("GM_MARCARNINGUNO"), Iconos.PuntoNaranja() )
        resp = menu.lanza()
        if resp :
            for n in range(len(self.liElegidos)) :
                self.liElegidos[n] = resp == 1
            self.pgn.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridCambiadoRegistro( self, grid, fil, columna ) :
        jg = self.partida.liJugadas[fil]
        self.tablero.ponPosicion( jg.posicion )
        self.tablero.ponFlechaSC( jg.desde, jg.hasta )
        self.pgn.setFocus()

#==========================================================================================================================================
class WET_Escenas( QtGui.QWidget ):

    def __init__( self, owner ) :

        QtGui.QWidget.__init__(self,owner)

        self.owner = owner
        self.tutorial = owner.tutorial
        self.liEscenas = self.tutorial.liEscenas
        self.escenaActual = None
        self.configuracion = owner.procesador.configuracion
        self.tab = owner.tab

        self.posicion = ControlPosicion.ControlPosicion()

        f = Controles.TipoLetra( puntos=12, peso = 75 )
        flb = Controles.TipoLetra( puntos=8 )
        f10 = Controles.TipoLetra( puntos=10, peso = 60 )

        liAcciones = [  ( tr( "NUEVO" ), Iconos.TB_Nuevo(), "masE" ), None,
                        ( tr( "BORRAR" ), Iconos.TB_Borrar(), "borrarE" ), None,
                        ( tr( "MODIFICAR" ), Iconos.TB_Modificar(), "modificarE" ), None,
                        ( tr( "COPIAR" ), Iconos.TB_Copiar(), "copiarE" ), None,
                        ( tr( "ARRIBA" ), Iconos.TB_Arriba(), "arribaE" ), None,
                        ( tr( "ABAJO" ), Iconos.TB_Abajo(), "abajoE" ), None,
                    ]
        tbEscenas = Controles.TB( self, liAcciones, siTexto = False, tamIcon=24 )
        tbEscenas.setFont( flb )

        # Escenas
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva( "NUMERO", tr( "AB_NUM" ), 60, siCentrado=True )
        oColumnas.nueva( "NOMBRE", tr( "TIT_NOMBRE" ), 235 )
        self.gridEscenas = None # Si no da error al comparar
        self.gridEscenas = Grid.Grid( self, oColumnas, siCabeceraMovible = False, id = "E", siSelecFilas=True )
        nAncho = self.gridEscenas.anchoColumnas() + 20
        self.gridEscenas.setMinimumWidth( nAncho)

        ly = Colocacion.V().control(tbEscenas).control(self.gridEscenas)
        gbEscenas = Controles.GB(self,tr("TUT_ESCENAS"),ly ).ponFuente( f )

        # Tablero
        confTablero = Configuracion.ConfigTablero()
        confTablero.lee( self.configuracion.cTableroN.graba() )
        confTablero.anchoPieza = 32
        self.confTablero = confTablero
        self.tablero = Tablero.TutTablero(self, confTablero)
        self.tablero.crea()

        # Tareas
        liAcciones = [  ( tr( "NUEVO" ), Iconos.TB_Nuevo(), "masT" ), None,
                        ( tr( "BORRAR" ), Iconos.TB_Borrar(), "borrarT" ), None,
                        ( tr( "MODIFICAR" ), Iconos.TB_Modificar(), "modificarT" ), None,
                        ( tr( "COPIAR" ), Iconos.TB_Copiar(), "copiarT" ), None,
                        ( tr( "ARRIBA" ), Iconos.TB_Arriba(), "arribaT" ), None,
                        ( tr( "ABAJO" ), Iconos.TB_Abajo(), "abajoT" ), None,
                    ]
        tbTareas = Controles.TB( self, liAcciones, siTexto = False, tamIcon=24 )
        tbTareas.setFont( flb )

        # Tareas
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva( "NUMERO", tr( "AB_NUM" ), 40, siCentrado=True )
        oColumnas.nueva( "TAREA", tr( "TUT_TAREA" ), 210 )
        self.gridTareas = Grid.Grid( self, oColumnas, siCabeceraMovible = False, id = "T", siSelecFilas=True )
        nAncho = self.gridTareas.anchoColumnas() + 20
        self.gridTareas.setMinimumWidth(nAncho)

        ly = Colocacion.V().control(tbTareas).control(self.gridTareas)
        self.gbTareas = Controles.GB(self,tr("TUT_TAREAS"),ly ).ponFuente( f10 ).alinCentrado()

        # Layout
        layout = Colocacion.H().control(gbEscenas).control(self.gbTareas).control(self.tablero)
        self.setLayout( layout )

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        accion = self.sender().clave
        eval( "self.%s()"%accion )

    #--------------------------------------------------------------------------------------------------------------------------------
    def masE( self ) :
        menu = Controles.LMenu()

        f = Controles.TipoLetra( puntos=8, peso=75 )
        menu.ponFuente( f )

        menu.opcion( "posicion", tr("TUT_ESCENA_POSICION"), Iconos.PuntoNaranja() )
        menu.separador()

        if self.tutorial.liTPartidas :

            ms = menu.submenu( tr("TUT_ESCENA_PARTIDA"), Iconos.PuntoNaranja() )

            for npart, tpart in enumerate(self.tutorial.liTPartidas) :
                ms.opcion( "partida_%d"%npart, tpart.nombre(), Iconos.PuntoAzul() )

            ms.opcion( "partida_-1", tr("TUT_PARTIDA_BUSCAR"), Iconos.PuntoNaranja() )
        else :
            menu.opcion( "partida_-1", tr("TUT_ESCENA_PARTIDA"), Iconos.PuntoNaranja() )

        resp = menu.lanza()
        if resp is None :
            return

        elif resp == "posicion" :
            self.escenaPosicion(  )

        elif resp.startswith("partida") :
            self.escenasPartida( int(resp[8:]) )

    #--------------------------------------------------------------------------------------------------------------------------------
    def masT( self ) :
        # Menu :
        # flecha
        # recuadro
        # pieza
        ### crear
        ### mover
        #### por tiempo
        #### directo
        ### borrar
        # tiempo

        if self.escenaActual is None :
            return

        menu = Controles.LMenu()

        f = Controles.TipoLetra( puntos=8, peso=75 )
        menu.ponFuente( f )

        menu.opcion( "f", tr("TUT_FLECHA"), Iconos.PuntoNaranja() )
        menu.separador()
        menu.opcion( "m", tr("TUT_MARCO"), Iconos.PuntoNaranja() )

        menu.separador()
        smenu = menu.submenu( tr( "ORDEN_PIEZA" ), Iconos.PuntoNaranja() )
        smenu.opcion( "pc", tr( "TUT_MENU_CREAR" ), Iconos.PuntoNaranja() )

        m_menu = smenu.submenu( tr( "TUT_MENU_MOVER" ), Iconos.PuntoNaranja() )
        m_menu.opcion( "pmi", tr( "TUT_MENU_MOVER_INMEDIATO" ), Iconos.PuntoNaranja() )
        m_menu.opcion( "pmt", tr( "TUT_MENU_MOVER_TIEMPO" ), Iconos.PuntoNaranja() )

        smenu.opcion( "pb", tr( "TUT_MENU_BORRAR" ), Iconos.PuntoNaranja() )

        resp = menu.lanza()
        if resp is None :
            return

        elif resp == "f" :
            self.editaFlecha( -1 )

        elif resp == "m" :
            self.editaMarco( -1 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def flechaTransicion( self ) :
        siCreada, pFlechaTransicion = self.tutorial.dame_pFlechaTransicion(self.configuracion)
        if siCreada :
            self.owner.refreshFlechas()
        return pFlechaTransicion

    #--------------------------------------------------------------------------------------------------------------------------------
    def editaFlecha( self, numTarea ) :
        if numTarea == -1 :
            idFlecha = self.flechaTransicion().id
            desde = "a1"
            hasta = "b3"
        else :
            tarea = self.escenaActual.liTareas[numTarea]
            desde = tarea.desde
            hasta = tarea.hasta

        liGen = [ (None,None) ]

        # Lista de flechas
        liF = [ ( flecha.nombre, flecha.id ) for flecha in self.tutorial.liPFlechas ]

        config = FormLayout.Combobox( tr( "TUT_FLECHA" ), liF )
        liGen.append( ( config, idFlecha ) )

        config = FormLayout.Casillabox( tr( "TUT_DESDE" ) )
        liGen.append( ( config, desde ) )

        config = FormLayout.Casillabox( tr( "TUT_HASTA" ) )
        liGen.append( ( config, hasta ) )

        resultado = FormLayout.fedit( liGen, title= tr( "TUT_FLECHA" ), parent = self, siDefecto = False )
        if resultado :
            resp = resultado[1]
            idFlecha = resp[0]
            desde = resp[1]
            hasta = resp[2]
            if desde != hasta :
                if numTarea == -1 :
                    t = Tareas.TareaCreaFlecha( self.tutorial, desde, hasta, idFlecha )
                    self.escenaActual.liTareas.append( t )
                    self.gridTareas.refresh()
                    self.gridTareas.gobottom()
                else :
                    tarea.desde = desde
                    tarea.hasta = hasta
                    tarea.idFlecha = idFlecha

            self.gridTareas.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def editaMarco( self, numTarea ) :
        if numTarea == -1 :
            idMarco = self.flechaTransicion().id
            desde = "a1"
            hasta = "b3"
        else :
            tarea = self.escenaActual.liTareas[numTarea]
            desde = tarea.desde
            hasta = tarea.hasta

        liGen = [ (None,None) ]

        # Lista de flechas
        liF = [ ( flecha.nombre, flecha.id ) for flecha in self.tutorial.liPMarcos ]

        config = FormLayout.Combobox( tr( "TUT_MARCO" ), liF )
        liGen.append( ( config, idMarco ) )

        config = FormLayout.Casillabox( tr( "TUT_DESDE" ) )
        liGen.append( ( config, desde ) )

        config = FormLayout.Casillabox( tr( "TUT_HASTA" ) )
        liGen.append( ( config, hasta ) )

        resultado = FormLayout.fedit( liGen, title= tr( "TUT_MARCO" ), parent = self, siDefecto = False )
        if resultado :
            resp = resultado[1]
            idMarco = resp[0]
            desde = resp[1]
            hasta = resp[2]
            if desde != hasta :
                if numTarea == -1 :
                    t = Tareas.TareaCreaMarco( self.tutorial, desde, hasta, idMarco )
                    self.escenaActual.liTareas.append( t )
                    self.gridTareas.refresh()
                    self.gridTareas.gobottom()
                else :
                    tarea.desde = desde
                    tarea.hasta = hasta
                    tarea.idMarco = idMarco

            self.gridTareas.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def borrarE( self ) :
        fila = self.gridEscenas.recno()
        if fila >= 0 :
            if QTUtil2.pregunta( self, tr( "TUT_BORRAMOS_ESCENA", self.liEscenas[fila].nombre )) :
                del self.liEscenas[fila]
                self.gridEscenas.refresh()
                self.gridEscenas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def borrarT( self ) :
        if self.escenaActual :
            fila = self.gridTareas.recno()
            if fila >= 0 :
                if QTUtil2.pregunta( self, tr( "TUT_BORRAMOS_TAREA", self.escenaActual.liTareas[fila].nombre )) :
                    del self.escenaActual.liTareas[fila]
                    self.gridTareas.refresh()
                    self.gridTareas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def copiarE( self ) :
        fila = self.gridEscenas.recno()
        if fila >= 0 :
            regEscena = copy.deepcopy( self.liEscenas[fila] )
            n = 1
            nombre = "%s-%d"%(regEscena.nombre, n )
            while self.siEstaNombre( nombre ) :
                n+=1
                nombre = "%s-%d"%(regEscena.nombre, n )
            regEscena.nombre = nombre
            regEscena.id = self.tutorial.idNuevo()
            self.liEscenas.append(regEscena)
            self.gridEscenas.refresh()
            self.gridEscenas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def copiarT( self ) :
        fila = self.gridTareas.recno()
        if fila >= 0 :
            regTarea = copy.deepcopy( self.escenaActual.liTareas[fila] )
            regTarea.id = self.tutorial.idNuevo()
            self.escenaActual.liTareas.append(regTarea)
            self.gridTareas.refresh()
            self.gridTareas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def arribaE( self ) :
        fila = self.gridEscenas.recno()
        if fila > 0 :
            self.liEscenas[fila-1],self.liEscenas[fila] = self.liEscenas[fila],self.liEscenas[fila-1]
            self.gridEscenas.goto(fila-1,0)
            self.gridEscenas.refresh()
            self.gridEscenas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def arribaT( self ) :
        fila = self.gridTareas.recno()
        if fila > 0 :
            liTareas = self.escenaActual.liTareas
            liTareas[fila-1],liTareas[fila] = liTareas[fila],liTareas[fila-1]
            self.gridTareas.goto(fila-1,0)
            self.gridTareas.refresh()
            self.gridTareas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def abajoE( self ) :
        fila = self.gridEscenas.recno()
        if fila >= 0 and fila < (len(self.liEscenas)-1) :
            self.liEscenas[fila+1],self.liEscenas[fila] = self.liEscenas[fila],self.liEscenas[fila+1]
            self.gridEscenas.goto(fila+1,0)
            self.gridEscenas.refresh()
            self.gridEscenas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def abajoT( self ) :
        fila = self.gridTareas.recno()
        if fila > 0 :
            liTareas = self.escenaActual.liTareas
            if fila < (len(liTareas)-1) :
                liTareas[fila-1],liTareas[fila] = liTareas[fila],liTareas[fila-1]
                self.gridTareas.goto(fila-1,0)
                self.gridTareas.refresh()
                self.gridTareas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridNumDatos( self, grid ) :
        if grid == self.gridEscenas :
            return len(self.liEscenas)
        else :
            if self.liEscenas :
                fila = self.gridEscenas.recno()
                if fila >= 0 :
                    return len(self.liEscenas[fila].liTareas)
        return 0

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridCambiadoRegistro( self, grid, fila, columna ) :
        if grid == self.gridEscenas :
            self.escenaActual = self.liEscenas[fila]
            self.gbTareas.ponTexto( "(%d) %s"%(fila+1,self.escenaActual.nombre) )

            self.posicion.leeFen( self.escenaActual.fen )
            self.tablero.ponPosicion( self.posicion )
            self.gridTareas.gobottom()
            self.gridCambiadoRegistro( self.gridTareas, self.gridTareas.recno(), 0 )
            self.gridEscenas.setFocus()
        else :

            self.posicion.leeFen( self.escenaActual.fen )
            self.tablero.reset(self.confTablero)
            self.tablero.ponPosicion( self.posicion )
            for ntarea in range(fila+1) :
                tarea = self.escenaActual.liTareas[ntarea]
                if hasattr( tarea, "directo" ) :
                    tarea.directo( self.tablero )
                    if hasattr( tarea, "scFlecha" ) :
                        tarea.scFlecha.ponRutinaPulsada( self.dispatch, tarea )
                    elif hasattr( tarea, "scMarco" ) :
                        tarea.scMarco.ponRutinaPulsada( self.dispatch, tarea )
            self.tablero.refresh()
            self.gridTareas.refresh()
            self.gridTareas.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def dispatch( self, tarea ) :
        if hasattr( tarea, "scFlecha" ) :
            a1h8 = tarea.scFlecha.bloqueDatos.a1h8
            tarea.desde = a1h8[:2]
            tarea.hasta = a1h8[2:]
        elif hasattr( tarea, "scMarco" ) :
            a1h8 = tarea.scMarco.bloqueDatos.a1h8
            tarea.desde = a1h8[:2]
            tarea.hasta = a1h8[2:]
        self.gridTareas.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridDato( self, grid, fila, oColumna ) :
        clave = oColumna.clave
        if clave == "NUMERO" :
            return "%d"%(fila+1,)
        if grid == self.gridEscenas :
            escena = self.liEscenas[fila]
            if clave == "NOMBRE" :
                return escena.nombre
        else :
            if self.escenaActual :
                if clave == "TAREA" :
                    return str(self.escenaActual.liTareas[fila])
        return ""

    #--------------------------------------------------------------------------------------------------------------------------------
    def siEstaNombre( self, nombre ) :
        for rf in self.liEscenas :
            if rf.nombre == nombre :
                return True
        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def escenasPartida( self, nPartida ) :

        siBuscarNueva = nPartida == -1

        # Si se ha elegido una partida grabada
        if not siBuscarNueva :
            tpart = self.tutorial.liTPartidas[nPartida]
            partida = tpart.partida
            idPartida = tpart.id

        # Buscamos una partida en un fichero PGN
        else :
            idPartida = None

            # Elegimos el fichero PGN
            path = QTUtil2.leeFichero( self, self.configuracion.dirPGN, "pgn" )
            if path is None :
                return
            carpeta, fichero = os.path.split(path)
            if self.configuracion.dirPGN != carpeta :
                self.configuracion.dirPGN = carpeta
                self.configuracion.graba()

            # Lo importamos
            fpgn = PGN.PGN()

            self.tmpProceso = 0
            self.tmpBP = None

            def control( proceso, porcentaje ) :
                if proceso != self.tmpProceso :
                    if self.tmpProceso > 0 :
                        self.tmpBP.cerrar()
                        if proceso == 3 : #Nos ha mandado la seņal de final
                            return True
                    self.tmpProceso = proceso
                    rotulo = tr( "PGN_F1LEYENDO", path ) if proceso == 1 else tr( "PGN_F2CONVIRTIENDO", path )
                    self.tmpBP = QTUtil2.BarraProgreso( self, rotulo,rotulo, 100 ).mostrar()
                self.tmpBP.pon( porcentaje )
                return not self.tmpBP.siCancelado()

            dicDB = fpgn.leeFichero( path, control )
            if dicDB is None :
                return

            # Los datos los tenemos en una BD.sql
            dClaves = dicDB["DICCLAVES"]

            bd = SQL.Base.DBBase( dicDB["PATHDB"] )

            dbf = bd.dbf( "JUEGOS", ",".join(dClaves.keys()) +",JUGADAS" )

            siSeguir, estadoWpgn, siSeHaBorradoAlgo = PantallaPGN.elegirPGN( self, dbf, dClaves, self, None )
            if siSeguir :
                reg = dbf.dicValores()

            dbf.cerrar()

            bd.cerrar()

            if not siSeguir :
                return

            pgn = ""
            for k,v in reg.iteritems() :
                if k != "JUGADAS" :
                    pgn += '[%s "%s"]\n'%( k, v)
            pgn += reg["JUGADAS"]

            unpgn = PGN.UnPGN()
            unpgn.leeTexto(pgn)

            partida = unpgn.partida

        w = WET_EligeMovimientos(self,partida)
        if w.exec_() :

            dondeInsertar = w.donde
            if dondeInsertar == "principio" :
                nposIns = 0
            elif dondeInsertar == "despues_actual" :
                nposIns = self.gridEscenas.recno()+1
                if nposIns == len(self.liEscenas) :
                    dondeInsertar = "final"
            elif dondeInsertar == "antes_actual" :
                nposIns = self.gridEscenas.recno()

            liElegidos = w.liElegidos
            liJugadas = partida.liJugadas
            if siBuscarNueva :
                idPartida = self.tutorial.buscaIdPartida( unpgn ) # Tambien la aņade si es necesario
            vTransicion = self.tutorial.dame_vTransicion()
            pFlechaTransicion = self.flechaTransicion()

            for n in range(len(liElegidos)) :
                if liElegidos[n] :
                    escena = Tutoriales.Escena()
                    fil = n
                    if partida.siEmpiezaConNegras :
                        fil += 1
                    txt = "%d. "%(fil/2+1)
                    if fil%2 == 1 :
                        txt += "... "
                    txt += liJugadas[n].pgnSP()
                    escena = Tutoriales.Escena()
                    escena.id = self.tutorial.idNuevo()
                    escena.nombre = txt
                    jg = liJugadas[n]
                    escena.fen = jg.posicionBase.fen()
                    escena.idPartida = idPartida
                    escena.numJugada = n

                    t = Tareas.TareaMuevePiezaV( jg.desde, jg.hasta, vTransicion )
                    escena.liTareas.append( t )

                    # Movimientos adicionales
                    if len( jg.liMovs ) > 2 :
                        for op in jg.liMovs[2:] :
                            tp = op[0]
                            if tp == "m" :
                                t = Tareas.TareaMuevePieza( op[1], op[2] )
                            elif tp == "b" :
                                t = Tareas.TareaBorraPieza( op[1] )
                            elif tp == "c" :
                                t = Tareas.TareaCambiaPieza( op[1], op[2] )
                            escena.liTareas.append( t )

                    t = Tareas.TareaCreaFlecha( self.tutorial, jg.desde, jg.hasta, pFlechaTransicion.id )
                    escena.liTareas.append( t )

                    if dondeInsertar == "final" :
                        self.liEscenas.append( escena )
                    else :
                        self.liEscenas.insert( nposIns, escena )
                        nposIns += 1

            self.gridEscenas.refresh()
            if dondeInsertar == "final" :
                self.gridEscenas.gobottom()
            else :
                self.gridEscenas.goto(nposIns-1,0)

            self.gridEscenas.setFocus()
            self.gridCambiadoRegistro( self.gridEscenas, self.gridEscenas.recno(), 0 )
    #--------------------------------------------------------------------------------------------------------------------------------
    def escenaPosicion( self ) :
        fen = EntMaquina.editarPosicion( self, self.configuracion, None )
        if fen is not None :
            if fen == "" :
                cp = ControlPosicion.ControlPosicion()
                cp.posInicial()
                fen = cp.fen()
            escena = Tutoriales.Escena()
            escena.id = self.tutorial.idNuevo()
            escena.fen = fen

            if self.liEscenas :
                resp = menu_insercion()
                if resp is None :
                    return
            else :
                resp = "final"
            if resp == "principio" :
                nposIns = 0
            elif resp == "despues_actual" :
                nposIns = self.gridEscenas.recno()+1
                if nposIns == len(self.liEscenas) :
                    resp = "final"
            elif resp == "antes_actual" :
                nposIns = self.gridEscenas.recno()

            if resp == "final" :
                self.liEscenas.append( escena )
                nposIns = len(self.liEscenas)-1
            else :
                self.liEscenas.insert( nposIns, escena )

            escena.nombre = tr( "TUT_ESCENA", str(nposIns+1) )

            self.gridEscenas.goto(nposIns,0)
            self.gridEscenas.setFocus()
            self.gridEscenas.refresh()
            # self.gridCambiadoRegistro( self.gridEscenas, nposIns, 0 )

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