def lee(self):
dic = Util.restore_pickle(self.file)
if dic:
for x in dir(self):
if x.startswith("x_"):
if x in dic:
setattr(self, x, dic[x])
xperf = dic.get("PERFOMANCE")
if xperf:
self.perfomance.restore(xperf)
palette = dic.get("PALETTE")
if palette:
self.palette = palette
for x in os.listdir("../.."):
if x.endswith(".pon"):
os.remove("../%s" % x)
self.x_translator = x[:2]
self.releeTRA()
TrListas.ponPiecesLNG(self.x_pgn_english or self.translator() == "en")
self.tutor = self.buscaTutor(self.x_tutor_clave)
if self.tutor.key != self.x_tutor_clave:
self.x_tutor_clave = self.tutor.key
self.x_style = "WindowsVista"
def pgnSP(self):
dConv = TrListas.dConv()
resp = self.pgnBase
for k in dConv.keys():
if k in resp:
resp = resp.replace(k, dConv[k])
return resp + self.resultadoSP()
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 pgnSP(self):
dConv = TrListas.dConv()
resp = self.pgnBase
for k in dConv.keys():
if k in resp:
resp = resp.replace(k, dConv[k])
return resp + self.resultadoSP()
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.partida.liTags:
trad = TrListas.pgnLabel(clave)
if trad != clave:
clave = trad
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("opening", rotulo, Iconos.PuntoNaranja())
menu.separador()
menu.opcion("pgn", _("Edit PGN labels"), Iconos.PGN())
resp = menu.lanza()
if resp:
self.editarEtiquetasPGN()
def pgnSP(self, desde, hasta, coronacion=None):
dConv = TrListas.dConv()
resp = self.pgn(desde, hasta, coronacion)
for k in dConv.keys():
if k in resp:
resp = resp.replace(k, dConv[k])
return resp
def read_svg(self, base):
with open(base % "svg", "rb") as f:
x = f.read()
dic = TrListas.transsiberian()
for k, v in dic.iteritems():
x = x.replace(">%s<" % k, ">%s<" % v)
return x
def creaListaSonidos(self):
self.liSonidos = [["MC", _("After rival move"), None]]
# self.liSonidos.append( [ None, "", None ] )
self.liSonidos.append([None, "- " + _("Results") + " -", None])
d = collections.OrderedDict()
d["GANAMOS"] = _("You win")
d["GANARIVAL"] = _("Opponent wins")
d["TABLAS"] = _("Stalemate")
d["TABLASREPETICION"] = _("Draw due to three times repetition")
d["TABLAS50"] = _("Draw according to the 50 move rule")
d["TABLASFALTAMATERIAL"] = _("Draw, not enough material")
d["GANAMOSTIEMPO"] = _("You win on time")
d["GANARIVALTIEMPO"] = _("Opponent has won on time")
for c, tr in d.items():
self.liSonidos.append([c, tr, None])
# self.liSonidos.append( [ None, "", None ] )
self.liSonidos.append([None, "- " + _("Rival moves") + " -", None])
for c in "abcdefgh12345678":
self.liSonidos.append([c, c, None])
for c in "KQRBNP":
t = TrListas.letterPiece(c)
self.liSonidos.append([c, t, None])
for c in ("O-O", "O-O-O", "=", "x", "#", "+"):
self.liSonidos.append([c, c, None])
self.liSonidos.append([None, "", None])
self.liSonidos.append(["ZEITNOT", _("Zeitnot"), None])
def muestraInformacion(self):
li = []
li.append("%s: %d" % (_("Errors"), self.errores))
if self.siAyuda:
li.append(_("Help activated"))
self.ponRotulo1("\n".join(li))
tgm = 0
for tr in self.game["TRIES"]:
tgm += tr["TIME"]
mens = "\n" + "\n".join(self.liMensBasic)
mens += "\n%s:\n %s %s\n %s %s" % (
_("Working time"), time.strftime("%H:%M:%S", time.gmtime(tgm)),
_("Current"), time.strftime("%H:%M:%S", time.gmtime(
self.tm)), _("Total"))
self.ponRotulo2(mens)
if self.siAyuda:
dicNAGs = TrListas.dicNAGs()
mens3 = ""
fenM2 = self.partida.ultPosicion.fenM2()
reg = self.dbop.getfenvalue(fenM2)
if reg:
mens3 = reg.get("COMENTARIO", "")
ventaja = reg.get("VENTAJA", 0)
valoracion = reg.get("VALORACION", 0)
if ventaja:
mens3 += "\n %s" % dicNAGs[ventaja]
if valoracion:
mens3 += "\n %s" % dicNAGs[valoracion]
self.ponRotulo3(mens3 if mens3 else None)
def rehaz_columnas(self):
li_tags = self.dbGames.li_tags()
o_columns = self.grid.o_columns
si_cambios = False
li_remove = []
for n, col in enumerate(o_columns.liColumnas):
clave = col.clave
if not (clave in li_tags) and not (clave in ("__num__", "rowid")):
li_remove.append(n)
if li_remove:
si_cambios = True
li_remove.sort(reverse=True)
for n in li_remove:
del o_columns.liColumnas[n]
dcabs = self.dbGames.recuperaConfig("dcabs", DBgames.drots.copy())
st100 = {"Event", "Site", "White", "Black"}
stActual = {col.clave for col in self.grid.o_columns.liColumnas}
for tag in li_tags:
if not (tag in stActual):
rotulo = TrListas.pgnLabel(tag)
if rotulo == tag:
rotulo = dcabs.get(rotulo, rotulo)
o_columns.nueva(tag, rotulo, 100 if tag in st100 else 70, centered=not (tag in ("Event", "Site")))
si_cambios = True
if si_cambios:
self.dbGames.reset_cache()
self.grid.releerColumnas()
def informacion(self):
menu = QTVarios.LCMenu(self.main_window)
f = Controles.TipoLetra(puntos=10, peso=75)
menu.ponFuente(f)
siOpening = False
for key, valor in self.game.li_tags:
trad = TrListas.pgnLabel(key)
if trad != key:
key = trad
menu.opcion(key, "%s : %s" % (key, valor), Iconos.PuntoAzul())
if key.upper() == "OPENING":
siOpening = True
if not siOpening:
opening = self.game.opening
if opening:
menu.separador()
nom = opening.trNombre
ape = _("Opening")
label = nom if ape.upper() in nom.upper() else ("%s : %s" %
(ape, nom))
menu.opcion("opening", label, Iconos.PuntoNaranja())
menu.separador()
menu.opcion("pgn", _("Edit PGN labels"), Iconos.PGN())
resp = menu.lanza()
if resp:
self.editEtiquetasPGN()
def pgnSP(self, desde, hasta, coronacion=None):
dConv = TrListas.dConv()
resp = self.pgn(desde, hasta, coronacion)
for k in dConv.keys():
if k in resp:
resp = resp.replace(k, dConv[k])
return resp
def __init__(self, procesador, winBookGuide, dbGamesFEN):
QtGui.QWidget.__init__(self)
self.winBookGuide = winBookGuide
self.dbGamesFEN = dbGamesFEN
self.procesador = procesador
self.configuracion = procesador.configuracion
self.infoMove = None # <-- setInfoMove
self.numJugada = 0 # Se usa para indicarla al mostrar el pgn en infoMove
self.terminado = False # singleShot
self.liFiltro = []
self.where = None
# Grid
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("numero", _("N."), 70, siCentrado=True)
liBasic = dbGamesFEN.liCamposBase
for clave in liBasic:
if clave == "FEN":
continue
rotulo = TrListas.pgnLabel(clave)
siCentrado = clave != "EVENT"
ancho = 140 if clave == "FEN" else 70 # para que sirva con WBG_GamesFEN
oColumnas.nueva(clave, rotulo, ancho, siCentrado=siCentrado)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True, xid="wgamesfen")
# Status bar
self.status = QtGui.QStatusBar(self)
self.status.setFixedHeight(22)
# ToolBar
liAccionesWork = [
(_("Close"), Iconos.MainMenu(), self.tw_terminar), None,
(_("Database"), Iconos.DatabaseC(), self.tg_file), None,
(_("New"), Iconos.Nuevo(), self.tw_nuevo, _("Add a new game")), None,
(_("Edit"), Iconos.Modificar(), self.tw_editar), None,
(_("First"), Iconos.Inicio(), self.tw_gotop), None,
(_("Last"), Iconos.Final(), self.tw_gobottom), None,
(_("Filter"), Iconos.Filtrar(), self.tw_filtrar), None,
(_("Remove"), Iconos.Borrar(), self.tw_borrar),None,
]
self.tbWork = Controles.TBrutina(self, liAccionesWork, tamIcon=24)
self.lbName = Controles.LB(self, "").ponWrap().alinCentrado().ponColorFondoN("white", "#4E5A65").ponTipoLetra(puntos=16)
lyNT = Colocacion.H().control(self.lbName)
lyTB = Colocacion.H().control(self.tbWork)
layout = Colocacion.V().otro(lyNT).otro(lyTB).control(self.grid).control(self.status).margen(1)
self.setLayout(layout)
self.setNameToolBar()
def pgn_translated(self):
dConv = TrListas.dConv()
li = []
for c in self.pgnBase:
if c in dConv:
c = dConv[c]
li.append(c)
return "".join(li)
def pgn_translated(self, from_sq, to_sq, promotion=None):
dConv = TrListas.dConv()
li = []
for c in self.pgn(from_sq, to_sq, promotion):
if c in dConv:
c = dConv[c]
li.append(c)
return "".join(li)
def trPGN(self):
p = ""
pzs = "KQRBNPkqrbnp"
pgn = self.pgn
for n, c in enumerate(pgn):
if c in pzs and not pgn[n + 1].isdigit():
c = TrListas.letterPiece(c)
p += c
return p
def trPGN(self):
p = ""
pzs = "KQRBNPkqrbnp"
pgn = self.pgn
for n, c in enumerate(pgn):
if c in pzs and not pgn[n + 1].isdigit():
c = TrListas.letterPiece(c)
p += c
return p
def __init__(self, carpeta):
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
self.tr = trTraining
self.name = trTraining(os.path.basename(carpeta))
self.read(carpeta)
def leeEstandar(self, dic):
listSTD = TrListas.listSTD()
for name, eco, a1h8, pgn, siBasic in listSTD:
bloque = AperturaStd(name)
bloque.eco = eco
bloque.a1h8 = a1h8
bloque.pgn = pgn
bloque.siBasic = siBasic
dic[bloque.a1h8] = bloque
def lee(self):
dic = Util.restore_pickle(self.fichero)
if dic:
for x in dir(self):
if x.startswith("x_"):
if x in dic:
setattr(self, x, dic[x])
for x in os.listdir(".."):
if x.endswith(".pon"):
os.remove("../%s" % x)
self.x_translator = x[:2]
self.releeTRA()
TrListas.ponPiecesLNG(self.x_pgn_english or self.translator() == "en")
self.tutor = self.buscaTutor(self.x_tutor_clave)
if self.tutor.clave != self.x_tutor_clave:
self.x_tutor_clave = self.tutor.clave
def leeEstandar(self, dic):
listSTD = TrListas.listSTD()
for name, eco, a1h8, pgn, siBasic in listSTD:
bloque = AperturaStd(name)
bloque.eco = eco
bloque.a1h8 = a1h8
bloque.pgn = pgn
bloque.siBasic = siBasic
dic[bloque.a1h8] = bloque
def read_standard(dic):
list_std = TrListas.list_std()
for name, eco, a1h8, pgn, siBasic in list_std:
bloque = AperturaStd(name)
bloque.eco = eco
bloque.a1h8 = a1h8
bloque.pgn = pgn
bloque.siBasic = siBasic
dic[bloque.a1h8] = bloque
def basadoEn(self):
fich = self.configNivel.fichero[:-4]
li = fich.split("/" if "/" in fich else "\\")
d = TrListas.dicTraining()
base = li[1]
txt = d.get(base, _F(base))
if len(li) == 3:
fich = li[2]
txt += ", " + d.get(fich, _F(fich))
return txt
def __init__(self, carpeta):
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
self.tr = trTraining
self.name = trTraining(os.path.basename(carpeta))
self.read(carpeta)
def mousePressEvent(self, event):
siRight = event.button() == QtCore.Qt.RightButton
p = event.pos()
a1h8 = self.punto2a1h8(p)
m = int(event.modifiers())
is_ctrl = (m & QtCore.Qt.ControlModifier) > 0
is_shift = (m & QtCore.Qt.ShiftModifier) > 0
is_alt = (m & QtCore.Qt.AltModifier) > 0
li_tareas = self.guion.tareasPosicion(p)
if siRight and is_shift and is_alt:
pz_borrar = self.board.dameNomPiezaEn(a1h8)
menu = Controles.Menu(self.board)
dicPieces = TrListas.dicNomPiezas()
icoPiece = self.board.piezas.icono
if pz_borrar or len(li_tareas):
mrem = menu.submenu(_("Remove"), Iconos.Delete())
if pz_borrar:
label = dicPieces[pz_borrar.upper()]
mrem.opcion(("rem_pz", None), label, icoPiece(pz_borrar))
mrem.separador()
for pos_guion, tarea in li_tareas:
label = "%s - %s - %s" % (tarea.txt_tipo(), tarea.name(),
tarea.info())
mrem.opcion(("rem_gr", pos_guion), label, Iconos.Delete())
mrem.separador()
menu.separador()
for pz in "KQRBNPkqrbnp":
if pz != pz_borrar:
if pz == "k":
menu.separador()
menu.opcion(("create", pz), dicPieces[pz.upper()],
icoPiece(pz))
resp = menu.lanza()
if resp is not None:
orden, arg = resp
if orden == "rem_gr":
self.w.g_guion.goto(arg, 0)
self.w.borrar_lista()
elif orden == "rem_pz":
self.w.creaTarea("B", pz_borrar, a1h8, -1)
elif orden == "create":
self.w.creaTarea("C", arg, a1h8, -1)
return True
if self.director:
return self.mousePressEvent_Drop(event)
self.w.boardPress(event, a1h8, siRight, is_shift, is_alt, is_ctrl)
return True
def __init__(self, procesador):
titulo = _("Play against a game")
super().__init__(parent=procesador.pantalla,
titulo=titulo,
icono=Iconos.Law(),
extparam="playgame")
self.procesador = procesador
self.configuracion = procesador.configuracion
self.recno = None
self.db = PlayPGNs(self.configuracion.ficheroPlayPGN)
# Historico
oColumnas = Columnas.ListaColumnas()
def creaCol(clave, rotulo, siCentrado=True):
oColumnas.nueva(clave, rotulo, 80, siCentrado=siCentrado)
# # Claves segun orden estandar
liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK",
"RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO")
for clave in liBasic:
rotulo = TrListas.pgnLabel(clave)
creaCol(clave, rotulo, clave != "EVENT")
self.grid = Grid.Grid(self,
oColumnas,
siSelecFilas=True,
siSeleccionMultiple=True)
self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)
# Tool bar
liAcciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Play"), Iconos.Empezar(), self.empezar),
(_("New"), Iconos.Nuevo(), self.nuevo),
None,
(_("Remove"), Iconos.Borrar(), self.borrar),
None,
)
self.tb = Controles.TBrutina(self, liAcciones)
# Colocamos
lyTB = Colocacion.H().control(self.tb).margen(0)
ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)
self.setLayout(ly)
self.registrarGrid(self.grid)
self.recuperarVideo(siTam=False)
self.grid.gotop()
def pgn_translated(self, from_sq, to_sq, promotion=""):
d_conv = TrListas.dConv()
li = []
cpgn = self.pgn(from_sq, to_sq, promotion)
if not cpgn:
return ""
for c in cpgn:
if c in d_conv:
c = d_conv[c]
li.append(c)
return "".join(li)
def __init__(self, wmoves):
QtGui.QTreeWidget.__init__(self)
self.wmoves = wmoves
self.itemActivo = None
self.setAlternatingRowColors(True)
self.dicItems = {}
self.posMoves = 0
self.posTransposition = 1
self.posBookmark = 2
self.posAnalisis = 3
self.posComment = 4
self.setHeaderLabels((_("Moves"), "", "", _("Analysis"), _("Comments"), ""))
self.setColumnHidden(5, True)
self.setIndentation(14)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.menuContexto)
self.setStyleSheet("selection-background-color: #F1D369; selection-color: #000000;")
ftxt = Controles.TipoLetra(puntos=9)
self.setFont(ftxt)
self.connect(self, QtCore.SIGNAL("itemExpanded(QTreeWidgetItem *)"), self.expandido)
self.connect(self, QtCore.SIGNAL("itemSelectionChanged()"), self.seleccionadoISC)
self.connect(self, QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"), self.dobleClick)
self.noIcon = QtGui.QIcon()
self.iconBookmark = Iconos.Favoritos()
self.iconTransposition = Iconos.Transposition()
dicNAGs = TrListas.dicNAGs()
self.dicValoracion = collections.OrderedDict()
self.dicValoracion[BUENO] = (dicNAGs[1], PantallaColores.nag2ico(1,16))
self.dicValoracion[MALO] = (dicNAGs[2], PantallaColores.nag2ico(2,16))
self.dicValoracion[MUY_BUENO] = (dicNAGs[3], PantallaColores.nag2ico(3,16))
self.dicValoracion[MUY_MALO] = (dicNAGs[4], PantallaColores.nag2ico(4,16))
self.dicValoracion[INTERESANTE] = (dicNAGs[5], PantallaColores.nag2ico(5,16))
self.dicValoracion[DUDOSA] = (dicNAGs[6], PantallaColores.nag2ico(6,16))
self.dicValoracion[SIN_VALORACION] = (_("No rating"), self.noIcon )
self.dicVentaja = collections.OrderedDict()
self.dicVentaja[V_SIN] = ( _("Undefined"), self.noIcon )
self.dicVentaja[V_IGUAL] = ( dicNAGs[11], Iconos.V_Blancas_Igual_Negras() )
self.dicVentaja[V_BLANCAS] = ( dicNAGs[14], Iconos.V_Blancas() )
self.dicVentaja[V_BLANCAS_MAS] = ( dicNAGs[16], Iconos.V_Blancas_Mas() )
self.dicVentaja[V_BLANCAS_MAS_MAS] = ( dicNAGs[18], Iconos.V_Blancas_Mas_Mas() )
self.dicVentaja[V_NEGRAS] = ( dicNAGs[15], Iconos.V_Negras() )
self.dicVentaja[V_NEGRAS_MAS] = ( dicNAGs[17], Iconos.V_Negras_Mas() )
self.dicVentaja[V_NEGRAS_MAS_MAS] = ( dicNAGs[19], Iconos.V_Negras_Mas_Mas() )
def __init__(self, procesador):
titulo = _("Play against a game")
QTVarios.WDialogo.__init__(self, procesador.main_window, titulo,
Iconos.Law(), "playgame")
self.procesador = procesador
self.configuracion = procesador.configuracion
self.recno = None
self.db = DBPlayGame(self.configuracion.file_play_game())
# Historico
o_columns = Columnas.ListaColumnas()
def creaCol(key, rotulo, centered=True):
o_columns.nueva(key, rotulo, 80, centered=centered)
# # Claves segun orden estandar
liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK",
"RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO")
for key in liBasic:
rotulo = TrListas.pgnLabel(key)
creaCol(key, rotulo, key != "EVENT")
self.grid = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True)
self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)
# Tool bar
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Play"), Iconos.Empezar(), self.play),
(_("New"), Iconos.Nuevo(), self.new),
None,
(_("Remove"), Iconos.Borrar(), self.remove),
None,
)
self.tb = QTVarios.LCTB(self, li_acciones)
# Colocamos
lyTB = Colocacion.H().control(self.tb).margen(0)
ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)
self.setLayout(ly)
self.register_grid(self.grid)
self.restore_video(siTam=False)
self.grid.gotop()
def __init__(self, wmoves):
QtGui.QTreeWidget.__init__(self)
self.wmoves = wmoves
self.itemActivo = None
self.setAlternatingRowColors(True)
self.dicItems = {}
self.posMoves = 0
self.posTransposition = 1
self.posBookmark = 2
self.posAnalisis = 3
self.posComment = 4
self.setHeaderLabels((_("Moves"), "", "", _("Analysis"), _("Comments"), ""))
self.setColumnHidden(5, True)
self.setIndentation(14)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.menuContexto)
self.setStyleSheet("selection-background-color: #F1D369; selection-color: #000000;")
ftxt = Controles.TipoLetra(puntos=9)
self.setFont(ftxt)
self.connect(self, QtCore.SIGNAL("itemExpanded(QTreeWidgetItem *)"), self.expandido)
self.connect(self, QtCore.SIGNAL("itemSelectionChanged()"), self.seleccionadoISC)
self.connect(self, QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"), self.dobleClick)
self.noIcon = QtGui.QIcon()
self.iconBookmark = Iconos.Favoritos()
self.iconTransposition = Iconos.Transposition()
dicNAGs = TrListas.dicNAGs()
self.dicValoracion = collections.OrderedDict()
self.dicValoracion[BUENO] = (dicNAGs[1], PantallaColores.nag2ico(1, 16))
self.dicValoracion[MALO] = (dicNAGs[2], PantallaColores.nag2ico(2, 16))
self.dicValoracion[MUY_BUENO] = (dicNAGs[3], PantallaColores.nag2ico(3, 16))
self.dicValoracion[MUY_MALO] = (dicNAGs[4], PantallaColores.nag2ico(4, 16))
self.dicValoracion[INTERESANTE] = (dicNAGs[5], PantallaColores.nag2ico(5, 16))
self.dicValoracion[DUDOSA] = (dicNAGs[6], PantallaColores.nag2ico(6, 16))
self.dicValoracion[SIN_VALORACION] = (_("No rating"), self.noIcon)
self.dicVentaja = collections.OrderedDict()
self.dicVentaja[V_SIN] = (_("Undefined"), self.noIcon)
self.dicVentaja[V_IGUAL] = (dicNAGs[11], Iconos.V_Blancas_Igual_Negras())
self.dicVentaja[V_BLANCAS] = (dicNAGs[14], Iconos.V_Blancas())
self.dicVentaja[V_BLANCAS_MAS] = (dicNAGs[16], Iconos.V_Blancas_Mas())
self.dicVentaja[V_BLANCAS_MAS_MAS] = (dicNAGs[18], Iconos.V_Blancas_Mas_Mas())
self.dicVentaja[V_NEGRAS] = (dicNAGs[15], Iconos.V_Negras())
self.dicVentaja[V_NEGRAS_MAS] = (dicNAGs[17], Iconos.V_Negras_Mas())
self.dicVentaja[V_NEGRAS_MAS_MAS] = (dicNAGs[19], Iconos.V_Negras_Mas_Mas())
def __init__(self, procesador):
titulo = _("Learn a game")
QTVarios.WDialogo.__init__(self, procesador.pantalla, titulo,
Iconos.PGN(), "learngame")
self.procesador = procesador
self.configuracion = procesador.configuracion
self.db = LearnPGNs(self.configuracion.ficheroLearnPGN)
# Historico
oColumnas = Columnas.ListaColumnas()
def creaCol(clave, rotulo, siCentrado=True):
oColumnas.nueva(clave, rotulo, 80, siCentrado=siCentrado)
# # Claves segun orden estandar
liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK",
"RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO")
for clave in liBasic:
rotulo = TrListas.pgnLabel(clave)
creaCol(clave, rotulo, clave != "EVENT")
self.grid = Grid.Grid(self,
oColumnas,
siSelecFilas=True,
siSeleccionMultiple=True)
self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)
# Tool bar
liAcciones = (
(_("Quit"), Iconos.MainMenu(), "terminar"),
None,
(_("New"), Iconos.TutorialesCrear(), "nuevo"),
None,
(_("Remove"), Iconos.Borrar(), "borrar"),
None,
(_("Start"), Iconos.Empezar(), "empezar"),
)
self.tb = Controles.TB(self, liAcciones)
# Colocamos
lyTB = Colocacion.H().control(self.tb).margen(0)
ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)
self.setLayout(ly)
self.registrarGrid(self.grid)
self.recuperarVideo(siTam=False)
self.grid.gotop()
def gridDato(self, grid, fila, oColumna):
if oColumna.clave == "ETIQUETA":
lb = self.liPGN[fila][0]
ctra = lb.upper()
trad = TrListas.pgnLabel(lb)
if trad != ctra:
clave = trad
else:
if lb:
clave = lb # [0].upper()+lb[1:].lower()
else:
clave = ""
return clave
return self.liPGN[fila][1]
def __init__(self, owner, procesador):
QtGui.QTreeWidget.__init__(self)
self.owner = owner
self.dbCache = owner.dbCache
self.setAlternatingRowColors(True)
self.listaMoves = owner.listaMoves
self.procesador = procesador
# self.setSelectionMode(self.ExtendedSelection)
# self.setDragDropMode(self.InternalMove)
# self.setDragEnabled(True)
# self.setDropIndicatorShown(True)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.menuContexto)
self.setHeaderLabels(
(_("Moves"), _("Points"), _("Comments"), _("Variants"), "", ""))
self.setColumnHidden(4, True)
dicNAGs = TrListas.dicNAGs()
self.dicValoracion = collections.OrderedDict()
self.dicValoracion["1"] = (MUY_BUENO, dicNAGs[3])
self.dicValoracion["2"] = (BUENO, dicNAGs[1])
self.dicValoracion["3"] = (MALO, dicNAGs[2])
self.dicValoracion["4"] = (MUY_MALO, dicNAGs[4])
self.dicValoracion["5"] = (INTERESANTE, dicNAGs[5])
self.dicValoracion["6"] = (DUDOSA, dicNAGs[6])
self.dicValoracion["0"] = (SIN_VALORACION, _("No rating"))
ftxt = Controles.TipoLetra(puntos=9)
self.setFont(ftxt)
self.connect(
self,
QtCore.SIGNAL(
"currentItemChanged(QTreeWidgetItem *,QTreeWidgetItem *)"),
self.seleccionado)
self.connect(self,
QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"),
self.editado)
hitem = self.header()
hitem.setClickable(True)
self.connect(hitem, QtCore.SIGNAL("sectionDoubleClicked(int)"),
self.editadoH)
self.dicItemMoves = {}
self.ponMoves(self.listaMoves)
self.sortItems(4, QtCore.Qt.AscendingOrder)
def grid_dato(self, grid, fila, oColumna):
if oColumna.clave == "ETIQUETA":
lb = self.li_labels[fila][0]
ctra = lb.upper()
trad = TrListas.pgnLabel(lb)
if trad != ctra:
key = trad
else:
if lb:
key = lb # [0].upper()+lb[1:].lower()
else:
key = ""
return key
return self.li_labels[fila][1]
def grid_dato(self, grid, row, o_column):
if o_column.key == "ETIQUETA":
lb, value = self.li_labels[row]
ctra = lb.upper()
trad = TrListas.pgnLabel(lb)
if trad != ctra:
key = trad
else:
if lb:
key = lb
else:
key = ""
return key
return self.li_labels[row][1]
def gridDato(self, grid, fila, oColumna):
if oColumna.clave == "ETIQUETA":
lb = self.liPGN[fila][0]
ctra = lb.upper()
trad = TrListas.pgnLabel(lb)
if trad != ctra:
clave = trad
else:
if lb:
clave = lb # [0].upper()+lb[1:].lower()
else:
clave = ""
return clave
return self.liPGN[fila][1]
def lista_columnas(self):
dcabs = self.dbGames.recuperaConfig("dcabs", DBgames.drots.copy())
o_columns = Columnas.ListaColumnas()
o_columns.nueva("__num__", _("N."), 60, centered=True)
li_tags = self.dbGames.li_tags()
st100 = {"Event", "Site", "White", "Black"}
for tag in li_tags:
rotulo = TrListas.pgnLabel(tag)
if rotulo == tag:
rotulo = dcabs.get(rotulo, rotulo)
centered = not (tag in ("Event", "Site"))
ancho = 100 if tag in st100 else 80
o_columns.nueva(tag, rotulo, ancho, centered=centered)
o_columns.nueva("rowid", _("Row ID"), 60, centered=True)
return o_columns
def grid_dato(self, grid, row, o_column):
if o_column.key == "ETIQUETA":
lb = self.liPGN[row][0]
ctra = lb.upper()
trad = TrListas.pgnLabel(lb)
if trad != ctra:
key = trad
else:
if lb:
key = lb # [0].upper()+lb[1:].lower()
else:
key = ""
return key
if row < len(self.liPGN):
return self.liPGN[row][1]
def __init__(self, procesador):
titulo = _("Learn a game")
QTVarios.WDialogo.__init__(self, procesador.pantalla, titulo, Iconos.PGN(), "learngame")
self.procesador = procesador
self.configuracion = procesador.configuracion
self.db = LearnPGNs(self.configuracion.ficheroLearnPGN)
# Historico
oColumnas = Columnas.ListaColumnas()
def creaCol(clave, rotulo, siCentrado=True):
oColumnas.nueva(clave, rotulo, 80, siCentrado=siCentrado)
# # Claves segun orden estandar
liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK", "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO" )
for clave in liBasic:
rotulo = TrListas.pgnLabel(clave)
creaCol(clave, rotulo, clave != "EVENT")
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True)
self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)
# Tool bar
liAcciones = (
( _("Quit"), Iconos.MainMenu(), "terminar" ), None,
( _("New"), Iconos.TutorialesCrear(), "nuevo" ), None,
( _("Remove"), Iconos.Borrar(), "borrar" ), None,
( _("Start"), Iconos.Empezar(), "empezar" ),
)
self.tb = Controles.TB(self, liAcciones)
# Colocamos
lyTB = Colocacion.H().control(self.tb).margen(0)
ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)
self.setLayout(ly)
self.registrarGrid(self.grid)
self.recuperarVideo(siTam=False)
self.grid.gotop()
def creaListaSonidos(self):
self.liSonidos = [
["MC", _("After rival move"), None],
]
# self.liSonidos.append( [ None, "", None ] )
self.liSonidos.append([None, "- " + _("Results") + " -", None])
d = collections.OrderedDict()
d["GANAMOS"] = _("You win")
d["GANARIVAL"] = _("Opponent wins")
d["TABLAS"] = _("Stalemate")
d["TABLASREPETICION"] = _("Draw due to three times repetition")
d["TABLAS50"] = _("Draw according to the 50 move rule")
d["TABLASFALTAMATERIAL"] = _("Draw, not enough material")
d["GANAMOSTIEMPO"] = _("You win on time")
d["GANARIVALTIEMPO"] = _("Opponent has won on time")
for c, tr in d.iteritems():
self.liSonidos.append([c, tr, None])
# self.liSonidos.append( [ None, "", None ] )
self.liSonidos.append([None, "- " + _("Rival moves") + " -", None])
for c in "abcdefgh12345678":
self.liSonidos.append([c, c, None])
for c in "KQRBNP":
t = TrListas.letterPiece(c)
self.liSonidos.append([c, t, None])
for c in ( "O-O", "O-O-O", "=", "x", "#", "+" ):
self.liSonidos.append([c, c, None])
self.liSonidos.append([None, "", None])
self.liSonidos.append(["ZEITNOT", _("Zeitnot"), None])
def cambiaColoresPGN(ventana, configuracion):
liGen = [(None, None)]
dicNAGs = TrListas.dicNAGs()
config = FormLayout.Colorbox(dicNAGs[1], 80, 20, siSTR=True)
liGen.append(( config, configuracion.color_nag1 ))
config = FormLayout.Colorbox(dicNAGs[2], 80, 20, siSTR=True)
liGen.append(( config, configuracion.color_nag2 ))
config = FormLayout.Colorbox(dicNAGs[3], 80, 20, siSTR=True)
liGen.append(( config, configuracion.color_nag3 ))
config = FormLayout.Colorbox(dicNAGs[4], 80, 20, siSTR=True)
liGen.append(( config, configuracion.color_nag4 ))
config = FormLayout.Colorbox(dicNAGs[5], 80, 20, siSTR=True)
liGen.append(( config, configuracion.color_nag5 ))
config = FormLayout.Colorbox(dicNAGs[6], 80, 20, siSTR=True)
liGen.append(( config, configuracion.color_nag6 ))
resultado = FormLayout.fedit(liGen, title=_("PGN"), parent=ventana, icon=Iconos.Vista(), siDefecto=True)
if resultado:
accion, liResp = resultado
if accion == "defecto":
configuracion.coloresPGNdefecto()
configuracion.graba()
cambiaColoresPGN(ventana, configuracion)
else:
configuracion.color_nag1 = liResp[0]
configuracion.color_nag2 = liResp[1]
configuracion.color_nag3 = liResp[2]
configuracion.color_nag4 = liResp[3]
configuracion.color_nag5 = liResp[4]
configuracion.color_nag6 = liResp[5]
configuracion.graba()
def lee(self):
self.siAplazada = False
if not os.path.isfile(self.fichero):
CajonDesastre.compruebaCambioVersion(self)
else:
fbak = self.fichero + ".CP.%d" % NIVELBAK
if not Util.existeFichero(fbak):
Util.copiaFichero(self.fichero, fbak)
dic = Util.recuperaDIC(self.fichero)
if dic:
dg = dic.get
self.id = dic["ID"]
self.version = dic.get("VERSION", "")
self.jugador = dic["JUGADOR"]
self.estilo = dg("ESTILO", "Cleanlooks")
self.tiempoTutor = dic["TIEMPOTUTOR"]
if self.tiempoTutor == 0:
self.tiempoTutor = 3000
self.siSuenaBeep = dic["SIBEEP"]
self.siSuenaJugada = dg("SISUENAJUGADA", False)
self.siSuenaResultados = dg("SISUENARESULTADOS", False)
self.siSuenaNuestro = dg("SISUENANUESTRO", False)
self.efectosVisuales = dg("EFECTOS_VISUALES", True)
self.rapidezMovPiezas = dg("RAPIDEZMOVPIEZAS", self.rapidezMovPiezas)
self.siAtajosRaton = dg("ATAJOS_RATON", False)
self.showCandidates = dg("SHOW_CANDIDATES", False)
self.siActivarCapturas = dg("ACTIVAR_CAPTURAS", self.siActivarCapturas)
self.siActivarInformacion = dg("ACTIVAR_INFORMACION", self.siActivarInformacion)
self.guardarVariantesTutor = dg("GUARDAR_VARIANTES", True)
self.dirSalvados = dic["DIRSALVADOS"]
self.dirPGN = dg("DIRPGN", "")
self.dirJS = dg("DIRJS", "")
self.traductor = dic["TRADUCTOR"].lower()
self.salvarFichero = dic["SALVAR_FICHERO"]
self.salvarGanados = dic["SALVAR_GANADOS"]
self.salvarPerdidos = dic["SALVAR_PERDIDOS"]
self.salvarAbandonados = dg("SALVAR_ABANDONADOS", False)
self.salvarCSV = dg("SALVAR_CSV", "")
self.vistaTutor = dg("VISTA_TUTOR", kTutorH)
self.rival = self.buscaRival(dic["RIVAL"], self.rivalInicial)
self.tutor = self.buscaTutor(dic["TUTOR"], self.tutorInicial)
self.siNomPiezasEN = dg("SINOMPIEZASEN", self.siNomPiezasEN)
self.tutorDifPts = dg("TUTOR_DIFPTS", 0)
self.tutorDifPorc = dg("TUTOR_DIFPORC", 0)
self.tutorActivoPorDefecto = dg("TUTORACTIVODEFECTO", True)
self.tutorMultiPV = dg("TUTOR_MULTIPV", "MX")
fich = dg("DBGAMES", self.ficheroDBgames)
if os.path.isfile(fich):
self.ficheroDBgames = fich
fich = dg("DBGAMESFEN", self.ficheroDBgamesFEN)
if os.path.isfile(fich):
self.ficheroDBgamesFEN = fich
self.ficheroBookGuide = dg("BOOKGUIDE", self.ficheroBookGuide)
self.elo = dg("ELO", 0)
self.eloNC = dg("ELONC", 1600)
self.michelo = dg("MICHELO", self.michelo)
self.micheloNC = dg("MICHELONC", self.micheloNC)
self.fics = dg("FICS", self.fics)
self.ficsNC = dg("FICSNC", self.ficsNC)
self.fide = dg("FIDE", self.fide)
self.fideNC = dg("FIDENC", self.fideNC)
self.siDGT = dg("SIDGT", False)
self.familia = dg("FAMILIA", self.familia)
self.puntosMenu = dg("PUNTOSMENU", self.puntosMenu)
self.boldMenu = dg("BOLDMENU", self.boldMenu)
self.puntosTB = dg("PUNTOSTB", self.puntosTB)
self.boldTB = dg("BOLDTB", self.boldTB)
self.color_nag1 = dg("COLOR_NAG1", self.color_nag1)
self.color_nag2 = dg("COLOR_NAG2", self.color_nag2)
self.color_nag3 = dg("COLOR_NAG3", self.color_nag3)
self.color_nag4 = dg("COLOR_NAG4", self.color_nag4)
self.color_nag5 = dg("COLOR_NAG5", self.color_nag5)
self.color_nag6 = dg("COLOR_NAG6", self.color_nag6)
self.tamFontRotulos = dg("TAMFONTROTULOS", self.tamFontRotulos)
self.anchoPGN = dg("ANCHOPGN", self.anchoPGN)
self.puntosPGN = dg("PUNTOSPGN", self.puntosPGN)
self.altoFilaPGN = dg("ALTOFILAPGN", self.altoFilaPGN)
self.figurinesPGN = dg("FIGURINESPGN", False)
self.showVariantes = dg("SHOW_VARIANTES", False)
self.tipoMaterial = dg("TIPOMATERIAL", self.tipoMaterial)
self.ficheroBMT = dg("FICHEROBMT", self.ficheroBMT)
self.liTrasteros = dg("TRASTEROS", [])
self.liFavoritos = dg("FAVORITOS", [])
self.liPersonalidades = dg("PERSONALIDADES", [])
self.centipawns = dg("CENTIPAWNS", self.centipawns)
self.voice = dg("VOICE", self.voice)
for k in dic.keys():
if k.startswith("RIVAL_"):
claveK = k[6:]
for clave, rival in self.dicRivales.iteritems():
if rival.clave == claveK:
rival.lee(dic[k])
if "APLAZAMIENTO" in dic:
self.siAplazada = True
try:
self.aplazamiento = Util.txt2dic(dic["APLAZAMIENTO"])
except:
self.aplazamiento = None
self.siAplazada = False
self.graba()
self.dicTrad = {'english': "en", 'español': "es", 'francais': "fr",
'deutsch': "de", 'portuguese': "pt", 'russian': "ru",
"italiano": "it", "azeri": "az", "català": "ca",
"vietnamese": "vi", "swedish": "sv"}
# Si viene de la instalacion
for k, v in self.dicTrad.iteritems():
if os.path.isfile(v + '.pon'):
self.traductor = v
self.graba()
os.remove(v + '.pon')
# Versiones antiguas
if self.traductor in self.dicTrad:
self.traductor = self.dicTrad[self.traductor]
self.releeTRA()
TrListas.ponPiecesLNG(self.siNomPiezasEN or self.traductor == "en")
self.setVoice()
def info(self):
pz = TrListas.letterPiece(self._pieza)
return (pz if pz.isupper() else pz.lower()) + " -> " + self._desde
def nombre(self):
return TrListas.categoria(self.clave)
def __init__(self, owner, dbf, dClaves, gestor, estado, siElegir):
titulo = _("Choose a game to view") if siElegir else _("PGN viewer")
icono = Iconos.PGN()
extparam = "pgnelegir"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.siElegir = siElegir
self.gestor = gestor
self.dClaves = dClaves = copy.deepcopy(dClaves)
self.seHaBorradoAlgo = False # Para que se haga un touch antiguo al DB y lo regenere la proxima vez
siRepite = estado is not None
if siRepite:
self.estado = estado
else:
self.estado = EstadoWpgn()
self.dbf = dbf
if siRepite:
self.estado.recuperaDBF(dbf)
else:
self.dbf.leer()
# Filtro
self.liFiltro = self.estado.liFiltro if siRepite else []
# Status bar-> antes que grid porque se actualiza en gridNumDatos
self.status = QtGui.QStatusBar(self)
self.status.setFixedHeight(22)
# Lista
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("numero", _("N."), 50, siCentrado=True)
def creaCol(clave, rotulo, siCentrado=True):
tam = max(dClaves[clave], len(rotulo), 11)
oColumnas.nueva(clave, rotulo, tam * 6, siCentrado=siCentrado)
# # Claves segun orden estandar
liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK", "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO" )
self.liOrdenClaves = [] # nos servira en el exterior, para paste pgn y para mostrar info
for clave in liBasic:
if clave in dClaves:
rotulo = TrListas.pgnLabel(clave)
creaCol(clave, rotulo, clave != "EVENT")
self.liOrdenClaves.append(clave)
for clave in dClaves:
if clave.upper() not in liBasic:
rotulo = TrListas.pgnLabel(clave)
creaCol(clave.upper(), rotulo, clave != "EVENT")
self.liOrdenClaves.append(clave.upper())
dicVideoGrid = self.estado.dicVideoGrid if siRepite else None
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, dicVideo=dicVideoGrid, siSeleccionMultiple=True)
if siRepite:
self.grid.goto(self.estado.recno, 0)
else:
self.grid.gotop()
if siRepite:
self.estado.recuperaWindow(self)
else:
n = self.grid.anchoColumnas() + 20
w, h = QTUtil.tamEscritorio()
self.resize(min(w * 9 / 10, n), h * 8 / 10)
# Toolbar
if siElegir:
liAcciones = [( _("Choose"), Iconos.Aceptar(), self.elegir ), None,
( _("Cancel"), Iconos.Cancelar(), self.cancelar ), None,
( _("First"), Iconos.Inicio(), self.grid.gotop ),
( _("Last"), Iconos.Final(), self.grid.gobottom ), None,
( _("Filter"), Iconos.Filtrar(), self.filtrar ), None,
]
else:
liAcciones = [
( _("Close"), Iconos.MainMenu(), self.cancelar ), None,
( _("View"), Iconos.Ver(), self.elegir ), None,
( _("Edit"), Iconos.Modificar(), self.editar ), None,
( _("Save"), Iconos.Grabar(), self.guardar ), None,
( _("First"), Iconos.Inicio(), self.grid.gotop ),
( _("Last"), Iconos.Final(), self.grid.gobottom ), None,
( _("Filter"), Iconos.Filtrar(), self.filtrar ), None,
( _("Remove"), Iconos.Borrar(), self.borrar ), None,
( _("Utilities"), Iconos.Utilidades(), self.utilidades ), None
]
tb = Controles.TBrutina(self, liAcciones)
# Layout
layout = Colocacion.V().control(tb).control(self.grid).control(self.status).margen(3)
self.setLayout(layout)
self.recuperarVideo(siTam=False)
self.ponStatus()
def inicio(self, posEntreno, numEntrenos, titEntreno, liEntrenos, siTutorActivado=None, jump=False):
if hasattr(self, "reiniciando"):
if self.reiniciando:
return
self.reiniciando = True
if siTutorActivado is None:
siTutorActivado = (VarGen.dgtDispatch is None) and self.configuracion.tutorActivoPorDefecto
self.posEntreno = posEntreno
self.guardaPosicion(posEntreno)
self.numEntrenos = numEntrenos
self.titEntreno = titEntreno
self.liEntrenos = liEntrenos
self.jump = jump
self.liHistorico = [self.posEntreno]
self.ayudas = 99999
fenInicial = self.liEntrenos[self.posEntreno - 1].strip()
self.fenInicial = fenInicial
self.rivalPensando = False
self.dicEtiquetasPGN = None
# Dirigido
etiDirigido = ""
self.siDirigido = False
self.siDirigidoSeguir = None
self.siDirigidoVariantes = False
siPartidaOriginal = False
if "|" in fenInicial:
li = fenInicial.split("|")
fenInicial = li[0]
if fenInicial.endswith(" 0"):
fenInicial = fenInicial[:-1] + "1"
nli = len(li)
if nli >= 2:
etiDirigido = li[1]
# # Solucion
if nli >= 3:
solucion = li[2]
if solucion:
self.dicDirigidoFen = PGN.leeEntDirigido(fenInicial, solucion)
self.siDirigido = self.dicDirigidoFen and len(self.dicDirigidoFen) > 0
## Partida original
if nli >= 4:
if nli > 4:
txt = "|".join(li[3:])
else:
txt = li[3]
txt = txt.replace("]", "]\n").replace(" [", "[")
pgn = PGN.UnPGN()
pgn.leeTexto(txt)
partida = pgn.partida
siEstaFen = False
njug = partida.numJugadas()
for n in range(njug - 1, -1, -1):
jg = partida.jugada(n)
if jg.posicion.fen() == fenInicial:
siEstaFen = True
if n + 1 != njug:
partida.liJugadas = partida.liJugadas[:n + 1]
partida.ultPosicion = jg.posicion.copia()
break
if siEstaFen:
siPartidaOriginal = True
self.partida = partida
self.pgn.partida = partida
self.dicEtiquetasPGN = pgn.dic
# if etiDirigido:
# etiDirigido += "<br>"
# for k, v in pgn.dic.iteritems():
# if k.upper() != "FEN":
# if etiDirigido:
# etiDirigido += "<br>"
# etiDirigido += "%s: <b>%s</b>"%(k,v)
cp = ControlPosicion.ControlPosicion()
cp.leeFen(fenInicial)
self.fen = fenInicial
siBlancas = cp.siBlancas
if not siPartidaOriginal:
self.partida.reset(cp)
self.partida.pendienteApertura = False
self.tipoJuego = kJugEntPos
self.siJuegaHumano = False
self.estado = kJugando
self.siJuegaPorMi = True
self.siJugamosConBlancas = siBlancas
self.siRivalConBlancas = not siBlancas
self.liVariantes = []
self.rmRival = None
self.siTutorActivado = siTutorActivado
self.pantalla.ponActivarTutor(self.siTutorActivado)
self.ayudasPGN = 0
liOpciones = [k_mainmenu, k_cambiar, k_reiniciar, k_atras]
if self.dicEtiquetasPGN:
liOpciones.append(k_pgnInformacion)
if self.numEntrenos > 1:
liOpciones.append(k_anterior)
liOpciones.append(k_siguiente)
liOpciones.extend((k_configurar, k_utilidades))
self.liOpcionesToolBar = liOpciones
self.pantalla.ponToolBar(liOpciones)
self.pantalla.activaJuego(True, False, siAyudas=False)
self.pantalla.quitaAyudas(False, False)
self.ponMensajero(self.mueveHumano)
self.ponPosicion(self.partida.ultPosicion)
self.mostrarIndicador(True)
self.ponPiezasAbajo(siBlancas)
titulo = "<b>%s</b>" % TrListas.dicTraining().get(self.titEntreno, self.titEntreno)
if etiDirigido:
titulo += "<br>%s" % etiDirigido
self.ponRotulo1(titulo)
self.ponRotulo2("%d / %d" % (posEntreno, numEntrenos))
self.pgnRefresh(True)
QTUtil.xrefreshGUI()
self.xrival = self.procesador.creaGestorMotor(self.configuracion.tutor, self.configuracion.tiempoTutor, None)
self.siAnalizadoTutor = False
self.ponPosicionDGT()
if siPartidaOriginal:
# self.ponteAlFinal()
self.repiteUltimaJugada()
self.reiniciando = False
self.rivalPensando = False
self.siguienteJugada()
def __init__(self, procesador, winBookGuide, dbGames, wsummary, siMoves=True, siFEN=False):
QtGui.QWidget.__init__(self)
self.winBookGuide = winBookGuide
self.dbGames = dbGames # <--setdbGames
self.procesador = procesador
self.configuracion = procesador.configuracion
self.siMoves = siMoves
self.wsummary = wsummary
self.infoMove = None # <-- setInfoMove
self.summaryActivo = None # movimiento activo en summary
self.numJugada = 0 # Se usa para indicarla al mostrar el pgn en infoMove
self.liFiltro = []
self.siFiltro = False
# Grid
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("numero", _("N."), 70, siCentrado=True)
liBasic = dbGames.liCamposBase
ancho = 70
for clave in liBasic:
rotulo = TrListas.pgnLabel(clave)
siCentrado = clave != "EVENT"
if siFEN:
ancho = 140 if clave == "FEN" else 70 # para que sirva con WBG_GamesFEN
oColumnas.nueva(clave, rotulo, ancho, siCentrado=siCentrado)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True, id="wgames")
# Status bar
self.status = QtGui.QStatusBar(self)
self.btLeerMas = Controles.PB(self, _("Show more games"), rutina=self.leerMas, plano=False)
self.btLeerMas.setFixedHeight(18)
self.status.addPermanentWidget(self.btLeerMas)
self.status.setFixedHeight(22)
# ToolBar
liAccionesWork = [
( _("Close"), Iconos.MainMenu(), self.tw_terminar ), None,
( _("New"), Iconos.Nuevo(), self.tw_nuevo ), None,
( _("Edit"), Iconos.Modificar(), self.tw_editar ), None,
( _("First"), Iconos.Inicio(), self.tw_gotop ), None,
( _("Last"), Iconos.Final(), self.tw_gobottom ), None,
( _("Filter"), Iconos.Filtrar(), self.tw_filtrar ), None,
( _("Remove"), Iconos.Borrar(), self.tw_borrar ), None, None,
( _("Change"), Iconos.DatabaseF() if siFEN else Iconos.DatabaseC(), self.tg_change ), None,
( _("Import"), Iconos.MasDoc(), self.tg_importar ), None,
( _("Export"), Iconos.Grabar(), self.tg_exportar ), None,
]
if not siFEN:
liAccionesWork.extend([( _("Utilities"), Iconos.Utilidades(), self.tw_utilidades ), None])
self.tbWork = Controles.TBrutina(self, liAccionesWork, tamIcon=24)
self.lbName = Controles.LB(self, "").ponWrap().alinCentrado().ponColorFondoN("white", "#4E5A65").ponTipoLetra(
puntos=16)
lyNT = Colocacion.H().control(self.lbName)
if not siMoves:
self.lbName.hide()
lyTB = Colocacion.H().control(self.tbWork).relleno() # .control(self.tbGen)
layout = Colocacion.V().otro(lyNT).otro(lyTB).control(self.grid).control(self.status).margen(1)
self.setLayout(layout)
self.setNameToolBar()
def __init__(self, owner, nomPiezasOri):
titulo = _("Blindfold") + " - " + _("Configuration")
icono = Iconos.Ojo()
extparam = "wblindfold"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.config = BlindfoldConfig(nomPiezasOri)
self.nomPiezasOri = nomPiezasOri
lbWhite = Controles.LB(self, _("White")).ponTipoLetra(peso=75, puntos=10)
lbBlack = Controles.LB(self, _("Black")).ponTipoLetra(peso=75, puntos=10)
self.dicWidgets = collections.OrderedDict()
self.dicImgs = {}
liOpciones = (
( _("Hide"), HIDE ),
( _("Green"), GREY ),
( _("Checker"), CHECKER ),
( _("Show"), SHOW ),
)
dicNomPiezas = TrListas.dicNomPiezas()
def haz(pz):
tpW = self.config.dicPiezas[pz.upper()]
tpB = self.config.dicPiezas[pz]
lbPZw = Controles.LB(self)
cbPZw = Controles.CB(self, liOpciones, tpW).capturaCambiado(self.reset)
lbPZ = Controles.LB(self, dicNomPiezas[pz.upper()]).ponTipoLetra(peso=75, puntos=10)
lbPZb = Controles.LB(self)
cbPZb = Controles.CB(self, liOpciones, tpB).capturaCambiado(self.reset)
self.dicWidgets[pz] = [lbPZw, cbPZw, lbPZ, lbPZb, cbPZb, None, None]
for pz in "kqrbnp":
haz(pz)
btAllW = Controles.PB(self, _("All White"), self.allWhite, plano=False)
self.cbAll = Controles.CB(self, liOpciones, HIDE)
btAllB = Controles.PB(self, _("All Black"), self.allBlack, plano=False)
btSwap = Controles.PB(self, _("Swap"), self.swap, plano=False)
liAcciones = ( ( _("Save"), Iconos.Grabar(), "grabar" ), None,
( _("Cancel"), Iconos.Cancelar(), "cancelar" ), None,
( _("Configurations"), Iconos.Opciones(), "configurations" ), None,
)
tb = Controles.TB(self, liAcciones)
ly = Colocacion.G()
ly.controlc(lbWhite, 0, 1).controlc(lbBlack, 0, 3)
fila = 1
for pz in "kqrbnp":
lbPZw, cbPZw, lbPZ, lbPZb, cbPZb, tipoW, tipoB = self.dicWidgets[pz]
ly.control(cbPZw, fila, 0)
ly.controlc(lbPZw, fila, 1)
ly.controlc(lbPZ, fila, 2)
ly.controlc(lbPZb, fila, 3)
ly.control(cbPZb, fila, 4)
fila += 1
ly.filaVacia(fila, 20)
fila += 1
ly.controld(btAllW, fila, 0, 1, 2)
ly.control(self.cbAll, fila, 2)
ly.control(btAllB, fila, 3, 1, 2)
ly.controlc(btSwap, fila + 1, 0, 1, 5)
ly.margen(20)
layout = Colocacion.V().control(tb).otro(ly)
self.setLayout(layout)
self.reset()
def lanza(self, siFavoritos=True):
self.comprueba()
liFavoritos = None
if siFavoritos:
liFav = self.procesador.configuracion.liFavoritos
if liFav:
li = []
for elem in liFav:
if elem in self.dicMenu:
li.append(self.dicMenu[elem])
liFavoritos = li
if liFavoritos:
menu = self.menuFavoritos(liFavoritos)
else:
menu = self.menu
resp = menu.lanza()
if resp:
siStr = type(resp) == type("")
if siStr:
if resp == "menu_global":
self.lanza(False)
elif resp == "gm":
self.entrenaGM()
elif resp.startswith("mate"):
self.jugarMate(int(resp[-1]))
elif resp == "bmt":
self.bmt()
elif resp == "polyglot":
self.entrenaBooks()
elif resp.startswith("boxing"):
self.boxing(resp[6:])
elif resp in ["j60_rival", "j60_jugador"]:
self.jugar60(resp == "j60_jugador")
elif resp == "aperturas":
self.aperturas()
elif resp == "dailytest":
self.dailyTest()
elif resp == "potencia":
self.potencia()
elif resp == "visualiza":
self.visualiza()
elif resp.startswith("tactica|"):
nada, tipo, nombre, carpeta, ini = resp.split("|")
self.tacticas(tipo, nombre, carpeta, ini)
elif resp.startswith("remtactica|"):
nada, carpeta, nombre = resp.split("|")
self.tacticaRemove(carpeta, nombre)
elif resp.startswith("puente_"):
self.puente(int(resp[7:]))
elif resp.startswith("horses_"):
test = int(resp[7])
icl, icn, tit = self.horsesDef[test]
icon = VarGen.todasPiezas.icono(icl, icn)
self.horses(test, tit, icon)
elif resp.startswith("ep_"):
um = self.procesador.unMomento()
entreno = resp[3:].replace("\\", "/")
if "/" in entreno:
dicTraining = TrListas.dicTraining()
titentreno = ""
for x in entreno[:-4].split("/")[1:]:
titentreno += dicTraining.get(x, x) + "/"
titentreno = titentreno[:-1]
f = PGNreader.openCodec(entreno)
todo = f.read().strip()
f.close()
liEntrenamientos = todo.split("\n")
nPosiciones = len(liEntrenamientos)
um.final()
if nPosiciones == 0:
return
elif nPosiciones == 1:
pos = 1
jump = False
else:
db = Util.DicSQL(self.configuracion.ficheroTrainings)
posUltimo = db[entreno]
if posUltimo is None:
posUltimo = 1
resp = DatosNueva.numPosicion(self.procesador.pantalla,
titentreno, nPosiciones, posUltimo)
if resp is None:
return
pos, tipo, jump = resp
db.close()
if tipo.startswith( "r" ):
if tipo == "rk":
random.seed(pos)
random.shuffle(liEntrenamientos)
self.procesador.entrenaPos(pos, nPosiciones, titentreno, liEntrenamientos, entreno, jump)
elif resp == "learnPGN":
self.learnPGN()
elif resp == "lucaselo":
self.procesador.lucaselo(False)
elif resp == "micelo":
self.procesador.micelo(False)
elif resp.startswith("fics"):
self.procesador.ficselo(False, int(resp[4:]))
elif resp.startswith("fide"):
self.procesador.fideelo(False, int(resp[4:]))
elif resp.startswith("map_"):
nada, mapa = resp.split("_")
self.procesador.trainingMap(mapa)
else:
if resp <= -100:
self.menu = None # ya que puede cambiar y la etiqueta es diferente
mem = Memoria.Memoria(self.procesador)
mem.lanza(abs(resp) - 100)
def __init__(self, wParent):
QtGui.QWidget.__init__(self, wParent)
self.wParent = wParent
self.jg = None
self.partida = None
puntos = VarGen.configuracion.puntosPGN
f = Controles.TipoLetra(puntos=puntos, peso=75)
# ftxt = Controles.TipoLetra( nombre="Courier New", puntos=puntos )
f9 = Controles.TipoLetra(puntos=puntos)
ftxt = f9
# Apertura
self.lbApertura = Controles.LB(self, "").ponFuente(f).alinCentrado().ponColorFondoN("#eeeeee", "#474d59").ponWrap()
self.lbApertura.hide()
# Valoracion
liOpciones = [("-", "-")]
dicNAGs = TrListas.dicNAGs()
carpNAGs = "./IntFiles/NAGs"
for x in dicNAGs:
if x:
fsvg = "%s/$%d.svg" % (carpNAGs, x)
if os.path.isfile(fsvg):
liOpciones.append(("$%d : %s" % ( x, dicNAGs[x]), str(x), QTVarios.fsvg2ico(fsvg, 16)))
else:
liOpciones.append(("$%d : %s" % ( x, dicNAGs[x]), str(x)))
self.maxNAGs = 10
self.liNAGs = []
for x in range(self.maxNAGs):
cb = Controles.CB(self, liOpciones, "").ponAnchoMinimo().capturaCambiado(self.valoracionCambiada).ponFuente(
f9)
if x:
cb.hide()
self.liNAGs.append(cb)
liOpciones = [(x, x) for x in ("-", "!", "!!", "?", "??", "!?", "?!" )]
self.valoracionDirecta = Controles.CB(self, liOpciones, "-").ponAnchoFijo(42).capturaCambiado(self.valoracionDirectaCambiada)
lyH = Colocacion.H().control(self.valoracionDirecta).control(self.liNAGs[0])
ly = Colocacion.V().otro(lyH)
for x in range(1, self.maxNAGs):
ly.control(self.liNAGs[x])
self.gbValoracion = Controles.GB(self, _("Rating"), ly).ponFuente(f)
# Comentarios
self.comentario = Controles.EM(self, siHTML=False).capturaCambios(self.comentarioCambiado).ponFuente(
ftxt).anchoMinimo(200)
ly = Colocacion.H().control(self.comentario)
self.gbComentario = Controles.GB(self, _("Comments"), ly).ponFuente(f)
# Variantes
liAcciones = (
( _("Append"), Iconos.Mas(), "tbMasVariante" ), None,
( "%s+%s" % (_("Append"), _("Engine")), Iconos.MasR(), "tbMasVarianteR" ), None,
( _("Edit"), Iconos.ComentarioEditar(), "tbEditarVariante" ), None,
( _("Remove"), Iconos.Borrar(), "tbBorrarVariante" ), None,
)
tbVariantes = Controles.TB(self, liAcciones, siTexto=False, tamIcon=16)
self.variantes = Controles.EM(self, siHTML=False).capturaCambios(self.variantesCambiado).ponFuente(ftxt)
self.variantes.capturaDobleClick(self.variantesDobleClick)
ly = Colocacion.V().control(tbVariantes).control(self.variantes)
self.gbVariantes = Controles.GB(self, _("Variants"), ly).ponFuente(f)
layout = Colocacion.V()
layout.control(self.lbApertura)
layout.control(self.gbValoracion)
layout.control(self.gbComentario)
layout.control(self.gbVariantes)
layout.margen(5)
self.setLayout(layout)
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()
# 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())
menu.separador()
# DailyTest ------------------------------------------------------------------------------------------------
xopcion(menu, "dailytest", _("Your daily test"), Iconos.DailyTest())
menu.separador()
# Resistencia ------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Resistance Test"), Iconos.Resistencia())
nico = Util.Rondo(Iconos.Verde(), Iconos.Azul(), Iconos.Amarillo(), Iconos.Naranja())
xopcion(menu1, "boxing", _("Normal"), nico.otro())
xopcion(menu1, "boxingc", _("Blindfold chess"), nico.otro())
xopcion(menu1, "boxingp1", _("Hide only our pieces"), nico.otro())
xopcion(menu1, "boxingp2", _("Hide only opponent pieces"), nico.otro())
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()
# Maps ----------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Training on a map"), Iconos.Maps())
xopcion(menu1, "map_Africa", _("Africa map"), Iconos.Africa())
menu1.separador()
xopcion(menu1, "map_WorldMap", _("World map"), Iconos.WorldMap())
# 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()
xopcion(menu1, "learnPGN", _("Learn a game"), Iconos.PGN())
menu1.separador()
xopcion(menu1, "visualiza", _("The board at a glance"), Iconos.Gafas())
# 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())
return menu, dicMenu
