def haz_menu(frommenu, part):
liOp = self.dbop.getOtras(self.configuracion, part)
if liOp:
otra = frommenu.submenu(_("Other opening lines"),
Iconos.OpeningLines())
for fichero, titulo in liOp:
otra.opcion(("ol", (fichero, part)), titulo,
Iconos.PuntoVerde())
frommenu.separador()
frommenu.opcion(("pgn", part), _("PGN with variants"),
Iconos.Tablero())
frommenu.separador()
frommenu.opcion(("polyglot", part), _("Polyglot book"),
Iconos.Libros())
frommenu.separador()
frommenu.opcion(("summary", part), _("Database summary"),
Iconos.DatabaseC())
frommenu.separador()
frommenu.opcion(("voyager2", part), _("Voyager 2"),
Iconos.Voyager1())
frommenu.separador()
frommenu.opcion(("opening", part), _("Opening"), Iconos.Apertura())
def __init__(self, owner, listaAperturasStd, dicDatos):
icono = Iconos.Apertura()
titulo = _("Learn openings by repetition")
extparam = "opentrainingE"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
nombre = dicDatos.get("NOMBRE", "")
self.listaAperturasStd = listaAperturasStd
self.liBloques = self.leeBloques(dicDatos.get("LISTA", []))
# Toolbar
liAcciones = [(_("Accept"), Iconos.Aceptar(), self.aceptar), None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar), None,
(_("Add"), Iconos.Nuevo(), self.nueva), None,
(_("Modify"), Iconos.Modificar(), self.modificar), None,
(_("Remove"), Iconos.Borrar(), self.borrar), None,
]
tb = Controles.TBrutina(self, liAcciones)
lbNombre = Controles.LB(self, _("Name") + ": ")
self.edNombre = Controles.ED(self, nombre)
lyNombre = Colocacion.H().control(lbNombre).control(self.edNombre)
# Lista
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("NOMBRE", _("Name"), 240)
oColumnas.nueva("PGN", _("Moves"), 360)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True)
n = self.grid.anchoColumnas()
self.grid.setMinimumWidth(n + 20)
self.registrarGrid(self.grid)
self.grid.gotop()
layout = Colocacion.V().control(tb).otro(lyNombre).control(self.grid)
self.setLayout(layout)
self.recuperarVideo()
def tw_filtrar(self):
xpv = None
if self.summaryActivo and "pv" in self.summaryActivo:
li = self.summaryActivo["pv"].split(" ")
if len(li) > 1:
xpv = " ".join(li[:-1])
def refresh():
self.grid.refresh()
self.grid.gotop()
self.updateStatus()
self.gridCambiadoRegistro(None, 0, 0)
def standard():
w = PantallaPGN.WFiltrar(self, self.grid.oColumnas, self.liFiltro, self.dbGames.nomFichero)
if w.exec_():
self.liFiltro = w.liFiltro
self.where = w.where()
self.dbGames.filterPV(xpv, self.where)
refresh()
def raw_sql():
w = PantallaPGN.WFiltrarRaw(self, self.grid.oColumnas, self.where)
if w.exec_():
self.where = w.where
self.dbGames.filterPV(xpv, self.where)
refresh()
def opening():
me = QTUtil2.unMomento(self)
import Code.QT.PantallaAperturas as PantallaAperturas
w = PantallaAperturas.WAperturas(self, self.configuracion, self.last_opening)
me.final()
if w.exec_():
self.last_opening = ap = w.resultado()
pv = getattr(ap, "a1h8", "")
self.dbGames.filterPV(pv)
self.numJugada = pv.count(" ")
refresh()
def remove():
self.dbGames.filterPV("")
self.where = None
refresh()
menu = QTVarios.LCMenu(self)
menu.opcion(standard, _("Standard"), Iconos.Filtrar())
menu.separador()
menu.opcion(raw_sql, _("Advanced"), Iconos.SQL_RAW())
menu.separador()
menu.opcion(opening, _("Opening"), Iconos.Apertura())
if self.dbGames.filter is not None and self.dbGames.filter:
menu.separador()
menu.opcion(remove, _("Remove filter"), Iconos.Cancelar())
# menu.opcion(vopening, _("Various openings"), Iconos.Apertura())
# menu.separador()
# menu.opcion(sample, _("Select a sample"), Iconos.Apertura())
# menu.separador()
resp = menu.lanza()
if resp:
resp()
def creaMenu(self):
dicMenu = {}
menu = QTVarios.LCMenu(self.parent)
def xopcion(menu, clave, texto, icono, siDeshabilitado=False):
menu.opcion(clave, texto, icono, siDeshabilitado)
dicMenu[clave] = (clave, texto, icono, siDeshabilitado)
# Posiciones de entrenamiento --------------------------------------------------------------------------
self.menuFNS(menu, _("Training positions"), xopcion)
menu.separador()
# GM ---------------------------------------------------------------------------------------------------
xopcion(menu, "gm", _("Play like a grandmaster"), Iconos.GranMaestro())
menu.separador()
# Mate --------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Training mates"), Iconos.Mate())
for mate in range(1, 5):
xopcion(menu1, "mate%d" % mate, _X(_("Mate in %1"), str(mate)),
Iconos.PuntoAzul())
menu1.separador()
menu.separador()
# BMT -------------------------------------------------------------------------------------------
xopcion(menu, "bmt", _("Find best move"), Iconos.BMT())
menu.separador()
# Resistencia ------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Resistance Test"), Iconos.Resistencia())
nico = Util.Rondo(Iconos.Verde(), Iconos.Azul(), Iconos.Amarillo(),
Iconos.Naranja())
xopcion(menu1, "resistance", _("Normal"), nico.otro())
xopcion(menu1, "resistancec", _("Blindfold chess"), nico.otro())
xopcion(menu1, "resistancep1", _("Hide only our pieces"), nico.otro())
xopcion(menu1, "resistancep2", _("Hide only opponent pieces"),
nico.otro())
menu.separador()
# DailyTest ------------------------------------------------------------------------------------------------
xopcion(menu, "dailytest", _("Your daily test"), Iconos.DailyTest())
menu.separador()
# Tacticas ---------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Learn tactics by repetition"),
Iconos.Tacticas())
nico = Util.Rondo(Iconos.Amarillo(), Iconos.Naranja(), Iconos.Verde(),
Iconos.Azul(), Iconos.Magenta())
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
def menuTacticas(tipo, carpetaBase):
lista = []
if os.path.isdir(carpetaBase):
li = Util.listdir(carpetaBase)
for nombre in li:
carpeta = os.path.join(carpetaBase, nombre)
ini = os.path.join(carpeta, "Config.ini")
if os.path.isdir(carpeta) and os.path.isfile(ini):
xopcion(
menu1, "tactica|%s|%s|%s|%s" %
(tipo, nombre, carpeta, ini), trTraining(nombre),
nico.otro())
menu1.separador()
lista.append((carpeta, nombre))
return lista
menuTacticas("B", "Tactics")
carpetaTacticasP = os.path.join(self.configuracion.dirPersonalTraining,
"Tactics")
lista = menuTacticas("P", carpetaTacticasP)
if lista:
ico = Iconos.Delete()
menub = menu1.submenu(_("Remove"), ico)
for carpeta, nombre in lista:
xopcion(menub, "remtactica|%s|%s" % (carpeta, nombre),
trTraining(nombre), ico)
menu.separador()
# Openings ------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
# # Aperturas --------------------------------------------------------------------------------------------
xopcion(menu1, "aperturas", _("Learn openings by repetition"),
Iconos.Apertura())
menu1.separador()
# Books ------------------------------------------------------------------------------------------------
xopcion(menu1, "polyglot", _("Training with a book"), Iconos.Libros())
# Ratings
menu.separador()
menu1 = menu.submenu(_("Training ratings"), Iconos.Elo())
xopcion(menu1, "lucaselo",
"%s (%d)" % (_("Lucas-Elo"), self.configuracion.eloNC),
Iconos.Elo())
menu1.separador()
xopcion(menu1, "micelo",
"%s (%d)" % (_("Tourney-Elo"), self.configuracion.micheloNC),
Iconos.EloTimed())
menu1.separador()
fics = self.configuracion.ficsNC
menuf = menu1.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <=
(fics - elo) <= 400):
xopcion(menuf, "fics%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
menu1.separador()
fide = self.configuracion.fideNC
menuf = menu1.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
rp = QTVarios.rondoPuntos()
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <=
(fide - elo) <= 400):
xopcion(menuf, "fide%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
menu.separador()
# Longs ----------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Long-term trainings"), Iconos.Longhaul())
# Maps
menu2 = menu1.submenu(_("Training on a map"), Iconos.Maps())
xopcion(menu2, "map_Africa", _("Africa map"), Iconos.Africa())
menu2.separador()
xopcion(menu2, "map_WorldMap", _("World map"), Iconos.WorldMap())
# Rail
menu1.separador()
xopcion(menu1, "transsiberian", _("Transsiberian Railway"),
Iconos.Train())
# Everest
menu1.separador()
xopcion(menu1, "everest", _("Expeditions to the Everest"),
Iconos.Trekking())
# TOL
menu1.separador()
menu2 = menu1.submenu(_("Turn on the lights"), Iconos.TOL())
xopcion(menu2, "tol_uned", _("UNED chess school"), Iconos.Uned())
menu2.separador()
xopcion(menu2, "tol_uwe", _("Uwe Auerswald"), Iconos.Uwe())
# Washing
menu1.separador()
xopcion(menu1, "washing_machine", _("The Washing Machine"),
Iconos.WashingMachine())
# Cebras ---------------------------------------------------------------------------------------------------
menu.separador()
menu1 = menu.submenu(_("Resources for zebras"), Iconos.Cebra())
menu2 = menu1.submenu(_("Check your memory on a chessboard"),
Iconos.Memoria())
rival = self.configuracion.rival
mem = Memoria.Memoria(self.procesador)
for x in range(6):
cat = rival.categorias.numero(x)
txt = cat.nombre()
nm = mem.nivel(x)
if nm > -1:
txt += " %s %d" % (_("Level"), nm + 1)
xopcion(menu2,
-100 - x,
txt,
cat.icono(),
siDeshabilitado=not mem.siActiva(x))
menu1.separador()
menu2 = menu1.submenu(_("Find all moves"), Iconos.J60())
xopcion(menu2, "j60_rival", _("Opponent"), Iconos.PuntoNaranja())
xopcion(menu2, "j60_jugador", _("Player"), Iconos.PuntoAzul())
menu1.separador()
self.horsesDef = hd = {
1: ("N", "Alpha", _("Basic test")),
2: ("p", "Fantasy", _("Four pawns test")),
3: ("Q", "Pirat", _("Jonathan Levitt test")),
4: ("n", "Spatial", _("Basic test") + ": a1"),
5: ("N", "Cburnett", _("Basic test") + ": e4")
}
menu2 = menu1.submenu(_("Becoming a knight tamer"),
self.procesador.tablero.piezas.icono("N"))
vicon = VarGen.todasPiezas.icono
icl, icn, tit = hd[1]
menu3 = menu2.submenu(tit, vicon(icl, icn))
xopcion(menu3, "horses_1", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[4]
xopcion(menu3, "horses_4", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[5]
xopcion(menu3, "horses_5", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[2]
xopcion(menu2, "horses_2", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[3]
xopcion(menu2, "horses_3", tit, vicon(icl, icn))
menu1.separador()
menu2 = menu1.submenu(_("Moves between two positions"),
Iconos.Puente())
rp = QTVarios.rondoPuntos()
for x in range(1, 11):
xopcion(menu2, "puente_%d" % x, "%s %d" % (_("Level"), x),
rp.otro())
menu1.separador()
xopcion(menu1, "potencia", _("Determine your calculating power"),
Iconos.Potencia())
menu1.separador()
menu2 = menu1.submenu(_("Learn a game"), Iconos.School())
xopcion(menu2, "learnPGN", _("Memorizing their moves"),
Iconos.LearnGame())
menu2.separador()
xopcion(menu2, "playPGN", _("Playing against"), Iconos.Law())
menu1.separador()
xopcion(menu1, "visualiza", _("The board at a glance"), Iconos.Gafas())
# menu2 = menu1.submenu(_("Endings with 3/4 pieces"), Iconos.Puente())
# xopcion(menu2, "end_t4-1", "%s %d"%(_("Level"), 1), Iconos.PuntoAzul())
# xopcion(menu2, "end_t4-2", "%s %d"%(_("Level"), 2), Iconos.PuntoMagenta())
return menu, dicMenu
def tools(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion("juega_solo", _("Create your own game"),
Iconos.JuegaSolo())
menu.separador()
menu1 = menu.submenu(_("PGN viewer"), Iconos.PGN())
menu1.opcion("pgn_paste", _("Paste PGN"), Iconos.Pegar())
menu1.separador()
menu1.opcion("pgn_fichero", _("Read PGN"), Iconos.Fichero())
menu1.separador()
menu1.opcion("pgn_jugadadia", _("Game of the day"), Iconos.LM())
menu1.separador()
if self.configuracion.liTrasteros:
menu1.opcion("pgn_trasteros", _("Boxrooms PGN"),
Iconos.Trasteros())
menu1.separador()
if self.configuracion.salvarFichero and Util.existeFichero(
self.configuracion.salvarFichero):
menu1.opcion("pgn_nuestroFichero", _("My games"),
Iconos.NuestroFichero())
menu.separador()
menu1 = menu.submenu(_("Database"), Iconos.Database())
menu1.opcion("database", _("Complete games"), Iconos.DatabaseC())
# menu1.separador()
# menu1.opcion("databaseFEN", _("Positions"), Iconos.DatabaseF()) # TODO
menu.separador()
menu.opcion("manual_save", _("Save positions to FNS/PGN"),
Iconos.ManualSave())
menu.separador()
menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
menu1.opcion("aperturaspers", _("Custom openings"), Iconos.Apertura())
menu1.separador()
menu1.opcion("bookguide", _("Personal Opening Guide"),
Iconos.BookGuide())
menu.separador()
menu.separador()
menu1 = menu.submenu(_("Engines"), Iconos.Motores())
menu1.opcion("torneos", _("Tournaments between engines"),
Iconos.Torneos())
menu1.separador()
menu1.opcion("sts", _("STS: Strategic Test Suite"), Iconos.STS())
menu1.separador()
menu1.opcion("motores", _("External engines"), Iconos.Motores())
menu.separador()
resp = menu.lanza()
if resp:
if resp.startswith("pgn_"):
self.visorPGN(resp)
elif resp == "juega_solo":
self.jugarSolo()
elif resp == "torneos":
self.torneos()
elif resp == "motores":
self.motoresExternos()
elif resp == "sts":
self.sts()
elif resp == "manual_save":
self.manual_save()
elif resp == "database":
self.database()
elif resp == "databaseFEN":
self.databaseFEN()
elif resp == "aperturaspers":
self.aperturaspers()
elif resp == "bookguide":
w = WBGuide.WBGuide(self.pantalla, self)
w.exec_()
def configurarGS(self):
sep = (None, None, None)
liMasOpciones = [
("rotacion", _("Auto-rotate board"), Iconos.JS_Rotacion()), sep,
("apertura", _("Opening"), Iconos.Apertura()), sep,
("posicion", _("Start position"), Iconos.Datos()), sep,
("pasteposicion", _("Paste FEN position"), Iconos.Pegar16()), sep,
("leerpgn", _("Read PGN"), Iconos.PGN_Importar()), sep,
("pastepgn", _("Paste PGN"), Iconos.Pegar16()), sep,
("voyager", _("Voyager 2"), Iconos.Voyager1()),
]
resp = self.configurar(liMasOpciones, siCambioTutor=True, siSonidos=True)
if resp == "rotacion":
self.siVolteoAutomatico = not self.siVolteoAutomatico
siBlancas = self.partida.ultPosicion.siBlancas
if self.siVolteoAutomatico:
if siBlancas != self.tablero.siBlancasAbajo:
self.tablero.rotaTablero()
elif resp == "apertura":
bl, ps = PantallaAperturas.dameApertura(self.pantalla, self.configuracion, self.bloqueApertura,
self.posicApertura)
if bl:
self.bloqueApertura = bl
self.posicApertura = ps
self.fen = None
self.reiniciar()
elif resp == "posicion":
resp = XVoyager.xVoyagerFEN(self.pantalla, self.configuracion, self.fen)
if resp is not None:
self.fen = resp
self.bloqueApertura = None
self.posicApertura = None
if self.xpgn:
siInicio = self.fen == ControlPosicion.FEN_INICIAL
li = self.xpgn.split("\n")
lin = []
siFen = False
for linea in li:
if linea.startswith("["):
if "FEN " in linea:
siFen = True
if siInicio:
continue
linea = '[FEN "%s"]' % self.fen
lin.append(linea)
else:
break
if not siFen:
linea = '[FEN "%s"]' % self.fen
lin.append(linea)
self.liPGN = lin
self.xpgn = "\n".join(lin) + "\n\n*"
self.reiniciar()
elif resp == "pasteposicion":
texto = QTUtil.traePortapapeles()
if texto:
cp = ControlPosicion.ControlPosicion()
try:
cp.leeFen(str(texto))
self.fen = cp.fen()
self.bloqueApertura = None
self.posicApertura = None
self.reiniciar()
except:
pass
elif resp == "leerpgn":
unpgn = PantallaPGN.eligePartida(self.pantalla)
if unpgn:
self.bloqueApertura = None
self.posicApertura = None
self.fen = unpgn.dic.get("FEN", None)
dic = self.creaDic()
dic["PARTIDA"] = unpgn.partida.guardaEnTexto()
dic["liPGN"] = unpgn.listaCabeceras()
dic["FEN"] = self.fen
dic["SIBLANCASABAJO"] = unpgn.partida.ultPosicion.siBlancas
self.reiniciar(dic)
elif resp == "pastepgn":
texto = QTUtil.traePortapapeles()
if texto:
unpgn = PGN.UnPGN()
unpgn.leeTexto(texto)
if unpgn.siError:
QTUtil2.mensError(self.pantalla, _("The text from the clipboard does not contain a chess game in PGN format"))
return
self.bloqueApertura = None
self.posicApertura = None
self.fen = unpgn.dic.get("FEN", None)
dic = self.creaDic()
dic["PARTIDA"] = unpgn.partida.guardaEnTexto()
dic["liPGN"] = unpgn.listaCabeceras()
dic["FEN"] = self.fen
dic["SIBLANCASABAJO"] = unpgn.partida.ultPosicion.siBlancas
self.reiniciar(dic)
elif resp == "voyager":
ptxt = XVoyager.xVoyager(self.pantalla, self.configuracion, partida=self.partida)
if ptxt:
dic = self.creaDic()
dic["PARTIDA"] = ptxt
p = self.partida.copia()
p.recuperaDeTexto(ptxt)
dic["FEN"] = None if p.siFenInicial() else p.iniPosicion.fen()
dic["SIBLANCASABAJO"] = self.tablero.siBlancasAbajo
self.reiniciar(dic)
def configurarGS(self):
mt = _("Engine").lower()
mt = _X(_("Disable %1"), mt) if self.play_against_engine else _X(
_("Enable %1"), mt)
sep = (None, None, None)
liMasOpciones = [
("rotacion", _("Auto-rotate board"), Iconos.JS_Rotacion()),
sep,
("opening", _("Opening"), Iconos.Apertura()),
sep,
("position", _("Edit start position"), Iconos.Datos()),
sep,
("pasteposicion", _("Paste FEN position"), Iconos.Pegar16()),
sep,
("leerpgn", _("Read PGN"), Iconos.PGN_Importar()),
sep,
("pastepgn", _("Paste PGN"), Iconos.Pegar16()),
sep,
("engine", mt, Iconos.Motores()),
sep,
("voyager", _("Voyager 2"), Iconos.Voyager1()),
]
resp = self.configurar(liMasOpciones,
siCambioTutor=True,
siSonidos=True)
if resp == "rotacion":
self.auto_rotate = not self.auto_rotate
is_white = self.game.last_position.is_white
if self.auto_rotate:
if is_white != self.tablero.is_white_bottom:
self.tablero.rotaTablero()
elif resp == "opening":
me = self.unMomento()
w = PantallaOpenings.WAperturas(self.main_window,
self.configuracion,
self.bloqueApertura)
me.final()
if w.exec_():
self.bloqueApertura = w.resultado()
self.xfichero = None
self.xpgn = None
self.xjugadaInicial = None
self.reiniciar()
elif resp == "position":
self.startPosition()
elif resp == "pasteposicion":
texto = QTUtil.traePortapapeles()
if texto:
cp = Position.Position()
try:
cp.read_fen(str(texto))
self.xfichero = None
self.xpgn = None
self.xjugadaInicial = None
self.new_game()
self.game.set_position(first_position=cp)
self.bloqueApertura = None
self.reiniciar()
except:
pass
elif resp == "leerpgn":
self.leerpgn()
elif resp == "pastepgn":
texto = QTUtil.traePortapapeles()
if texto:
ok, game = Game.pgn_game(texto)
if not ok:
QTUtil2.message_error(
self.main_window,
_("The text from the clipboard does not contain a chess game in PGN format"
))
return
self.xfichero = None
self.xpgn = None
self.xjugadaInicial = None
self.bloqueApertura = None
dic = self.creaDic()
dic["GAME"] = game.save()
dic["WHITEBOTTOM"] = game.last_position.is_white
self.reiniciar(dic)
elif resp == "engine":
self.ponRotulo1("")
if self.play_against_engine:
if self.xrival:
self.xrival.terminar()
self.xrival = None
self.play_against_engine = False
else:
self.cambioRival()
elif resp == "voyager":
ptxt = Voyager.voyagerPartida(self.main_window, self.game)
if ptxt:
self.xfichero = None
self.xpgn = None
self.xjugadaInicial = None
dic = self.creaDic()
dic["GAME"] = ptxt.save()
dic["WHITEBOTTOM"] = self.tablero.is_white_bottom
self.reiniciar(dic)
def editar(self, fila):
if fila is None:
nombre = ""
eco = ""
pgn = ""
estandar = True
titulo = _("New opening")
else:
reg = self.lista[fila]
nombre = reg["NOMBRE"]
eco = reg["ECO"]
pgn = reg["PGN"]
estandar = reg["ESTANDAR"]
titulo = nombre
# Datos
liGen = [(None, None)]
liGen.append((_("Name") + ":", nombre))
config = FormLayout.Editbox("ECO", ancho=30, rx="[A-Z, a-z][0-9][0-9]")
liGen.append((config, eco))
liGen.append((_("Add to standard list") + ":", estandar))
# Editamos
resultado = FormLayout.fedit(liGen,
title=titulo,
parent=self,
anchoMinimo=460,
icon=Iconos.Apertura())
if resultado is None:
return
accion, liResp = resultado
nombre = liResp[0].strip()
if not nombre:
return
eco = liResp[1].upper()
estandar = liResp[2]
fen = ControlPosicion.FEN_INICIAL
self.procesador.procesador = self.procesador # ya que editaVariante espera un gestor
resp = Variantes.editaVariante(self.procesador,
self.procesador,
fen,
pgn,
titulo=nombre,
siBlancasAbajo=True)
if resp:
pgn, a1h8 = resp
reg = {}
reg["NOMBRE"] = nombre
reg["ECO"] = eco
reg["PGN"] = pgn
reg["A1H8"] = a1h8
reg["ESTANDAR"] = estandar
if fila is None:
self.lista.append(reg)
self.grid.refresh()
self.grabar()
else:
self.lista[fila] = reg
self.grid.refresh()
self.grabar()
def __init__(self, owner, configuracion, bloqueApertura):
icono = Iconos.Apertura()
titulo = _("Select an opening")
extparam = "selectOpening"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
# Variables--------------------------------------------------------------------------
self.apStd = AperturasStd.ListaAperturasStd(configuracion, True, True)
self.configuracion = configuracion
self.partida = Partida.Partida()
self.bloqueApertura = bloqueApertura
self.liActivas = []
# Tablero
confTablero = configuracion.confTablero("APERTURAS", 32)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponMensajero(self.mueveHumano)
# Current pgn
self.lbPGN = Controles.LB(self, "").ponWrap().ponTipoLetra(puntos=10,
peso=75)
# Movimiento
self.siMoviendoTiempo = False
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self,
"",
siLibre=False,
tamIcon=24)
self.tbBM = tbBM
# Tool bar
tb = Controles.TBrutina(self)
tb.new(_("Accept"), Iconos.Aceptar(), self.aceptar)
tb.new(_("Cancel"), Iconos.Cancelar(), self.cancelar)
tb.new(_("Reinit"), Iconos.Reiniciar(), self.resetPartida)
tb.new(_("Takeback"), Iconos.Atras(), self.atras)
tb.new(_("Remove"), Iconos.Borrar(), self.borrar)
# Lista Aperturas
oColumnas = Columnas.ListaColumnas()
dicTipos = {
"b": Iconos.pmSun(),
"n": Iconos.pmPuntoAzul(),
"l": Iconos.pmNaranja()
}
oColumnas.nueva("TIPO",
"",
24,
edicion=Delegados.PmIconosBMT(dicIconos=dicTipos))
oColumnas.nueva("OPENING", _("Possible continuation"), 480)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, altoFila=32)
self.registrarGrid(self.grid)
# # Derecha
lyD = Colocacion.V().control(tb).control(self.grid)
gbDerecha = Controles.GB(self, "", lyD)
# # Izquierda
lyI = Colocacion.V().control(self.tablero).otro(lyBM).control(
self.lbPGN)
gbIzquierda = Controles.GB(self, "", lyI)
splitter = QtGui.QSplitter(self)
splitter.addWidget(gbIzquierda)
splitter.addWidget(gbDerecha)
self.registrarSplitter(splitter, "splitter")
# Completo
ly = Colocacion.H().control(splitter).margen(3)
self.setLayout(ly)
self.ponActivas()
self.resetPartida()
self.actualizaPosicion()
dic = {'_SIZE_': '916,444', 'SP_splitter': [356, 548]}
self.recuperarVideo(dicDef=dic)
def configurarGS(self):
mt = _("Engine").lower()
mt = _X(_("Disable %1"), mt) if self.siJuegaMotor else _X(_("Enable %1"), mt)
sep = (None, None, None)
liMasOpciones = [
("rotacion", _("Auto-rotate board"), Iconos.JS_Rotacion()), sep,
("apertura", _("Opening"), Iconos.Apertura()), sep,
("posicion", _("Start position"), Iconos.Datos()), sep,
("pasteposicion", _("Paste FEN position"), Iconos.Pegar16()), sep,
("leerpgn", _("Read PGN"), Iconos.PGN_Importar()), sep,
("pastepgn", _("Paste PGN"), Iconos.Pegar16()), sep,
("motor", mt, Iconos.Motores()), sep,
("voyager", _("Voyager 2"), Iconos.Voyager1()),
]
resp = self.configurar(liMasOpciones, siCambioTutor=True, siSonidos=True)
if resp == "rotacion":
self.siVolteoAutomatico = not self.siVolteoAutomatico
siBlancas = self.partida.ultPosicion.siBlancas
if self.siVolteoAutomatico:
if siBlancas != self.tablero.siBlancasAbajo:
self.tablero.rotaTablero()
elif resp == "apertura":
me = self.unMomento()
w = PantallaAperturas.WAperturas(self.pantalla, self.configuracion, self.bloqueApertura)
me.final()
if w.exec_():
self.bloqueApertura = w.resultado()
# self.posicApertura = ps
self.fen = None
self.reiniciar()
elif resp == "posicion":
self.startPosition()
elif resp == "pasteposicion":
texto = QTUtil.traePortapapeles()
if texto:
cp = ControlPosicion.ControlPosicion()
try:
cp.leeFen(str(texto))
self.fen = cp.fen()
self.bloqueApertura = None
self.posicApertura = None
self.reiniciar()
except:
pass
elif resp == "leerpgn":
unpgn = PantallaPGN.eligePartida(self.pantalla)
if unpgn:
self.bloqueApertura = None
self.posicApertura = None
self.fen = unpgn.dic.get("FEN", None)
dic = self.creaDic()
dic["PARTIDA"] = unpgn.partida.guardaEnTexto()
dic["liPGN"] = unpgn.listaCabeceras()
dic["FEN"] = self.fen
dic["SIBLANCASABAJO"] = unpgn.partida.ultPosicion.siBlancas
self.reiniciar(dic)
elif resp == "pastepgn":
texto = QTUtil.traePortapapeles()
if texto:
unpgn = PGN.UnPGN()
unpgn.leeTexto(texto)
if unpgn.siError:
QTUtil2.mensError(self.pantalla, _("The text from the clipboard does not contain a chess game in PGN format"))
return
self.bloqueApertura = None
self.posicApertura = None
self.fen = unpgn.dic.get("FEN", None)
dic = self.creaDic()
dic["PARTIDA"] = unpgn.partida.guardaEnTexto()
dic["liPGN"] = unpgn.listaCabeceras()
dic["FEN"] = self.fen
dic["SIBLANCASABAJO"] = unpgn.partida.ultPosicion.siBlancas
self.reiniciar(dic)
elif resp == "motor":
self.ponRotulo1("")
if self.siJuegaMotor:
if self.xrival:
self.xrival.terminar()
self.xrival = None
self.siJuegaMotor = False
else:
self.cambioRival()
elif resp == "voyager":
ptxt = Voyager.voyagerPartida(self.pantalla, self.partida)
if ptxt:
dic = self.creaDic()
dic["PARTIDA"] = ptxt
p = self.partida.copia()
p.recuperaDeTexto(ptxt)
dic["FEN"] = None if p.siFenInicial() else p.iniPosicion.fen()
dic["SIBLANCASABAJO"] = self.tablero.siBlancasAbajo
self.reiniciar(dic)
def tools(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion("juega_solo", _("Create your own game"),
Iconos.JuegaSolo())
menu.separador()
menu1 = menu.submenu(_("PGN viewer"), Iconos.PGN())
menu1.opcion("pgn_paste", _("Paste PGN"), Iconos.Pegar())
menu1.separador()
menu1.opcion("pgn_fichero", _("Read PGN"), Iconos.Fichero())
menu1.separador()
menu1.opcion("pgn_jugadadia", _("Game of the day"), Iconos.LM())
menu1.separador()
if self.configuracion.liTrasteros:
menu1.opcion("pgn_trasteros", _("Boxrooms PGN"),
Iconos.Trasteros())
menu1.separador()
if self.configuracion.salvarFichero and Util.existeFichero(
self.configuracion.salvarFichero):
menu1.opcion("pgn_nuestroFichero", _("My games"),
Iconos.NuestroFichero())
menu.separador()
menu1 = menu.submenu(_("Database"), Iconos.Database())
menu1.opcion("database", _("Complete games"), Iconos.DatabaseC())
menu1.separador()
menu1.opcion("databaseFEN", _("Positions"), Iconos.DatabaseF())
menu.separador()
menu1 = menu.submenu(_("Engines"), Iconos.Motores())
menu1.opcion("torneos", _("Tournaments between engines"),
Iconos.Torneos())
menu1.separador()
menu1.opcion("motores", _("External engines"), Iconos.Motores())
menu1.separador()
menu1.opcion("sts", _("STS: Strategic Test Suite"), Iconos.STS())
menu.separador()
menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
menu1.opcion("aperturaspers", _("Custom openings"), Iconos.Apertura())
menu1.separador()
menu1.opcion("bookguide", _("Personal Opening Guide"),
Iconos.BookGuide())
menu.separador()
menu.separador()
# menu1 = menu.submenu(_("Correspondence Chess"), Iconos.XFCC())
# liRemoves = []
# for f in Util.listfiles(self.configuracion.carpeta, "*.xfcc"):
# nomf = os.path.basename(f)[:-5]
# x = nomf.rfind("_")
# if x > 0:
# user = nomf[x + 1:].lower()
# server = nomf[:x]
# menu1.opcion("xfcc|%s|%s|%s" % (user, server, f), "%s: %s" % (server, user), Iconos.PuntoAzul())
# menu1.separador()
# liRemoves.append((user, server, f))
# menu1.opcion("xfcc_nuevo", _("New link"), Iconos.Mas())
# if liRemoves:
# menu1.separador()
# menu2 = menu1.submenu(_("Remove"), Iconos.Delete())
# for user, server, f in liRemoves:
# menu2.opcion("del_xfcc|%s|%s|%s" % (user, server, f), "%s: %s" % (server, user), Iconos.PuntoNaranja())
# menu2.separador()
resp = menu.lanza()
if resp:
if resp.startswith("pgn_"):
self.visorPGN(resp)
elif resp == "juega_solo":
self.jugarSolo()
elif resp == "torneos":
self.torneos()
elif resp == "motores":
self.motoresExternos()
elif resp == "sts":
self.sts()
elif resp == "database":
self.database()
elif resp == "databaseFEN":
self.databaseFEN()
elif resp == "aperturaspers":
self.aperturaspers()
elif resp == "bookguide":
w = WBGuide.WBGuide(self.pantalla, self)
w.exec_()
def editar(self, fila):
if fila is None:
name = ""
eco = ""
pgn = ""
estandar = True
titulo = _("New opening")
else:
reg = self.lista[fila]
name = reg["NOMBRE"]
eco = reg["ECO"]
pgn = reg["PGN"]
estandar = reg["ESTANDAR"]
titulo = name
# Datos
liGen = [(None, None)]
liGen.append((_("Name") + ":", name))
config = FormLayout.Editbox("ECO", ancho=30, rx="[A-Z, a-z][0-9][0-9]")
liGen.append((config, eco))
liGen.append((_("Add to standard list") + ":", estandar))
# Editamos
resultado = FormLayout.fedit(liGen,
title=titulo,
parent=self,
anchoMinimo=460,
icon=Iconos.Apertura())
if resultado is None:
return
accion, liResp = resultado
name = liResp[0].strip()
if not name:
return
eco = liResp[1].upper()
estandar = liResp[2]
fen = FEN_INITIAL
self.procesador.procesador = self.procesador # ya que editaVariante espera un gestor
if pgn:
ok, game = Game.pgn_game(pgn)
if not ok:
game = Game.Game()
else:
game = Game.Game()
resp = Variantes.editaVariante(self.procesador,
game,
titulo=name,
is_white_bottom=True)
if resp:
game = resp
reg = {}
reg["NOMBRE"] = name
reg["ECO"] = eco
reg["PGN"] = game.pgnBaseRAW()
reg["A1H8"] = game.pv()
reg["ESTANDAR"] = estandar
if fila is None:
self.lista.append(reg)
self.grid.refresh()
self.grabar()
else:
self.lista[fila] = reg
self.grid.refresh()
self.grabar()
