def train(self):
menu = QTVarios.LCMenu(self)
trSSP, trEng = self.train_test()
if trSSP:
menu.opcion("tr_sequential", _("Sequential"),
Iconos.TrainSequential())
menu.separador()
menu.opcion("tr_static", _("Static"), Iconos.TrainStatic())
menu.separador()
menu.opcion("tr_positions", _("Positions"),
Iconos.TrainPositions())
menu.separador()
if trEng:
menu.opcion("tr_engines", _("With engines"), Iconos.TrainEngines())
menu.separador()
submenu = menu.submenu(_("Configuration"), Iconos.Configurar())
if trEng or trSSP:
submenu.opcion("update", _("Update current trainings"),
Iconos.Reindexar())
submenu.separador()
submenu1 = submenu.submenu(_("Create trainings"), Iconos.Modificar())
submenu1.opcion(
"new_ssp",
"%s - %s - %s" % (_("Sequential"), _("Static"), _("Positions")),
Iconos.TrainSequential())
submenu1.opcion("new_eng", "With engines", Iconos.TrainEngines())
resp = menu.lanza()
if resp is None:
return
if resp.startswith("tr_"):
self.resultado = resp
self.accept()
elif resp == "new_ssp":
self.trainNewSSP()
elif resp == "new_eng":
self.trainNewEngines()
elif resp == "update":
self.trainUpdateAll()
def entrenar(self):
if self.tactica.terminada():
menu = QTVarios.LCMenu(self)
menu.opcion("auto", _("Default settings"), Iconos.PuntoAzul())
menu.separador()
menu.opcion("manual", _("Manual configuration"), Iconos.PuntoRojo())
n = self.ghistorico.recno()
if n >= 0:
reg = self.liHistorico[n]
if "PUZZLES" in reg:
menu.separador()
menu.opcion("copia%d" % n, _("Copy configuration from current register"), Iconos.PuntoVerde())
resp = menu.lanza()
if not resp:
return
self.resultado = resp
else:
self.resultado = "seguir"
self.guardarVideo()
self.accept()
def tg_exportar(self, ext):
li = self.grid.recnosSeleccionados()
if not li:
return None
menu = QTVarios.LCMenu(self)
menu.opcion(True, _("All read"), Iconos.PuntoVerde())
menu.separador()
menu.opcion(False, "%s [%d]"%(_("Only selected"),len(li)), Iconos.PuntoAzul())
siTodos = menu.lanza()
if siTodos is None:
return None
if siTodos:
li = range(self.dbGamesFEN.reccount())
# Fichero donde a?adir
path = QTUtil2.salvaFichero(self, _("Export"), self.configuracion.dirSalvados,
_("File") + " %s (*.%s)"%(ext, ext),
False)
if path:
if not path.lower().endswith(".%s"%ext):
path += ".%s"%ext
carpeta, nomf = os.path.split(path)
if carpeta != self.configuracion.dirSalvados:
self.configuracion.dirSalvados = carpeta
self.configuracion.graba()
# Grabamos
modo = "w"
if Util.existeFichero(path):
yn = QTUtil2.preguntaCancelar(self, _X(_("The file %1 already exists, what do you want to do?"), path),
si=_("Append"), no=_("Overwrite"))
if yn is None:
return None
if yn:
modo = "a"
return li, modo, path
else:
return None
def creaTab(self):
menu = QTVarios.LCMenu(self)
menu.opcion("book", _("Polyglot book"), Iconos.Libros())
menu.separador()
menu.opcion("dbase", _("Database"), Iconos.Database())
# menu.separador()
# menu.opcion("tree", _("Tree"), Iconos.Arbol())
resp = menu.lanza()
pos = 0
if resp == "book":
book = self.seleccionaLibro()
if book:
tabbook = TabBook(self, book, self.configuracion)
self.liTabs.append((resp, tabbook))
pos = len(self.liTabs)-1
self.tabs.nuevaTab(tabbook, book.nombre, pos)
self.tabs.setTabIcon(pos, Iconos.Libros())
self.setPosicion(self.partida, self.njg, pos)
# elif resp == "tree":
# tabtree = TabTree(self, self.configuracion)
# self.liTabs.append(("tree", tabtree))
# pos = len(self.liTabs)-1
# self.tabs.nuevaTab(tabtree, _("Tree"), pos)
# self.tabs.setTabIcon(pos, Iconos.Arbol())
# tabtree.bt_update()
elif resp == "dbase":
nomfichgames = QTVarios.selectDB(self, self.configuracion, False, True)
if nomfichgames:
dbSTAT = DBgames.TreeSTAT(nomfichgames + "_s1")
tabdb = TabDatabase(self, self.procesador, dbSTAT)
self.liTabs.append((resp, tabdb))
pos = len(self.liTabs) - 1
self.setPosicion(self.partida, self.njg, pos)
nombre = os.path.basename(nomfichgames)[:-4]
self.tabs.nuevaTab(tabdb, nombre, pos)
self.tabs.setTabIcon(pos, Iconos.Database())
self.tabs.activa(pos)
def opciones(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion(self.cambiaConfiguracion, _("Configuration"),
Iconos.Opciones())
menu.separador()
menu1 = menu.submenu(_("Colors"), Iconos.Colores())
menu1.opcion(self.editaColoresTablero, _("Main board"),
Iconos.EditarColores())
menu1.separador()
menu1.opcion(self.cambiaColores, _("General"), Iconos.Vista())
menu.separador()
menu1 = menu.submenu(_("Sound"), Iconos.SoundTool())
menu1.opcion(self.sonidos, _("Custom sounds"), Iconos.S_Play())
menu.separador()
menu.opcion(self.setPassword, _("Set password"), Iconos.Password())
if self.configuracion.siMain:
menu.separador()
menu.opcion(self.usuarios, _("Users"), Iconos.Usuarios())
menu.separador()
menu1 = menu.submenu(_("User data folder"), Iconos.Carpeta())
menu1.opcion(self.folder_change, _("Change the folder"),
Iconos.FolderChange())
if not Configuracion.isDefaultFolder():
menu1.separador()
menu1.opcion(self.folder_default, _("Set the default"),
Iconos.Defecto())
resp = menu.lanza()
if resp:
if isinstance(resp, tuple):
resp[0](resp[1])
else:
resp()
def MoverTiempo(self):
if self.siReloj:
self.siReloj = False
else:
menu = QTVarios.LCMenu(self)
menu.opcion(
"previo", "%s: %0.02f" %
(_("Duration of interval (secs)"), self.intervalo / 1000.0),
Iconos.MoverTiempo())
menu.opcion("otro", _("Change interval"), Iconos.Configurar())
resp = menu.lanza()
if not resp:
return
if resp == "otro":
liGen = [(None, None)]
config = FormLayout.Editbox(_("Duration of interval (secs)"),
40,
tipo=float)
liGen.append((config, self.intervalo / 1000.0))
resultado = FormLayout.fedit(liGen,
title=_("Interval"),
parent=self,
icon=Iconos.MoverTiempo())
if resultado is None:
return
accion, liResp = resultado
tiempo = liResp[0]
if tiempo > 0.01:
self.intervalo = int(tiempo * 1000)
else:
return
self.siReloj = True
# if self.siMoves and (self.posHistoria >= len(self.historia) - 1):
self.MoverInicio()
self.lanzaReloj()
def tg_exportar_PGN(self):
li = self.grid.recnosSeleccionados()
if li:
if len(li) > 1:
menu = QTVarios.LCMenu(self)
menu.opcion(True, _("All read"), Iconos.PuntoVerde())
menu.separador()
menu.opcion(False, _("Only selected"), Iconos.PuntoAzul())
resp = menu.lanza()
if resp is None:
return
siTodos = resp
else:
siTodos = True
if siTodos:
li = range(self.dbGames.reccount())
w = PantallaSavePGN.WSaveVarios(self, self.configuracion)
if w.exec_():
ws = PantallaSavePGN.FileSavePGN(self, w.dic_result)
if ws.open():
pb = QTUtil2.BarraProgreso1(self,
_("Saving..."),
formato1="%p%")
pb.mostrar()
pb.ponTotal(len(li))
for n, recno in enumerate(li):
pb.pon(n)
pgn, result = self.dbGames.leePGNRecno(recno)
if pb.siCancelado():
break
if n > 0 or not ws.is_new:
ws.write("\n\n")
ws.write(pgn)
pb.close()
ws.close()
def file(self):
menu = QTVarios.LCMenu(self.pantalla)
if self.ultimoFichero:
menuR = menu.submenu(_("Save"), Iconos.Grabar())
rpath = os.path.relpath(self.ultimoFichero)
if rpath.count("..") > 0:
rpath = self.ultimoFichero
menuR.opcion("save", "%s: %s" % (_("Save"), rpath),
Iconos.Grabar())
menuR.separador()
menuR.opcion("saveas", _("Save as"), Iconos.GrabarComo())
else:
menu.opcion("save", _("Save"), Iconos.Grabar())
menu.separador()
menu.opcion("new", _("New"), Iconos.TutorialesCrear())
menu.separador()
menu.opcion("open", _("Open"), Iconos.Recuperar())
menu.separador()
li = self.listaHistorico()
if li:
menu.separador()
menuR = menu.submenu(_("Reopen"), Iconos.Historial())
for path in li:
menuR.opcion("reopen_%s" % path, path, Iconos.PuntoNaranja())
menuR.separador()
resp = menu.lanza()
if resp is None:
return
if resp == "open":
self.recuperarPKS()
elif resp == "new":
self.nuevo()
elif resp.startswith("reopen_"):
return self.leeFichero(resp[7:])
elif resp == "save":
self.grabar()
elif resp == "saveas":
self.grabarComo()
def confTablero(self):
self.pause()
menu = QTVarios.LCMenu(self)
if self.siShowTablero:
menu.opcion("hide", _("Hide"), Iconos.PuntoNaranja())
else:
menu.opcion("show", _("Show"), Iconos.PuntoNaranja())
menu.separador()
menu1 = menu.submenu(_("Arrows"), Iconos.PuntoNegro())
for x in range(1, 31):
menu1.opcion(x, str(x), Iconos.PuntoVerde(), siDeshabilitado=x == self.nArrows)
resp = menu.lanza()
if resp:
if resp == "hide":
self.siShowTablero = False
self.tablero.hide()
elif resp == "show":
self.siShowTablero = True
self.tablero.show()
else:
self.nArrows = resp
self.guardarVideo()
self.play()
def creaMenu(self):
dicMenu = {}
menu = QTVarios.LCMenu(self.parent)
talpha = Controles.TipoLetra("Chess Alpha 2", self.configuration.x_menu_points + 4)
def xopcion(menu, key, texto, icono, is_disabled=False):
if "KP" in texto:
k2 = texto.index("K", 2)
texto = texto[:k2] + texto[k2:].lower()
menu.opcion(key, texto, icono, is_disabled, tipoLetra=talpha)
else:
menu.opcion(key, texto, icono, is_disabled)
dicMenu[key] = (self.menu_run, texto, icono, is_disabled)
self.create_menu_basic(menu, xopcion)
self.create_menu_tactics(menu, xopcion)
self.create_menu_games(menu, xopcion)
self.create_menu_openings(menu, xopcion)
self.create_menu_endings(menu, xopcion)
self.create_menu_long(menu, xopcion)
return menu, dicMenu
def tg_file(self):
menu = QTVarios.LCMenu(self)
menu.opcion(self.tg_createDB, _("Create a new database"), Iconos.NuevaDB())
menu.separador()
menu.opcion(self.tg_change, _("Open another database"), Iconos.DatabaseC())
menu.separador()
submenu = menu.submenu(_("Import from"), Iconos.DatabaseCNew())
submenu.opcion(self.tg_importar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_importar_DB, _("Other database"), Iconos.DatabaseC())
menu.separador()
submenu = menu.submenu(_("Export to"), Iconos.DatabaseMas())
submenu.opcion(self.tg_exportar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_exportar_DB, _("Other database"), Iconos.DatabaseC())
menu.separador()
resp = menu.lanza()
if resp:
resp()
def train(self):
if self.train_test():
menu = QTVarios.LCMenu(self)
menu.opcion("tr_sequential", _("Sequential"), Iconos.TrainSequential())
menu.separador()
menu.opcion("tr_static", _("Static"), Iconos.TrainStatic())
menu.separador()
menu.opcion("tr_positions", _("Positions"), Iconos.TrainPositions())
menu.separador()
submenu = menu.submenu(_("Configuration"), Iconos.Configurar())
submenu.opcion("update", _("Update current trainings"), Iconos.Reindexar())
submenu.separador()
submenu.opcion("new", _("Re-create all trainings"), Iconos.Modificar())
resp = menu.lanza()
if resp is None:
return
if resp.startswith("tr_"):
self.resultado = resp
self.accept()
elif resp == "new":
self.trainNew()
elif resp == "update":
self.trainUpdate()
def recuperar(self):
menu = QTVarios.LCMenu(self.pantalla)
li = self.listaHistorico()
menu.opcion("open", _("File") + " ...", Iconos.Recuperar())
menu.separador()
menu.opcion("new", _("New"), Iconos.TutorialesCrear())
if li:
menu.separador()
menuR = menu.submenu(_("Reopen"), Iconos.Historial())
for path in li:
menuR.opcion("r_%s" % path, path, Iconos.PuntoNaranja())
menuR.separador()
resp = menu.lanza()
if resp:
if resp == "open":
return self.recuperarPKS()
if resp == "new":
return self.nuevo()
return self.leeFichero(resp[2:])
def config(self):
menu = QTVarios.LCMenu(self)
if self.one_line:
menu.opcion("change", _("Change options and create new training"), Iconos.TOLchange())
menu.separador()
smenu = menu.submenu(_("What to do after solving"), Iconos.Tacticas())
go_fast = self.tol.go_fast
dico = {True: Iconos.Aceptar(), False: Iconos.PuntoAmarillo()}
smenu.opcion("t_False", _("Stop"), dico[go_fast == False])
smenu.opcion("t_True", _("Jump to the next"), dico[go_fast == True])
smenu.opcion("t_None", _("Jump to the next from level 2"), dico[go_fast is None])
menu.separador()
menu.opcion("remove", _("Remove all results of all levels"), Iconos.Cancelar())
resp = menu.lanza()
if resp:
if resp.startswith("t_"):
self.tol.go_fast = eval(resp[2:])
TurnOnLights.write_tol(self.tol)
elif resp == "remove":
self.rebuild()
elif resp == "change":
self.cambiar_one_line()
def colors(self):
menu = QTVarios.LCMenu(self)
d = {
"0": Iconos.Gris32(),
"1": Iconos.Amarillo32(),
"2": Iconos.Naranja32(),
"3": Iconos.Verde32(),
"4": Iconos.Azul32(),
"5": Iconos.Magenta32(),
"6": Iconos.Rojo32(),
"7": Iconos.Light32()
}
num, ultimo = TurnOnLights.numColorMinimum(self.tol)
snum = str(num)
thinkMode = self.tol.is_calculation_mode()
for txt, key, secs, secsThink in TurnOnLights.QUALIFICATIONS:
rotulo = "%s < %0.2f\"" % (_F(txt),
secsThink if thinkMode else secs)
if key == snum and not ultimo:
rotulo += " = %s" % _("Minimum to access next level")
menu.opcion(None, rotulo, d[key])
menu.separador()
menu.lanza()
def gmarcar(self):
if len(self.guion):
menu = QTVarios.LCMenu(self)
f = Controles.TipoLetra(puntos=8, peso=75)
menu.ponFuente(f)
menu.opcion(1, _("All"), Iconos.PuntoVerde())
menu.opcion(2, _("None"), Iconos.PuntoNaranja())
resp = menu.lanza()
if resp:
siTodos = resp == 1
for n in range(len(self.guion)):
tarea = self.guion.tarea(n)
if tarea.tp() in (TabVisual.TP_TEXTO, TabVisual.TP_ACTION,
TabVisual.TP_CONFIGURATION):
continue
siMarcado = tarea.marcado()
if siTodos:
if not siMarcado:
self.gridPonValor(None, n, None, True)
else:
if siMarcado:
self.gridPonValor(None, n, None, False)
self.refresh_guion()
def new(self):
menu = QTVarios.LCMenu(self)
if not QTVarios.lista_db(self.configuration, True).is_empty():
menu.opcion("db", _("Game in a database"), Iconos.Database())
menu.separador()
menu.opcion("pgn", _("Game in a pgn"), Iconos.Filtrar())
menu.separador()
resp = menu.lanza()
game = None
if resp == "pgn":
game = self.procesador.select_1_pgn(self)
elif resp == "db":
db = QTVarios.select_db(self, self.configuration, True, False)
if db:
w = WindowDatabase.WBDatabase(self, self.procesador, db, False, True)
resp = w.exec_()
if resp:
game = w.game
if game and len(game) > 0:
reg = {"GAME": game.save()}
self.db.append(reg)
self.grid.refresh()
self.grid.gotop()
def lanzaVariantes(self):
icoNegro = Iconos.PuntoNegro()
icoVerde = Iconos.PuntoVerde()
icoSeguimos = Iconos.PuntoAzul()
menu = QTVarios.LCMenu(self.pantalla)
for n, (tit, txtp, siBlancas) in enumerate(self.liVariantes):
menu.opcion(n, tit, icoVerde if siBlancas else icoNegro)
menu.separador()
if not self.siTerminada() and not self.siSeguirJugando:
menu.opcion(-1, _("Do you want to continue playing?"), icoSeguimos)
resp = menu.lanza()
if resp is not None:
if resp == -1:
self.siSeguirJugando = True
else:
self.partida.recuperaDeTexto(self.liVariantes[resp][1])
self.estado = kJugando
self.ponteAlFinal()
self.siguienteJugada()
def menuLibros(self):
menu = QTVarios.LCMenu(self)
nBooks = len(self.listaLibros.lista)
for book in self.listaLibros.lista:
ico = Iconos.PuntoVerde() if book == self.book else Iconos.PuntoNaranja()
menu.opcion(("x", book), book.nombre, ico)
menu.separador()
menu.opcion(("n", None), _("Install new book"), Iconos.Nuevo())
if nBooks > 1:
menu.separador()
menub = menu.submenu(_("Remove a book from the list"), Iconos.Delete())
for book in self.listaLibros.lista:
if not book.pordefecto:
menub.opcion(("b", book), book.nombre, Iconos.Delete())
menu.separador()
menu.opcion(("1", None), _("Find Next") + " <F3>", Iconos.Buscar())
resp = menu.lanza()
if resp:
orden, book = resp
if orden == "x":
self.cambiaLibro(book)
elif orden == "n":
fbin = QTUtil2.leeFichero(self, self.listaLibros.path, "bin", titulo=_("Polyglot book"))
if fbin:
self.listaLibros.path = os.path.dirname(fbin)
nombre = os.path.basename(fbin)[:-4]
book = Books.Libro("P", nombre, fbin, True)
self.listaLibros.nuevo(book)
self.cambiaLibro(book)
elif orden == "b":
self.listaLibros.borra(book)
self.listaLibros.guardaVar(self.fvar)
elif orden == "1":
self.buscaSiguiente()
def tg_file(self):
menu = QTVarios.LCMenu(self)
lista = QTVarios.listaDB(self.configuracion, False)
if lista:
smenu = menu.submenu( _("Open another database"), Iconos.DatabaseC())
rp = QTVarios.rondoPuntos()
for fich in lista:
smenu.opcion(os.path.join(self.configuracion.carpetaGames, fich), _F(fich[:-4]), rp.otro())
smenu.separador()
menu.separador()
menu.opcion(self.tg_create,_("Create a new database"), Iconos.NuevaDB())
menu.separador()
submenu = menu.submenu(_("Import from"), Iconos.DatabaseCNew())
submenu.opcion(self.tg_importar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_importar_DB, _("Other database"), Iconos.DatabaseC())
submenu.separador()
submenu.opcion(self.tg_importar_pks, _("A PKS file"), Iconos.JuegaSolo())
menu.separador()
submenu = menu.submenu(_("Export to"), Iconos.DatabaseMas())
submenu.opcion(self.tg_exportar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_exportar_DB, _("Other database"), Iconos.DatabaseC())
menu.separador()
menu.opcion(self.tg_pack, _("Pack database"), Iconos.Pack())
menu.separador()
resp = menu.lanza()
if resp:
if type(resp) == str:
self.changeDBgames(resp)
else:
resp()
def tg_file(self):
menu = QTVarios.LCMenu(self)
menu.opcion(self.tg_createDB, _("Create a new database"),
Iconos.NuevaDB())
menu.separador()
menu.opcion(self.tg_change, _("Open another database"),
Iconos.DatabaseC())
menu.separador()
submenu = menu.submenu(_("Import from"), Iconos.DatabaseCNew())
submenu.opcion(self.tg_importar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_importar_DB, _("Other database"),
Iconos.DatabaseC())
menu.separador()
submenu = menu.submenu(_("Export to"), Iconos.DatabaseMas())
submenu.opcion(self.tg_exportar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_exportar_DB, _("Other database"),
Iconos.DatabaseC())
menu.separador()
submenu = menu.submenu(_("Utilities"), Iconos.Utilidades())
ico = Iconos.PuntoAzul()
icoT = Iconos.Tacticas()
menu1 = submenu.submenu(_("Polyglot book"), ico)
menu1.opcion(self.tw_uti_pcreate, _("Create a new book"), ico)
menu1.separador()
menu1.opcion(self.tw_uti_pmerge, _("Merge two books in one"), ico)
submenu.separador()
submenu.opcion(self.tw_uti_tactic, _("Create tactics training"), icoT)
resp = menu.lanza()
if resp:
resp()
def eligeJugadaBooks(pantalla, liJugadas, siBlancas):
pantalla.cursorFueraTablero()
menu = QTVarios.LCMenu(pantalla)
f = Controles.TipoLetra(nombre="Courier New", puntos=10)
menu.ponFuente(f)
titulo = _("White") if siBlancas else _("Black")
icono = Iconos.Carpeta()
menu.opcion(None, titulo, icono)
menu.separador()
icono = Iconos.PuntoNaranja() if siBlancas else Iconos.PuntoNegro()
for desde, hasta, coronacion, pgn, peso in liJugadas:
menu.opcion((desde, hasta, coronacion), pgn, icono)
menu.separador()
resp = menu.lanza()
if resp:
return resp
else:
desde, hasta, coronacion, pgn, peso = liJugadas[0]
return (desde, hasta, coronacion)
def cambia_tema(self, tema, si_left):
if si_left:
self.pon_tema(tema)
self.current_theme = tema
else:
if self.own_theme_selected:
menu = QTVarios.LCMenu(self)
menu.opcion("rename", _("Change the name/section"), Iconos.Rename())
menu.separador()
menu.opcion("delete", _("Remove"), Iconos.Delete())
menu.separador()
resp = menu.lanza()
if resp == "rename":
self.rename_theme(tema)
elif resp == "delete":
name = tema.get("NOMBRE", "")
seccion = tema.get("SECCION", "")
if seccion:
name += "/" + seccion
if QTUtil2.pregunta(self, "Are you sure you want to remove %s?" % name):
self.li_themes.remove(tema)
self.save_own_themes()
self.ponSecciones()
def preferred_openings(self):
if len(self.li_preferred_openings) == 0:
return
menu = QTVarios.LCMenu(self)
menu.setToolTip(_("To choose: <b>left button</b> <br>To erase: <b>right button</b>"))
f = Controles.TipoLetra(puntos=8, peso=75)
menu.ponFuente(f)
n_pos = 0
for nli, bloque in enumerate(self.li_preferred_openings):
if type(bloque) == tuple: # compatibilidad con versiones anteriores
bloque = bloque[0]
self.li_preferred_openings[nli] = bloque
menu.opcion(bloque, bloque.trNombre, Iconos.PuntoVerde())
n_pos += 1
resp = menu.lanza()
if resp:
if menu.siIzq:
self.opening_block = resp
self.aperturaMuestra()
elif menu.siDer:
opening_block = resp
if QTUtil2.pregunta(self, _X(_("Do you want to delete the opening %1 from the list of favourite openings?"), opening_block.trNombre)):
del self.li_preferred_openings[n_pos]
def informacion(self):
menu = QTVarios.LCMenu(self.pantalla)
f = Controles.TipoLetra(puntos=10, peso=75)
menu.ponFuente(f)
siOpening = False
for clave, valor in self.liPGN:
siFecha = clave.upper().endswith("DATE")
trad = TrListas.pgnLabel(clave)
if trad != clave:
clave = trad
# else:
# clave = clave[0].upper()+clave[1:].lower()
if siFecha:
valor = valor.replace(".??", "")
menu.opcion(clave, "%s : %s" % (clave, valor), Iconos.PuntoAzul())
if clave.upper() == "OPENING":
siOpening = True
if not siOpening:
apertura = self.partida.apertura
if apertura:
menu.separador()
nom = apertura.trNombre
ape = _("Opening")
rotulo = nom if ape.upper() in nom.upper() else ("%s : %s" %
(ape, nom))
menu.opcion(clave, rotulo, Iconos.PuntoNaranja())
menu.separador()
menu.opcion("pgn", _("Edit PGN labels"), Iconos.PGN())
resp = menu.lanza()
if resp:
self.editarEtiquetasPGN()
def changeFolder(self):
nof = _("New opening folder")
base = self.configuracion.folderBaseOpenings
li = [
x for x in os.listdir(base) if os.path.isdir(os.path.join(base, x))
]
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
menu.opcion("", _("Home folder"), Iconos.Home())
menu.separador()
for x in li:
menu.opcion(x, x, rondo.otro())
menu.separador()
menu.opcion(":n", nof, Iconos.Nuevo())
if VarGen.isWindows:
menu.separador()
menu.opcion(":m", _("Direct maintenance"), Iconos.Configurar())
resp = menu.lanza()
if resp is not None:
if resp == ":m":
os.startfile(base)
return
elif resp == ":n":
name = ""
error = ""
while True:
liGen = [FormLayout.separador]
liGen.append((nof + ":", name))
if error:
liGen.append(FormLayout.separador)
liGen.append((None, error))
resultado = FormLayout.fedit(liGen,
title=nof,
parent=self,
icon=Iconos.OpeningLines(),
anchoMinimo=460)
if resultado:
accion, liResp = resultado
name = liResp[0].strip()
if name:
path = os.path.join(base, name)
try:
os.mkdir(path)
except:
error = _("Unable to create this folder")
continue
if not os.path.isdir(path):
continue
break
else:
return
else:
path = os.path.join(base, resp)
path = os.path.relpath(path)
self.configuracion.folderOpenings = path
self.configuracion.graba()
self.listaOpenings = OpeningLines.ListaOpenings(self.configuracion)
self.glista.refresh()
self.glista.gotop()
if len(self.listaOpenings) == 0:
self.wtrain.setVisible(False)
self.setWindowTitle(self.getTitulo())
def borrar(self):
tam_dbop = len(self.dbop)
if tam_dbop == 0:
return
current = self.glines.recno() // 2
li = []
if 0 <= current < tam_dbop:
li.append([
"current",
_("Remove line %d") % (current + 1, ),
Iconos.Mover()
])
if tam_dbop > 1:
li.append(
["lines",
_("Remove a list of lines"),
Iconos.MoverLibre()])
if len(li) > 0:
menu = QTVarios.LCMenu(self)
for key, title, ico in li:
menu.opcion(key, title, ico)
menu.separador()
resp = menu.lanza()
if resp == "current":
del self.dbop[current]
self.goto_inilinea()
else:
liGen = [FormLayout.separador]
config = FormLayout.Editbox(
"<div align=\"right\">" + _("Lines") + "<br>" +
_("By example:") + " -5,8-12,14,19-",
rx="[0-9,\-,\,]*")
liGen.append((config, ""))
resultado = FormLayout.fedit(liGen,
title=_("Remove a list of lines"),
parent=self,
anchoMinimo=460,
icon=Iconos.OpeningLines())
if resultado:
accion, liResp = resultado
clista = liResp[0]
if clista:
ln = Util.ListaNumerosImpresion(clista)
li = ln.selected(range(1, tam_dbop + 1))
sli = []
cad = ""
for num in li:
if cad:
cad += "," + str(num)
else:
cad = str(num)
if len(cad) > 80:
sli.append(cad)
cad = ""
if cad:
sli.append(cad)
cli = "\n".join(sli)
if QTUtil2.pregunta(
self,
_("Do you want to remove the next lines?") +
"\n\n" + cli):
li.sort(reverse=True)
um = QTUtil2.unMomento(self, _("Working..."))
for num in li:
del self.dbop[num - 1]
self.glines.refresh()
self.goto_inilinea()
um.final()
def menu(self, parent):
menu = QTVarios.LCMenu(parent)
rp = QTVarios.rondoPuntos(False)
rc = QTVarios.rondoColores(False)
submenu = menu.submenu(_("Internal engines"), self.dicIconos[INTERNO])
li_m_i = sorted(self.liMotoresInternos, key=lambda x: x.elo)
def haz(from_sq, to_sq, rotulo):
smn = None
for cm in li_m_i:
elo = cm.elo
if from_sq < elo <= to_sq:
if smn is None:
smn = submenu.submenu(rotulo, rc.otro())
clave = INTERNO, cm
texto = cm.name
icono = rp.otro()
smn.opcion(clave, "%s (%d)" % (texto, elo), icono)
haz(0, 1500, _("Up to 1500"))
haz(1500, 2000, "1500 - 2000")
haz(2000, 2500, "2000 - 2500")
haz(2500, 2750, "2500 - 2750")
haz(2750, 3000, "2750 - 3000")
haz(3000, 3500, _("Above 3000"))
menu.separador()
submenu = menu.submenu(_("External engines"), self.dicIconos[EXTERNO])
for cm in self.liMotoresExternos:
clave = EXTERNO, cm
texto = cm.clave
icono = rp.otro()
submenu.opcion(clave, texto, icono)
submenu.separador()
clave = EXTERNO, None
texto = _("Edition")
icono = Iconos.Mas()
submenu.opcion(clave, texto, icono)
menu.separador()
submenu = menu.submenu(_("GM engines"), self.dicIconos[MICGM])
for cm in self.liMotoresGM:
icono = rp.otro()
clave = MICGM, cm
texto = Util.primera_mayuscula(cm.name)
submenu.opcion(clave, texto, icono)
submenu.separador()
menu.separador()
menu.opcion((MICPER, None), _("Tourney engines"), self.dicIconos[MICPER])
menu.separador()
submenu = menu.submenu(_("Engines with fixed elo"), self.dicIconos[FIXED])
li = sorted(self.dict_engines_fixed_elo.keys())
for elo in li:
icono = rp.otro()
submenuElo = submenu.submenu(str(elo), icono)
lien = self.dict_engines_fixed_elo[elo]
lien.sort(key=lambda x: x.name)
for cm in lien:
clave = FIXED, cm
texto = cm.name
submenuElo.opcion(clave, texto, icono)
submenuElo.separador()
menu.separador()
menu1 = menu.submenu(_("Opponents for young players"), Iconos.RivalesMP())
for cm in self.liIrina:
menu1.opcion((IRINA, cm), cm.name, cm.icono)
menu.separador()
li_cortes = []
n = 19
pos = -1
for cm in self.liElo:
if n == 19:
li_cortes.append([])
pos += 1
n = 0
li_cortes[pos].append(cm)
n += 1
menu1 = menu.submenu(_("Lucas-Elo"), Iconos.Elo())
for li_corte in li_cortes:
from_sq = li_corte[0].elo
to_sq = li_corte[-1].elo
smenu = menu1.submenu("%d - %d" % (from_sq, to_sq), rc.otro())
for cm in li_corte:
smenu.opcion((ELO, cm), cm.name, rp.otro())
return menu.lanza()
def player_has_moved(self, from_sq, to_sq, promotion=""):
if not self.human_is_playing:
return self.check_premove(from_sq, to_sq)
move = self.check_human_move(from_sq, to_sq, promotion,
not self.is_tutor_enabled)
if not move:
return False
movimiento = move.movimiento()
siAnalisis = False
is_selected = False
fen_base = self.last_fen()
if self.bookR and self.bookMandatory:
listaJugadas = self.bookR.get_list_moves(fen_base)
if listaJugadas:
li = []
for apdesde, aphasta, appromotion, nada, nada1 in listaJugadas:
mx = apdesde + aphasta + appromotion
if mx.strip().lower() == movimiento:
is_selected = True
break
li.append((apdesde, aphasta, False))
if not is_selected:
self.board.ponFlechasTmp(li)
self.sigueHumano()
return False
if not is_selected and self.aperturaObl:
if self.aperturaObl.check_human(fen_base, from_sq, to_sq):
is_selected = True
else:
apdesde, aphasta = self.aperturaObl.from_to_active(fen_base)
if apdesde is None:
self.aperturaObl = None
else:
self.board.ponFlechasTmp(((apdesde, aphasta, False), ))
self.sigueHumano()
return False
if not is_selected and self.aperturaStd:
if self.aperturaStd.check_human(fen_base, from_sq, to_sq):
is_selected = True
else:
if not self.aperturaStd.is_active(fen_base):
self.aperturaStd = None
is_mate = move.is_mate
self.analizaFinal(is_mate) # tiene que acabar siempre
if not is_mate and not is_selected and self.is_tutor_enabled:
if not self.tutor_book.si_esta(fen_base, movimiento):
rmUser, n = self.mrmTutor.buscaRM(movimiento)
if not rmUser:
self.main_window.pensando_tutor(True)
rmUser = self.xtutor.valora(self.game.last_position,
from_sq, to_sq, move.promotion)
self.main_window.pensando_tutor(False)
if not rmUser:
self.sigueHumanoAnalisis()
return False
self.mrmTutor.agregaRM(rmUser)
siAnalisis = True
pointsBest, pointsUser = self.mrmTutor.difPointsBest(
movimiento)
self.setSummary("POINTSBEST", pointsBest)
self.setSummary("POINTSUSER", pointsUser)
difpts = self.configuration.x_tutor_difpoints
difporc = self.configuration.x_tutor_difporc
if self.mrmTutor.mejorRMQue(rmUser, difpts, difporc):
if not move.is_mate:
si_tutor = True
if self.chance:
num = self.mrmTutor.numMejorMovQue(movimiento)
if num:
rmTutor = self.mrmTutor.rmBest()
menu = QTVarios.LCMenu(self.main_window)
menu.opcion("None",
_("There are %d best moves") % num,
Iconos.Motor())
menu.separador()
resp = rmTutor.abrTextoBase()
if not resp:
resp = _("Mate")
menu.opcion(
"tutor",
"&1. %s (%s)" % (_("Show tutor"), resp),
Iconos.Tutor(),
)
menu.separador()
menu.opcion("try", "&2. %s" % _("Try again"),
Iconos.Atras())
menu.separador()
menu.opcion(
"user",
"&3. %s (%s)" % (_("Select my move"),
rmUser.abrTextoBase()),
Iconos.Player(),
)
self.main_window.cursorFueraBoard()
resp = menu.lanza()
if resp == "try":
self.sigueHumanoAnalisis()
return False
elif resp == "user":
si_tutor = False
elif resp != "tutor":
self.sigueHumanoAnalisis()
return False
if si_tutor:
tutor = Tutor.Tutor(self, move, from_sq, to_sq,
False)
if self.aperturaStd:
liApPosibles = self.listaOpeningsStd.list_possible_openings(
self.game)
else:
liApPosibles = None
if tutor.elegir(self.hints > 0,
liApPosibles=liApPosibles):
if self.hints > 0: # doble entrada a tutor.
self.set_piece_again(from_sq)
self.hints -= 1
self.tutor_con_flechas = self.nArrowsTt > 0 and self.hints > 0
from_sq = tutor.from_sq
to_sq = tutor.to_sq
promotion = tutor.promotion
ok, mens, jgTutor = Move.get_game_move(
self.game, self.game.last_position,
from_sq, to_sq, promotion)
if ok:
move = jgTutor
self.setSummary("SELECTTUTOR", True)
if self.configuration.x_save_tutor_variations:
tutor.ponVariations(move,
1 + len(self.game) / 2)
del tutor
self.setSummary("TIMEUSER", self.timekeeper.stop())
self.reloj_stop(True)
self.move_the_pieces(move.liMovs)
if siAnalisis:
rm, nPos = self.mrmTutor.buscaRM(move.movimiento())
if rm:
move.analysis = self.mrmTutor, nPos
self.add_move(move, True)
self.error = ""
self.play_next_move()
return True
def lanzaGUI(procesador):
"""
Lanzador del interfaz grafico de la aplicacion.
"""
# Comprobamos el lenguaje
app = QtGui.QApplication([])
liUsuarios = Usuarios.Usuarios().lista
usuario = None
if liUsuarios:
usuario = pideUsuario(liUsuarios)
if usuario is None:
return
user = str(usuario.numero) if usuario.numero else ""
else:
user = ""
activeFolder = Configuracion.activeFolder()
siPedirLenguaje = not os.path.isdir(activeFolder) or not os.listdir(
activeFolder)
procesador.iniciaConUsuario(user)
configuracion = procesador.configuracion
if usuario:
if not configuracion.jugador:
configuracion.jugador = usuario.nombre
configuracion.graba()
elif configuracion.jugador != usuario.nombre:
for usu in liUsuarios:
if usu.numero == usuario.numero:
usu.nombre = configuracion.jugador
Usuarios.Usuarios().guardaLista(liUsuarios)
# Comprobamos el lenguaje
if siPedirLenguaje and not configuracion.traductor:
if user:
confMain = Configuracion.Configuracion("")
ori = confMain.ficheroMExternos
confMain.lee()
confMain.limpia(usuario.nombre)
confMain.ponCarpetas(user)
confMain.graba()
procesador.configuracion = confMain
Util.copiaFichero(ori, confMain.carpeta)
else:
li = configuracion.listaTraducciones()
menu = QTVarios.LCMenu(None)
nico = QTVarios.rondoPuntos()
for k, nombre, porc, author in li:
rotulo = nombre
if porc != "100":
rotulo += " (%s%%)" % porc
menu.opcion(k, nombre, nico.otro())
resp = menu.lanza()
if resp:
configuracion.traductor = resp
configuracion.graba()
# Estilo
app.setStyle(QtGui.QStyleFactory.create(configuracion.estilo))
if configuracion.palette:
qpalette = QtGui.QPalette()
palette = configuracion.palette
def cl(tipo):
return QtGui.QColor(palette[tipo])
qpalette.setColor(QtGui.QPalette.Window, cl("Window"))
qpalette.setColor(QtGui.QPalette.WindowText, cl("WindowText"))
qpalette.setColor(QtGui.QPalette.Base, cl("Base"))
qpalette.setColor(QtGui.QPalette.Text, cl("Text"))
qpalette.setColor(QtGui.QPalette.AlternateBase, cl("AlternateBase"))
qpalette.setColor(QtGui.QPalette.ToolTipBase, cl("ToolTipBase"))
qpalette.setColor(QtGui.QPalette.ToolTipText, cl("ToolTipText"))
qpalette.setColor(QtGui.QPalette.Button, cl("Button"))
qpalette.setColor(QtGui.QPalette.ButtonText, cl("ButtonText"))
qpalette.setColor(QtGui.QPalette.BrightText, cl("BrightText"))
qpalette.setColor(QtGui.QPalette.Link, cl("Link"))
else:
qpalette = QtGui.QApplication.style().standardPalette()
app.setPalette(qpalette)
app.setEffectEnabled(QtCore.Qt.UI_AnimateMenu)
# QtGui.QFontDatabase.addApplicationFont('IntFiles/ChessAlpha2.ttf') # TODO
if configuracion.familia:
font = Controles.TipoLetra(configuracion.familia)
app.setFont(font)
VarGen.gc = QTUtil.GarbageCollector()
# Lanzamos la pantalla
procesador.iniciarGUI()
resp = app.exec_()
return resp
