def cambios(self):
if hasattr(self, "form"):
li = self.form.get()
n = 1 if self.siNombre else 0
for flecha in self.liEjemplos:
regFlecha = flecha.bloqueDatos
if self.siNombre:
regFlecha.nombre = li[0]
regFlecha.forma = li[n]
regFlecha.tipo = li[n + 1]
regFlecha.color = li[n + 2]
regFlecha.colorinterior = li[n + 3]
# regFlecha.colorinterior2 = li[4]
regFlecha.opacidad = (100.0 - float(li[n + 4])) / 100.0
regFlecha.redondeos = li[n + 5]
regFlecha.grosor = li[n + 6]
regFlecha.altocabeza = li[n + 7]
regFlecha.ancho = li[n + 8]
regFlecha.vuelo = li[n + 9]
regFlecha.descuelgue = li[n + 10]
regFlecha.destino = li[n + 11]
regFlecha.posicion.orden = li[n + 12]
flecha.posicion2xy() # posible cambio en destino
flecha.setOpacity(regFlecha.opacidad)
flecha.setZValue(regFlecha.posicion.orden)
self.tablero.escena.update()
QTUtil.refreshGUI()
def micRecord(self):
self.ponToolBar(( self.ks_cancelmic, None, self.ks_stopmic ))
self.siGrabando = True
self.siCancelado = False
self.mesa.ponCentesimas(0)
self.taller.micInicio()
iniTime = time.clock()
while self.siGrabando:
self.taller.micGraba()
QTUtil.refreshGUI()
t = time.clock() - iniTime
self.mesa.ponCentesimas(t * 100)
if t > self.maxTime:
break
self.siGrabando = False
self.taller.micFinal()
if self.siCancelado:
self.taller.limpiar()
self.mesa.ponCentesimas(0)
else:
self.mesa.ponCentesimas(self.taller.centesimas)
self.ponBaseTB()
def ponContinuar(self):
self.btCancelarSeguir.ponTexto(_("Continue"))
self.btCancelarSeguir.conectar(self.continuar)
self.btCancelarSeguir.ponFuente(self.fontB)
self.btCancelarSeguir.ponIcono(Iconos.Aceptar())
self.btCancelarSeguir.setDisabled(False)
QTUtil.refreshGUI()
def ponLayout(self, siBlancasAbajo):
layout = self.layout()
if layout:
while True:
item = layout.takeAt(0)
if item:
del item
else:
break
else:
layout = Colocacion.V().margen(0)
self.setLayout(layout)
dlayout = {}
for color in (True, False):
ly = dlayout[color] = Colocacion.V().margen(0)
for pieza, numero in self.li:
if color == False:
pieza = pieza.lower()
for i in range(numero):
ly.control(self.dic[pieza][i])
ly0, ly1 = dlayout[siBlancasAbajo], dlayout[not siBlancasAbajo]
layout.otro(ly0).relleno().otro(ly1)
QTUtil.refreshGUI()
def siguiente(self):
resp = self.sts.siguientePosicion(self.work)
if resp:
self.ngroup, self.nfen, self.elem = resp
if not self.hideBoard:
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.elem.fen)
self.tablero.ponPosicion(cp)
self.xengine.ponGuiDispatch(self.dispatch)
xpt, xa1h8 = self.elem.bestA1H8()
self.tablero.quitaFlechas()
self.tablero.creaFlechaTmp(xa1h8[:2], xa1h8[2:], False)
if not self.playing:
return
t0 = time.time()
mrm = self.xengine.analiza(self.elem.fen)
t1 = time.time()-t0
if mrm:
rm = mrm.mejorMov()
if rm:
mov = rm.movimiento()
if mov:
if not self.hideBoard:
self.tablero.creaFlechaTmp(rm.desde, rm.hasta, True)
self.sts.setResult(self.work, self.ngroup, self.nfen, mov, t1)
self.grid.refresh()
else:
self.tb.setAccionVisible(self.pause, False)
self.tb.setAccionVisible(self.run, False)
self.playing = False
QTUtil.refreshGUI()
def dispatchR(valor):
if reg.form is None:
if isinstance(valor, FormLayout.FormTabWidget):
reg.form = valor
reg.wtime = valor.getWidget(0, 1)
reg.wdepth = valor.getWidget(0, 2)
reg.wdt = valor.getWidget(0, 3)
elif isinstance(valor, FormLayout.FormWidget):
reg.form = valor
reg.wtime = valor.getWidget(1)
reg.wdepth = valor.getWidget(2)
reg.wdt = valor.getWidget(3)
else:
sender = reg.form.sender()
if not reg.wdt.isChecked():
if sender == reg.wtime:
if reg.wtime.textoFloat() > 0:
reg.wdepth.setCurrentIndex(0)
elif sender == reg.wdepth:
if reg.wdepth.currentIndex() > 0:
reg.wtime.ponFloat(0.0)
elif sender == reg.wdt:
if reg.wtime.textoFloat() > 0:
reg.wdepth.setCurrentIndex(0)
elif reg.wdepth.currentIndex() > 0:
reg.wtime.ponFloat(0.0)
QTUtil.refreshGUI()
def preparaColoresPGN(self):
self.colorMateNegativo = QTUtil.qtColorRGB(0, 0, 0)
self.colorMatePositivo = QTUtil.qtColorRGB(159, 0, 159)
self.colorNegativo = QTUtil.qtColorRGB(255, 0, 0)
self.colorPositivo = QTUtil.qtColorRGB(0, 0, 255)
self.colorBlanco = QTUtil.qtColorRGB(255, 255, 255)
def mover(self):
if self.siMover:
self.guardarVideo()
self.siMover = not self.siMover
self.setWindowFlags(self.flags[self.siMover])
self.show()
QTUtil.refreshGUI()
def actualiza(self, leidos, erroneos, duplicados, importados):
def pts(x): return "{:,}".format(x).replace(",", ".")
self.lbLeidos.ponTexto(pts(leidos))
self.lbErroneos.ponTexto(pts(erroneos))
self.lbDuplicados.ponTexto(pts(duplicados))
self.lbImportados.ponTexto(pts(importados))
QTUtil.refreshGUI()
return not self.siCancelado
def elegir(self):
f = self.grid.recno()
mt = self.liMotoresActivos[f]
if mt.siJugable:
self.resultado = mt
self.guardarVideo()
self.accept()
else:
QTUtil.beep()
def cambiadoRM(self, fila):
self.um.ponPosRMactual(fila)
self.lbPuntuacion.ponTexto(self.um.puntuacionActual())
self.lbPGN.ponTexto(self.um.pgnActual())
self.ponTablero()
self.owner.adjustSize()
QTUtil.refreshGUI()
def playBeep(self):
if self.replayBeep is None:
db = Util.DicBLOB(VarGen.configuracion.ficheroSounds, "general")
keys = db.keys()
self.replayBeep = "MC" in keys
if self.replayBeep:
self.playClave("MC", False)
else:
QTUtil.beep()
def __init__(self, gestor, xmotor, nombreOP, posicion, mrm, rmOP, rmUsu, analisis):
self.siCompetitivo = gestor.siCompetitivo
self.nombreOP = nombreOP
self.posicion = posicion
self.rmOP = rmOP
self.rmUsu = rmUsu
self.mrm = mrm
self.analisis = analisis
self.xmotor = xmotor
self.gestor = gestor
self.listaRM, self.posOP = self.hazListaRM()
self.posicion = posicion
titulo = _("Analysis")
icono = Iconos.Analizar()
extparam = "jzgm"
QTVarios.WDialogo.__init__(self, gestor.pantalla, titulo, icono, extparam)
self.colorNegativo = QTUtil.qtColorRGB(255, 0, 0)
self.colorImpares = QTUtil.qtColorRGB(231, 244, 254)
self.lbComentario = Controles.LB(self, "").ponTipoLetra(puntos=10).alinCentrado()
confTablero = VarGen.configuracion.confTablero("JUICIO", 32)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponerPiezasAbajo(posicion.siBlancas)
self.lbMotor = Controles.LB(self).alinCentrado()
self.lbTiempo = Controles.LB(self).alinCentrado()
liMas = ( (_("Close"), "close", Iconos.Delete() ), )
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self, "", siLibre=True, tamIcon=24, siMas=True, liMasAcciones=liMas)
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("POSREAL", "#", 40, siCentrado=True)
oColumnas.nueva("JUGADAS", "%d %s" % (len(self.listaRM), _("Moves")), 120, siCentrado=True)
oColumnas.nueva("PLAYER", _("Player"), 120)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True)
lyT = Colocacion.V().control(self.tablero).otro(lyBM).control(self.lbComentario)
# Layout
layout = Colocacion.H().otro(lyT).control(self.grid)
self.setLayout(layout)
self.grid.setFocus()
self.grid.goto(self.posOP, 0)
self.siMoviendoTiempo = False
self.ponPuntos()
def recuperarVideo(self, siTam=True, anchoDefecto=None, altoDefecto=None):
dic = self.recuperarDicVideo()
wE, hE = QTUtil.tamEscritorio()
if dic:
wE, hE = QTUtil.tamEscritorio()
x, y = dic["_POSICION_"].split(",")
x = int(x)
y = int(y)
if not ( 0 <= x <= (wE - 50) ):
x = 0
if not ( 0 <= y <= (hE - 50) ):
y = 0
self.move(x, y)
if siTam:
if "_SIZE_" not in dic:
w, h = self.width(),self.height()
for k in dic:
if k.startswith( "_TAMA" ):
w, h = dic[k].split(",")
else:
w, h = dic["_SIZE_"].split(",")
w = int(w)
h = int(h)
if w > wE:
w = wE
elif w < 20:
w = 20
if h > (hE - 40):
h = hE - 40
elif h < 20:
h = 20
self.resize(w, h)
for grid in self.liGrids:
grid.recuperarVideo(dic)
grid.ponAnchosColumnas()
for sp, name in self.liSplitters:
k = "SP_%s" % name
if k in dic:
sp.setSizes(dic[k])
return True
else:
if anchoDefecto or altoDefecto:
if anchoDefecto is None:
anchoDefecto = self.width()
if altoDefecto is None:
altoDefecto = self.height()
if anchoDefecto > wE:
anchoDefecto = wE
if altoDefecto > (hE - 40):
altoDefecto = hE - 40
self.resize(anchoDefecto, altoDefecto)
return False
def gridPonValor(self, grid, fila, columna, valor):
campo = columna.clave
valor = valor.strip()
usuario = self.liUsuarios[fila]
if campo == "USUARIO":
if valor:
usuario.nombre = valor
else:
QTUtil.beep()
else:
usuario.password = valor
def inicio(self, parent, mensaje, siCancelar=False, siMuestraYa=True, opacity=0.80,
posicion="c", fixedSize=256, titCancelar=None, background=None, pmImagen=None):
QTUtil.refreshGUI()
if self.me:
self.final()
if background is None:
background = "#79b600"
self.me = MensEspera(parent, mensaje, siCancelar, siMuestraYa, opacity, posicion, fixedSize, titCancelar,
background, pmImagen)
QTUtil.refreshGUI()
return self
def portapapelesUltJug(self):
if self.liData and self.siAnalizar():
una = self.liData[-1]
pgn = una["pgn"]
li = pgn.split(" ")
n = 2 if "..." in pgn else 1
resp = " ".join(li[0:n])
resp += self.comentario(una)
if len(li) > n:
resp += " ".join(li[n:])
QTUtil.ponPortapapeles(resp)
def guardar(self):
nrecs = self.dbf.reccount()
if nrecs == 0:
return
elif nrecs > 1:
menu = QTVarios.LCMenu(self)
menu.opcion("all", _("All games"), Iconos.PuntoNaranja())
menu.separador()
menu.opcion("selected", _("Selected games"), Iconos.PuntoAzul())
resp = menu.lanza()
if resp is None:
return
elif resp == "all":
liSelected = range(nrecs)
else:
liSelected = self.grid.recnosSeleccionados()
else:
liSelected = [0]
extension = "pgn"
resp = QTUtil2.salvaFichero(self, _("File to save"), self.gestor.configuracion.dirSalvados,
_("File") + " %s (*.%s)" % (extension, extension), False)
if resp:
antSelect = self.dbf.select
nueSelect = antSelect + ",PGN"
self.dbf.ponSelect(nueSelect)
self.dbf.leer()
self.dbf.gotop()
li = []
for i in liSelected:
self.dbf.goto(i)
dic = self.dbf.dicValores()
li.append(dic["PGN"])
dato = "\n\n".join(li)
try:
modo = "w"
if Util.existeFichero(resp):
modo = "a"
dato = "\n" * 2 + dato
f = codecs.open(resp, modo, 'utf-8', 'ignore')
f.write(dato.replace("\n", "\r\n"))
f.close()
QTUtil2.mensaje(self, _X(_("Saved to %1"), resp))
direc = os.path.dirname(resp)
if direc != self.gestor.configuracion.dirSalvados:
self.gestor.configuracion.dirSalvados = direc
self.gestor.configuracion.graba()
except:
QTUtil.ponPortapapeles(dato)
QTUtil2.mensError(self, "%s : %s\n\n%s" % (
_("Unable to save"), resp, _("It is saved in the clipboard to paste it wherever you want.") ))
self.dbf.ponSelect(antSelect)
def portapapelesUltJug(self):
if self.liData and self.siAnalizar():
una = self.liData[-1]
pgn = una["pgn"]
if "..." in pgn:
pgn = pgn.lstrip("0123456789. ")
li = pgn.split(" ")
resp = self.pgn1 + " " + li[0]
resp += self.comentario(una)
if len(li) > 1:
resp += " ".join(li[1:])
QTUtil.ponPortapapeles(resp)
def beginListen(self):
self.setEstado(self.ST_LISTENING)
self.siSeguimos = True
tallerSonido = Sonido.TallerSonido(None)
tallerSonido.leeWAV(self.ficheroWav)
tallerSonido.playInicio(0,tallerSonido.centesimas)
siSeguir = True
while self.siSeguimos and siSeguir:
siSeguir, pos = tallerSonido.play()
QTUtil.refreshGUI()
tallerSonido.playFinal()
self.endListen()
def portapapelesUltJug(self):
if self.liData and self.siAnalizar():
rm = self.liData[0]
p = Partida.Partida(fen=self.fen)
p.leerPV(rm.pv)
pgn = p.pgnSP()
li = pgn.split(" ")
n = 2 if "..." in pgn else 1
resp = " ".join(li[0:n])
resp += " {%s D%s} " % (rm.abrTexto(), rm.depth)
if len(li) > n:
resp += " ".join(li[n:])
QTUtil.ponPortapapeles(resp)
def paint(self, painter, option, widget):
bl = self.bloqueCaja
pen = QtGui.QPen()
pen.setColor(QTUtil.qtColor(bl.color))
pen.setWidth(bl.grosor)
pen.setStyle(bl.tipoqt())
painter.setPen(pen)
if bl.colorRelleno != -1:
painter.setBrush(QTUtil.qtBrush(bl.colorRelleno))
if bl.redEsquina:
painter.drawRoundedRect(self.rect, bl.redEsquina, bl.redEsquina)
else:
painter.drawRect(self.rect)
def muestra(self):
self.show()
v = self.owner
s = self.size()
if self.posicion == "c":
x = v.x() + (v.width() - s.width()) / 2
y = v.y() + (v.height() - s.height()) / 2
elif self.posicion == "ad":
x = v.x() + v.width() - s.width()
y = v.y() + 4
self.move(x, y)
QTUtil.refreshGUI()
return self
def cambios(self):
if hasattr(self, "form"):
li = self.form.get()
for n, svg in enumerate(self.liEjemplos):
regSVG = svg.bloqueDatos
regSVG.nombre = li[0]
regSVG.opacidad = (100.0 - float(li[1])) / 100.0
regSVG.psize = li[2]
regSVG.posicion.orden = li[3]
svg.setOpacity(regSVG.opacidad)
svg.setZValue(regSVG.posicion.orden)
svg.update()
self.tablero.escena.update()
QTUtil.refreshGUI()
def cambios(self):
if hasattr(self, "form"):
li = self.form.get()
for n, marker in enumerate(self.liEjemplos):
regMarker = marker.bloqueDatos
regMarker.nombre = li[0]
regMarker.opacidad = (100.0 - float(li[1])) / 100.0
regMarker.psize = li[2]
regMarker.poscelda = li[3]
regMarker.posicion.orden = li[4]
marker.setOpacity(regMarker.opacidad)
marker.setZValue(regMarker.posicion.orden)
marker.update()
self.tablero.escena.update()
QTUtil.refreshGUI()
def paint(self, painter, option, widget):
pen = QtGui.QPen()
painter.setBrush(QtGui.QBrush(QtGui.QColor(self.bloqueDatos.colorFondo)))
painter.drawRect(self.rect)
nColor = self.bloqueDatos.colorTexto if self.bloqueDatos.colorTexto != -1 else 0
if self.bloqueDatos.colorFondo != -1:
painter.setBrush(QtGui.QBrush())
pen.setColor(QTUtil.qtColor(nColor))
painter.setPen(pen)
painter.setFont(self.font)
painter.drawText(self.rect, self.texto(), self.textOption)
linea = self.bloqueDatos.linea
if linea:
r = self.rect
x, y, w, h = r.x(), r.y(), r.width(), r.height()
if linea == "a":
y = y + h
w = 1
h = 50
elif linea == "d":
x = x + w
y = y - 10
w = 1
h = 32
elif linea == "i":
y = y - 10
w = 1
h = 32
rect = QtCore.QRectF(x, y, w, h)
painter.drawRect(rect)
def recuperarVideo(self, dicVideo):
if dicVideo:
wE, hE = QTUtil.tamEscritorio()
x, y = dicVideo["_POSICION_"].split(",")
x = int(x)
y = int(y)
if not ( 0 <= x <= (wE - 50) ):
x = 0
if not ( 0 <= y <= (hE - 50) ):
y = 0
self.move(x, y)
if "_SIZE_" not in dicVideo:
w, h = self.width(),self.height()
for k in dicVideo:
if k.startswith( "_TAMA" ):
w, h = dicVideo[k].split(",")
else:
w, h = dicVideo["_SIZE_"].split(",")
w = int(w)
h = int(h)
if w > wE:
w = wE
elif w < 20:
w = 20
if h > hE:
h = hE
elif h < 20:
h = 20
self.resize(w, h)
def ponToolBar(self, liAcciones, separator=False):
# liAcciones = list(liAcciones) # Martin debug
# liAcciones.append( 999 )
self.tb.clear()
for k in liAcciones:
self.dicTB[k].setVisible(True)
self.dicTB[k].setEnabled(True)
self.tb.addAction(self.dicTB[k])
if separator:
self.tb.addSeparator()
self.tb.liAcciones = liAcciones
self.tb.update()
QTUtil.refreshGUI()
def movimientosPiezas(self, liMovs):
"""
Hace los movimientos de piezas en el tablero
"""
for movim in liMovs:
if movim[0] == "b":
self.w.tablero.borraPieza(movim[1])
elif movim[0] == "m":
self.w.tablero.muevePieza(movim[1], movim[2])
elif movim[0] == "c":
self.w.tablero.cambiaPieza(movim[1], movim[2])
self.w.tablero.desactivaTodas()
self.w.tablero.escena.update()
self.w.update()
QTUtil.xrefreshGUI()
def pulsado(self):
ncolor = self.rut_actual()
color = QTUtil.qtColor(ncolor)
color = QtGui.QColorDialog.getColor(color, self.parent, _("Choose a color"))
if color.isValid():
self.rut_actual(color.rgba())
self.rut_actualiza()
self.ponColor()
def muestra_resultado(self):
self.state = ST_ENDGAME
self.disable_all()
self.human_is_playing = False
mensaje, beep, player_win = self.game.label_resultado_player(self.human_side)
self.beepResultado(beep)
QTUtil.refresh_gui()
QTUtil2.message(self.main_window, mensaje)
li_options = [TB_CLOSE, TB_CONFIG, TB_UTILITIES]
if player_win:
li_options.insert(1, TB_REINIT)
self.main_window.pon_toolbar(li_options)
self.remove_hints()
self.game.set_tag("HintsUsed", self.engine.hints_current)
self.autosave()
if player_win:
self.saveGame(True)
else:
self.cancelGame()
def play(self):
self.mesa.activaEdicion(False)
self.ponToolBar(( self.ks_stopplay, ))
centDesde, centHasta = self.mesa.limites(False)
self.taller.playInicio(centDesde, centHasta)
self.siPlay = True
while self.siPlay:
siSeguir, centActual = self.taller.play()
if siSeguir:
self.mesa.ponCentesimasActual(centActual)
QTUtil.refreshGUI()
else:
self.mesa.ponCentesimasActual(centDesde)
QTUtil.refreshGUI()
break
self.siPlay = False
self.taller.playFinal()
self.ponBaseTB()
def start(
self,
parent,
mensaje,
siCancelar=False,
siMuestraYa=True,
opacity=0.90,
physical_pos="c",
fixedSize=None,
titCancelar=None,
background=None,
pmImagen=None,
puntos=11,
conImagen=True,
):
QTUtil.refresh_gui()
if self.me:
self.final()
if background is None:
background = "#D3E3EC"
self.me = MensEspera(
parent,
mensaje,
siCancelar,
siMuestraYa,
opacity,
physical_pos,
fixedSize,
titCancelar,
background,
pmImagen,
puntos,
conImagen,
)
QTUtil.refresh_gui()
return self
def __init__(self, procesador):
super(WAbout, self).__init__(procesador.pantalla)
self.setWindowTitle(_("About"))
self.setWindowIcon(Iconos.Aplicacion())
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
self.setMaximumWidth(QTUtil.anchoEscritorio())
f = Controles.TipoLetra(puntos=10) # 0, peso=75 )
cabecera = '<span style="font-size:30pt; font-weight="700"; font-family:arial; color:#2D2B2B">%s</span><br>' % _(
"Lucas Chess")
cabecera += '<span style="font-size:15pt;">%s</span><br>' % _X(
_("version %1"), procesador.version)
cabecera += '<span style="font-size:10pt;color:2D2B2B">%s: %s</span>' % (
_("Author"),
'<a href="mailto:[email protected]">Lucas Monge</a>')
cabecera += ' - <a style="font-size:10pt; color:2D2B2B" href="%s">%s</a>' % (
procesador.web, procesador.web)
cabecera += ' - <a style="font-size:10pt; color:2D2B2B" href="%s">Blog : Fresh news</a><br>' % (
procesador.blog, )
cabecera += '%s <a style="font-size:10pt; color:2D2B2B" href="http://www.gnu.org/copyleft/gpl.html"> GPL</a>' % _(
"License")
lbIco = Controles.LB(self).ponImagen(Iconos.pmAplicacion64())
lbTitulo = Controles.LB(self, cabecera)
btSeguir = Controles.PB(self, _("Continue"),
self.accept).ponPlano(False)
# Tabs
tab = Controles.Tab()
tab.ponFuente(f)
ib = InfoBase.ThanksTo()
for n, (k, titulo) in enumerate(ib.dic.iteritems()):
txt = ib.texto(k)
lb = Controles.LB(self, txt)
lb.ponFondoN("#F6F3EE")
lb.ponFuente(f)
tab.addTab(lb, titulo)
lyV1 = Colocacion.H().control(lbIco).espacio(15).control(
lbTitulo).relleno()
layout = Colocacion.V().otro(lyV1).espacio(10).control(tab).control(
btSeguir).margen(10)
self.setLayout(layout)
def __init__(self, owner, themes: Themes.Themes, current_move: Move.Move):
title = _("Select themes")
extparam = "selelectthemes"
self.owner = owner
self.current_move = current_move
self.st_current_themes = set(self.current_move.li_themes)
icono = Iconos.Themes()
QTVarios.WDialogo.__init__(self, owner, title, icono, extparam)
self.themes = themes
self.themes.check(self.st_current_themes)
self.qt_custom = QTUtil.qtColor("#bf5b16")
self.configuration = Code.configuration
li_options = [
(_("Save"), Iconos.GrabarFichero(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.reject),
None,
(_("Clear all"), Iconos.Borrar(), self.clear_themes),
None,
]
tb = QTVarios.LCTB(self, li_options, icon_size=24)
# Grid
o_columns = Columnas.ListaColumnas()
o_columns.nueva("SELECTED", "", 20, siChecked=True)
o_columns.nueva("THEME", "", 280)
self.o_columnas = o_columns
self.grid = Grid.Grid(self, o_columns, siEditable=True, altoCabecera=3)
font = Controles.TipoLetra(puntos=Code.configuration.x_pgn_fontpoints)
self.grid.ponFuente(font)
lb_right_click = Controles.LB(
self, " * %s" % _("More options with right-click"))
layout = Colocacion.V().control(tb).control(
self.grid).control(lb_right_click).margen(3)
self.setLayout(layout)
self.restore_video(anchoDefecto=self.grid.anchoColumnas() + 48)
def __init__(self, escena, bloqueTexto, rutina=None):
BloqueSC.__init__(self, escena, bloqueTexto.position)
self.bloqueDatos = self.bloqueTexto = bloqueTexto
self.font = Controles.TipoLetra(txt=str(bloqueTexto.tipoLetra))
self.textOption = QtGui.QTextOption(QTUtil.qtAlineacion("c"))
self.rutina = rutina
self.minimo = bloqueTexto.min
self.maximo = bloqueTexto.max
self.inicialx = bloqueTexto.position.x
self.rutina = bloqueTexto.rutina
self.siFinal = self.maximo == self.inicialx
self.centesimas = 0
def paste(self):
texto = QTUtil.traePortapapeles()
if texto:
pgn = PGN.UnPGN()
try:
pgn.leeTexto(str(texto))
except:
pgn.siError = True
if pgn.siError:
QTUtil2.mensError(
self.pantalla,
_("The text from the clipboard does not contain a chess game in PGN format"
))
self.finPartida()
return
self.pgnPaste = texto
self.mostrar(pgn, False)
def recuperarVideo(self):
if Util.tamFichero(self.ficheroVideo) > 0:
dic = Util.recuperaDIC(self.ficheroVideo)
if dic:
wE, hE = QTUtil.tamEscritorio()
x, y = dic["_POSICION_"].split(",")
x = int(x)
y = int(y)
if not (0 <= x <= (wE - 50)):
x = 0
if not (0 <= y <= (hE - 50)):
y = 0
self.move(x, y)
if "_SIZE_" not in dic:
w, h = self.width(), self.height()
for k in dic:
if k.startswith("_TAMA"):
w, h = dic[k].split(",")
else:
w, h = dic["_SIZE_"].split(",")
w = int(w)
h = int(h)
if w > wE:
w = wE
elif w < 20:
w = 20
if h > hE:
h = hE
elif h < 20:
h = 20
self.resize(w, h)
self.siShowTablero = dic.get("SHOW_TABLERO", self.siShowTablero)
self.nArrows = dic.get("NARROWS", self.nArrows)
self.siTop = dic.get("SITOP", self.siTop)
if not self.siShowTablero:
if self.siWidgets:
self.tablero.hide()
def paint(self, painter, option, widget):
pen = QtGui.QPen()
if self.bloqueTexto.colorFondo != -1:
painter.setBrush(QtGui.QBrush(QtGui.QColor(self.bloqueTexto.colorFondo)))
nColor = self.bloqueTexto.colorTexto if self.bloqueTexto.colorTexto != -1 else 0
if self.bloqueTexto.colorFondo != -1:
painter.setBrush(QtGui.QBrush())
pen.setColor(QTUtil.qtColor(nColor))
painter.setPen(pen)
painter.setFont(self.font)
painter.drawText(self.rect, self.bloqueTexto.valor, self.textOption)
if self.siRecuadro:
pen = QtGui.QPen()
pen.setColor(QtGui.QColor("blue"))
pen.setWidth(1)
pen.setStyle(QtCore.Qt.DashLine)
painter.setPen(pen)
painter.drawRect(self.rect)
def seguir(self):
self.set_position()
self.lb_result.set_text("")
for wm in self.liwm_captures:
wm.limpia()
for wm in self.liwm_threats:
wm.limpia()
self.tb.setEnabled(False)
# Mostramos los movimientos según depth
depth = self.capture.current_depth
if depth:
txt_ant = ""
for x in range(depth):
if not self.configuration.x_captures_showall:
if x != depth - 1:
continue
move = self.capture.game.move(self.capture.current_posmove + x)
txt = move.pgn_translated()
if txt == txt_ant:
self.board.pon_texto("", 1)
QTUtil.refresh_gui()
time.sleep(0.3)
txt_ant = txt
self.board.pon_texto(txt, 0.9)
QTUtil.refresh_gui()
dif = depth - x
factor = 1.0 - dif * 0.1
if factor < 0.7:
factor = 0.7
time.sleep(2.6 * factor * factor)
self.board.pon_texto("", 1)
QTUtil.refresh_gui()
# Ponemos el toolbar
self.show_tb(self.check, self.terminar)
# Activamos capturas
self.gb_captures.setEnabled(True)
self.gb_threats.setEnabled(True)
# Marcamos el tiempo
self.time_base = time.time()
self.liwm_captures[0].activa()
def scanner(self):
pos = QTUtil.escondeWindow(self.wparent)
seguir = True
if self.chb_scanner_ask.valor() and not QTUtil2.pregunta(
None,
_("Bring the window to scan to front"),
label_yes=_("Accept"),
label_no=_("Cancel"),
si_top=True):
seguir = False
if seguir:
fich_png = self.configuration.ficheroTemporal("png")
if not self.is_scan_init:
self.scanner_init()
self.is_scan_init = True
sc = Scanner.Scanner(self.configuration.carpetaScanners, fich_png)
sc.exec_()
self.vars_scanner.read()
self.vars_scanner.tolerance = self.sb_scanner_tolerance.valor(
) # releemos la variable
self.vars_scanner.tolerance_learns = min(
self.sb_scanner_tolerance_learns.valor(),
self.vars_scanner.tolerance)
if os.path.isfile(fich_png) and Util.filesize(fich_png):
self.scanner_read_png(fich_png)
self.pixmap = QtGui.QPixmap(fich_png)
tc = self.board.width_square * 8
pm = self.pixmap.scaled(tc, tc)
self.lb_scanner.ponImagen(pm)
self.lb_scanner.show()
self.gb_scanner.show()
self.scanner_deduce()
self.wparent.move(pos)
self.setFocus()
def scanner(self):
pos = QTUtil.escondeWindow(self.wparent)
seguir = True
if self.chb_scanner_ask.valor() and not QTUtil2.pregunta(
None,
_("Bring the window to scan to front"),
etiSi=_("Accept"),
etiNo=_("Cancel"),
si_top=True):
seguir = False
if seguir:
fich_png = self.configuracion.ficheroTemporal("png")
if not self.is_scan_init:
self.scanner_init()
self.is_scan_init = True
sc = Scanner.Scanner(self.configuracion.carpetaScanners, fich_png)
sc.exec_()
self.vars_scanner.read()
self.vars_scanner.tolerance = self.sb_scanner_tolerance.valor(
) # releemos la variable
if os.path.isfile(fich_png):
if Util.tamFichero(fich_png):
self.scanner_read_png(fich_png)
self.pixmap = QtGui.QPixmap(fich_png)
tc = self.tablero.anchoCasilla * 8
pm = self.pixmap.scaled(tc, tc)
self.lb_scanner.ponImagen(pm)
self.lb_scanner.show()
self.gb_scanner.show()
self.scanner_deduce()
self.wparent.move(pos)
self.setFocus()
def voyager_position(wowner, position, si_esconde: bool = True, wownerowner=None):
pos_ownerowner = None
pos = None
if si_esconde:
pos = QTUtil.escondeWindow(wowner)
if wownerowner:
pos_ownerowner = QTUtil.escondeWindow(wownerowner)
game = Game.Game(ini_posicion=position)
dlg = Voyager(wowner, False, game)
resp = dlg.resultado if dlg.exec_() else None
if si_esconde:
if wownerowner:
wownerowner.show()
wownerowner.move(pos_ownerowner)
QTUtil.refresh_gui()
time.sleep(0.01)
wowner.show()
wowner.move(pos)
QTUtil.refresh_gui()
time.sleep(0.01)
return resp
def ponColor(self):
ncolor = self.rut_actual()
self.setStyleSheet("QWidget { background: %s }" % QTUtil.qtColor(ncolor).name())
def dameCategoria(wParent, configuracion, procesador):
rival = configuracion.rival
menu = QTVarios.LCMenu(wParent)
menu.opcion(
None,
"%s: %d %s" % (_("Total score"), configuracion.puntuacion(), _("pts")),
Iconos.NuevaPartida())
menu.separador()
menu.opcion(None,
"%s: %s" % (_("Opponent"), rival.rotuloPuntos()),
Iconos.Motor(),
siDeshabilitado=False)
menu.separador()
# ---------- CATEGORIAS
ant = 1
for x in range(6):
cat = rival.categorias.numero(x)
txt = cat.nombre()
nm = cat.nivelHecho
nh = cat.hecho
if nm > 0:
txt += " %s %d" % (_("Level"), nm)
if nh:
if "B" in nh:
txt += " +%s:%d" % (_("White"), nm + 1)
if "N" in nh:
txt += " +%s:%d" % (_("Black"), nm + 1)
# if "B" not in nh:
# txt += " ... %s:%d"%( _( "White" )[0],nm+1)
# elif "N" not in nh:
# txt += " ... %s:%d"%( _( "Black" )[0],nm+1)
# else:
# txt += " ... %s:%d"%( _( "White" )[0],nm+1)
siDesHabilitado = (ant == 0)
ant = nm
menu.opcion(str(x), txt, cat.icono(), siDeshabilitado=siDesHabilitado)
# ----------- RIVAL
menu.separador()
menuRival = menu.submenu(_("Change opponent"))
puntuacion = configuracion.puntuacion()
icoNo = Iconos.Motor_No()
icoSi = Iconos.Motor_Si()
icoActual = Iconos.Motor_Actual()
grpNo = Iconos.Grupo_No()
grpSi = Iconos.Grupo_Si()
for grupo in configuracion.grupos.liGrupos:
nombre = _X(_("%1 group"), grupo.nombre)
if grupo.minPuntos > 0:
nombre += " (+%d %s)" % (grupo.minPuntos, _("pts"))
siDes = (grupo.minPuntos > puntuacion)
if siDes:
icoG = grpNo
icoM = icoNo
else:
icoG = grpSi
icoM = icoSi
submenu = menuRival.submenu(nombre, icoG)
for rv in grupo.liRivales:
siActual = rv.clave == rival.clave
ico = icoActual if siActual else icoM
submenu.opcion("MT_" + rv.clave, rv.rotuloPuntos(), ico, siDes
or siActual)
menuRival.separador()
# ----------- RIVAL
menu.separador()
menu.opcion("ayuda", _("Help"), Iconos.Ayuda())
cursor = QtGui.QCursor.pos()
resp = menu.lanza()
if resp is None:
return None
elif resp == "ayuda":
titulo = _("Competition")
ancho, alto = QTUtil.tamEscritorio()
ancho = min(ancho, 700)
txt = _(
"<br><b>The aim is to obtain the highest possible score</b> :<ul><li>The current point score is displayed in the title bar.</li><li>To obtain points it is necessary to win on different levels in different categories.</li><li>To overcome a level it is necessary to win against the engine with white and with black.</li><li>The categories are ranked in the order of the following table:</li><ul><li><b>Beginner</b> : 5</li><li><b>Amateur</b> : 10</li><li><b>Master candidate</b> : 20</li><li><b>Master</b> : 40</li><li><b>Grandmaster candidate</b> : 80</li><li><b>Grandmaster</b> : 160</li></ul><li>The score for each game is calculated by multiplying the playing level with the score of the category.</li><li>The engines are divided into groups.</li><li>To be able to play with an opponent of a particular group a minimum point score is required. The required score is shown next to the group label.</li></ul>"
)
Info.info(wParent, _("Lucas Chess"), titulo, txt, ancho,
Iconos.pmAyudaGR())
return None
elif resp.startswith("MT_"):
procesador.cambiaRival(resp[3:])
QtGui.QCursor.setPos(cursor)
procesador.competicion()
return None
else:
categoria = rival.categorias.numero(int(resp))
return categoria
def __init__(self, procesador, winBookGuide, dbGames):
QtGui.QWidget.__init__(self)
self.winBookGuide = winBookGuide
self.procesador = procesador
self.data = [[], [], [], []]
self.movesWhite = []
self.movesBlack = []
self.lastFilterMoves = {"white": "", "black": ""}
self.configuracion = procesador.configuracion
self.infoMove = None # <-- setInfoMove
self.ap = AperturasStd.ap
self.gridOpeningWhite = self.gridOpeningBlack = self.gridMovesWhite = self.gridMovesBlack = 0
# GridOpening
ancho = 54
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("opening", _("Opening"), 200)
oColumnas.nueva("games", _("Games"), ancho, siDerecha=True)
oColumnas.nueva("pgames", "% " + _("Games"), 70, siDerecha=True)
oColumnas.nueva("win", _("Win"), ancho, siDerecha=True)
oColumnas.nueva("draw", _("Draw"), ancho, siDerecha=True)
oColumnas.nueva("lost", _("Loss"), ancho, siDerecha=True)
oColumnas.nueva("pwin", "% " + _("Win"), ancho, siDerecha=True)
oColumnas.nueva("pdraw", "% " + _("Draw"), ancho, siDerecha=True)
oColumnas.nueva("plost", "% " + _("Loss"), ancho, siDerecha=True)
oColumnas.nueva("pdrawwin", "%% %s" % _("W+D"), ancho, siDerecha=True)
oColumnas.nueva("pdrawlost", "%% %s" % _("L+D"), ancho, siDerecha=True)
self.gridOpeningWhite = Grid.Grid(self, oColumnas, siSelecFilas=True)
self.gridOpeningBlack = Grid.Grid(self, oColumnas, siSelecFilas=True)
# GridWhite/GridBlack
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("games", _("Games"), ancho, siDerecha=True)
oColumnas.nueva("win", _("Win"), ancho, siDerecha=True)
oColumnas.nueva("draw", _("Draw"), ancho, siDerecha=True)
oColumnas.nueva("lost", _("Loss"), ancho, siDerecha=True)
oColumnas.nueva("pwin", "% " + _("Win"), ancho, siDerecha=True)
oColumnas.nueva("pdraw", "% " + _("Draw"), ancho, siDerecha=True)
oColumnas.nueva("plost", "% " + _("Loss"), ancho, siDerecha=True)
ancho_col = 40
siFigurinesPGN = self.configuracion.figurinesPGN
for x in range(1, 50):
num = (x - 1) * 2
oColumnas.nueva(str(num),
"%d." % x,
ancho_col,
siCentrado=True,
edicion=Delegados.EtiquetaPOS(siFigurinesPGN,
siLineas=False))
oColumnas.nueva(str(num + 1),
"...",
ancho_col,
siCentrado=True,
edicion=Delegados.EtiquetaPOS(siFigurinesPGN,
siLineas=False))
self.gridMovesWhite = Grid.Grid(self, oColumnas, siSelecFilas=True)
self.gridMovesBlack = Grid.Grid(self, oColumnas, siSelecFilas=True)
wWhite = QtGui.QWidget(self)
tbmovesw = ToolbarMoves("white", self.dispatchMoves)
ly = Colocacion.V().control(tbmovesw).control(
self.gridMovesWhite).margen(3)
wWhite.setLayout(ly)
wblack = QtGui.QWidget(self)
tbmovesb = ToolbarMoves("black", self.dispatchMoves)
ly = Colocacion.V().control(tbmovesb).control(
self.gridMovesBlack).margen(3)
wblack.setLayout(ly)
tabs = Controles.Tab(self)
tabs.nuevaTab(self.gridOpeningWhite, _("White openings"))
tabs.nuevaTab(self.gridOpeningBlack, _("Black openings"))
tabs.nuevaTab(wWhite, _("White moves"))
tabs.nuevaTab(wblack, _("Black moves"))
# ToolBar
liAccionesWork = [
(_("Close"), Iconos.MainMenu(), self.tw_terminar),
None,
("", Iconos.Usuarios(), self.tw_changeplayer),
None,
(_("Rebuild"), Iconos.Reindexar(), self.tw_rebuild),
None,
]
self.tbWork = Controles.TBrutina(self,
liAccionesWork,
tamIcon=24,
puntos=12)
self.tbWork.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
lyTB = Colocacion.H().control(self.tbWork)
layout = Colocacion.V().otro(lyTB).control(tabs).margen(1)
self.setLayout(layout)
self.qtColor = (QTUtil.qtColorRGB(221, 255, 221),
QTUtil.qtColorRGB(247, 247, 247),
QTUtil.qtColorRGB(255, 217, 217))
self.setdbGames(dbGames)
self.setPlayer(self.leeVariable("PLAYER", ""))
def __init__(self, owner, name, title, icono, folder, li_tam_blocks):
self.tol = TurnOnLights.read_tol(name, title, folder, li_tam_blocks)
self.reinit = False
titulo = _("Turn on the lights") + ": " + title
if self.tol.is_calculation_mode():
tipo = _("Calculation mode")
background = "#88AA3A"
else:
tipo = _("Memory mode")
background = "#BDDBE8"
extparam = "tol%s-%d" % (name, self.tol.work_level)
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.colorTheme = QTUtil.qtColor("#F0F0F0")
lb = Controles.LB(self, tipo)
lb.ponFondoN(background).alinCentrado().ponTipoLetra(puntos=14)
# Toolbar
tb = Controles.TBrutina(self)
tb.new(_("Close"), Iconos.MainMenu(), self.terminar)
anterior, siguiente = self.tol.prev_next()
if anterior:
tb.new(_("Previous"), Iconos.Anterior(), self.goto_previous)
if siguiente:
tb.new(_("Next"), Iconos.Siguiente(), self.goto_next)
tb.new(_("Config"), Iconos.Configurar(), self.config)
tb.new(_("Information"), Iconos.Informacion(), self.colors)
# Lista
oColumnas = Columnas.ListaColumnas()
work_level = self.tol.work_level + 1
oColumnas.nueva("THEME",
_("Level %d/%d") % (work_level, self.tol.num_levels),
175)
edicionIconos = Delegados.PmIconosColor()
self.dicIconos = {}
for k, pm in edicionIconos.dicpmIconos.iteritems():
self.dicIconos[k] = QtGui.QIcon(pm)
for x in range(self.tol.num_blocks):
oColumnas.nueva("BLOCK%d" % x,
"%d" % (x + 1, ),
42,
siCentrado=True,
edicion=edicionIconos)
self.grid = grid = Grid.Grid(self,
oColumnas,
altoFila=42,
background="white")
self.grid.setAlternatingRowColors(False)
self.grid.tipoLetra(puntos=10, peso=500)
nAnchoPgn = self.grid.anchoColumnas() + 20
self.grid.setMinimumWidth(nAnchoPgn)
self.registrarGrid(grid)
# Colocamos ---------------------------------------------------------------
ly = Colocacion.V().control(lb).control(tb).control(self.grid)
self.setLayout(ly)
alto = self.tol.num_themes * 42 + 146
self.recuperarVideo(siTam=True,
altoDefecto=alto,
anchoDefecto=nAnchoPgn)
def __init__(self, manager, tutor, siRival, siOpenings, is_white,
siPuntos):
titulo = _("Analyzing your move")
icono = Iconos.Tutor()
extparam = "tutor"
QTVarios.WDialogo.__init__(self, manager.main_window, titulo, icono,
extparam)
self.tutor = tutor
self.manager = manager
self.respLibro = None
self.siElegidaOpening = False
self.x_tutor_view = manager.configuration.x_tutor_view
# ~ self.setStyleSheet("QDialog,QGroupBox { background: #f0f0f0; }")
f = Controles.TipoLetra(puntos=12, peso=75)
flb = Controles.TipoLetra(puntos=10)
flba = Controles.TipoLetra(puntos=8)
ae = QTUtil.anchoEscritorio()
mx = 32 if ae > 1000 else 20
config_board = Code.configuration.config_board("TUTOR", mx)
# Boards
def create_board(name, si=True, siLibre=True, siMas=False):
if not si:
return None, None, None
board = Board.Board(self, config_board)
board.crea()
board.ponerPiezasAbajo(is_white)
lytb, tb = QTVarios.lyBotonesMovimiento(self,
name,
siLibre,
siMas=siMas)
return board, lytb, tb
self.boardTutor, lytbtutor, self.tbtutor = create_board("tutor")
self.boardUsuario, lytbuser, self.tbuser = create_board("user")
self.boardRival, lytbRival, self.tbRival = create_board(
"rival", siRival)
self.boardOpening, lytbOpening, self.tbOpening = create_board(
"opening", siOpenings, siLibre=False)
tutor.ponBoardsGUI(self.boardTutor, self.boardUsuario, self.boardRival,
self.boardOpening)
# Puntuaciones
self.lbTutorPuntuacion = Controles.LB(self).align_center().ponFuente(
flb)
self.lbUsuarioPuntuacion = Controles.LB(self).align_center().ponFuente(
flb)
if siRival:
self.lbRivalPuntuacion = Controles.LB(
self).align_center().ponFuente(flb)
# Openings
if siOpenings:
li_options = self.tutor.opcionesOpenings()
self.cbOpenings = Controles.CB(self, li_options, 0)
self.cbOpenings.setFont(flba)
self.connect(self.cbOpenings,
QtCore.SIGNAL("currentIndexChanged(int)"),
self.tutor.cambiarOpening)
# RM
liRM = []
for n, uno in enumerate(tutor.list_rm):
liRM.append((uno[1], n))
self.cbRM, self.lbRM = QTUtil2.comboBoxLB(self, liRM, liRM[0][1],
_("Moves analyzed"))
self.connect(self.cbRM, QtCore.SIGNAL("currentIndexChanged (int)"),
tutor.cambiadoRM)
lyRM = Colocacion.H().control(self.lbRM).control(self.cbRM)
lyTutor = Colocacion.V().relleno().control(
self.lbTutorPuntuacion).relleno()
gbTutor = Controles.GB(self, _("Tutor's suggestion"),
lyTutor).ponFuente(f).align_center()
if siPuntos:
gbTutor.to_connect(self.elegirTutor)
self.lbTutorPuntuacion.setEnabled(True)
lyUsuario = Colocacion.V().relleno().control(
self.lbUsuarioPuntuacion).relleno()
gbUsuario = Controles.GB(
self, _("Your move"),
lyUsuario).ponFuente(f).align_center().to_connect(
self.elegirUsuario)
self.lbUsuarioPuntuacion.setEnabled(True)
btLibros = Controles.PB(self, _("Consult a book"),
self.consultaLibro).ponPlano(False)
if siRival:
lyRival = Colocacion.V().relleno().control(
self.lbRivalPuntuacion).relleno()
gbRival = Controles.GB(self, _("Opponent's prediction"),
lyRival).ponFuente(f).align_center()
if siOpenings:
lyOpenings = Colocacion.V().relleno().control(
self.cbOpenings).relleno()
gbOpenings = Controles.GB(self, _("Opening"),
lyOpenings).align_center().ponFuente(f)
if siPuntos:
gbOpenings.to_connect(self.elegirOpening)
self.cbOpenings.setEnabled(True)
self.tutor.cambiarOpening(0)
dicVista = {
POS_TUTOR_HORIZONTAL: ((0, 1), (0, 2)),
POS_TUTOR_HORIZONTAL_2_1: ((0, 1), (4, 0)),
POS_TUTOR_HORIZONTAL_1_2: ((4, 0), (4, 1)),
POS_TUTOR_VERTICAL: ((4, 0), (8, 0)),
}
usu, riv = dicVista[self.x_tutor_view]
fu, cu = usu
fr, cr = riv
layout = Colocacion.G()
layout.controlc(gbTutor, 0, 0).controlc(self.boardTutor, 1,
0).otro(lytbtutor, 2,
0).otroc(lyRM, 3, 0)
layout.controlc(gbUsuario, fu,
cu).controlc(self.boardUsuario, fu + 1,
cu).otro(lytbuser, fu + 2, cu).controlc(
btLibros, fu + 3, cu)
if siRival:
layout.controlc(gbRival, fr,
cr).controlc(self.boardRival, fr + 1,
cr).otro(lytbRival, fr + 2, cr)
elif siOpenings:
layout.controlc(gbOpenings, fr,
cr).controlc(self.boardOpening, fr + 1,
cr).otro(lytbOpening, fr + 2, cr)
layout.margen(8)
self.setLayout(layout)
self.restore_video(siTam=False)
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
def __init__(self, procesador, dbop):
self.dbop = dbop
title = dbop.gettitle()
QTVarios.WDialogo.__init__(self, procesador.pantalla, title,
Iconos.OpeningLines(), "studyOpening")
self.procesador = procesador
self.configuracion = procesador.configuracion
self.partidabase = self.dbop.getpartidabase()
self.num_jg_inicial = self.partidabase.numJugadas()
self.num_jg_actual = None
self.partida = None
self.resultado = None
siFigurinesPGN = self.configuracion.figurinesPGN
liAcciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Remove"), Iconos.Borrar(), self.borrar),
None,
(_("Import"), Iconos.Mezclar(), self.importar),
None,
(_("Utilities"), Iconos.Utilidades(), self.utilidades),
None,
(_("Train"), Iconos.Study(), self.train),
None,
)
self.tb = Controles.TBrutina(self, liAcciones)
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("LINE",
_("Line"),
35,
edicion=Delegados.EtiquetaPOS(False, True))
inicio = self.partidabase.numJugadas() / 2 + 1
ancho_col = ((self.configuracion.anchoPGN - 35 - 20) / 2) * 80 // 100
for x in range(inicio, 75):
oColumnas.nueva(str(x),
str(x),
ancho_col,
edicion=Delegados.EtiquetaPOS(
siFigurinesPGN, True))
self.glines = Grid.Grid(self, oColumnas, siCabeceraMovible=False)
self.glines.setAlternatingRowColors(False)
self.glines.tipoLetra(puntos=self.configuracion.puntosPGN)
self.glines.ponAltoFila(self.configuracion.altoFilaPGN)
self.pboard = POLBoard.BoardLines(self, self.configuracion)
self.tabsanalisis = POLAnalisis.TabsAnalisis(self, self.procesador,
self.configuracion)
splitter = QtGui.QSplitter(self)
splitter.setOrientation(QtCore.Qt.Vertical)
splitter.addWidget(self.glines)
splitter.addWidget(self.tabsanalisis)
sp = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
splitter.setSizePolicy(sp)
self.registrarSplitter(splitter, "SPLITTER")
lyLV = Colocacion.V().control(splitter)
lyTB = Colocacion.V().control(self.tb).control(self.pboard)
layout = Colocacion.H().otro(lyTB).otro(lyLV).margen(3)
self.setLayout(layout)
self.colorPar = QTUtil.qtColor("#DBDAD9")
self.colorNon = QTUtil.qtColor("#F1EFE9")
self.colorLine = QTUtil.qtColor("#CDCCCB")
self.partida = self.partidabase
self.pboard.MoverFinal()
self.recuperarVideo()
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 configurarGS(self):
sep = (None, None, None)
liMasOpciones = [
("rotacion", _("Auto-rotate board"), Iconos.JS_Rotacion()),
sep,
("leerpgn", _("Read PGN"), Iconos.PGN_Importar()),
sep,
("pastepgn", _("Paste PGN"), Iconos.Pegar16()),
sep,
]
if not self.siCompleta:
liMasOpciones.extend([
("posicion", _("Start position"), Iconos.Datos()), sep,
("pasteposicion", _("Paste FEN position"), 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 == "posicion":
ini_fen = self.partida.iniPosicion.fen()
cur_fen = Voyager.voyagerFEN(self.pantalla, ini_fen)
if cur_fen and cur_fen != ini_fen:
self.partida.resetFEN(cur_fen)
self.inicio(self.partida, self.siCompleta)
elif resp == "pasteposicion":
texto = QTUtil.traePortapapeles()
if texto:
cp = ControlPosicion.ControlPosicion()
try:
cp.leeFen(str(texto))
self.fen = cp.fen()
self.posicApertura = None
self.reiniciar()
except:
pass
elif resp == "leerpgn":
unpgn = PantallaPGN.eligePartida(self.pantalla)
if unpgn:
partida = unpgn.partida
if self.siCompleta and not partida.siFenInicial():
return
p = Partida.PartidaCompleta()
p.leeOtra(partida)
p.asignaApertura()
p.setTags(unpgn.listaCabeceras())
self.reinicio = p.save()
self.reiniciar()
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
partida = unpgn.partida
if self.siCompleta and not partida.siFenInicial():
return
p = Partida.PartidaCompleta()
p.leeOtra(partida)
p.asignaApertura()
p.setTags(unpgn.listaCabeceras())
self.reinicio = p.save()
self.reiniciar()
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 controlTeclado(self, nkey):
if nkey == Qt.Key_V: # V
self.paste(QTUtil.traePortapapeles())
def go_next(self):
if self.working:
self.square_object, self.square_next = self.coordinates.next()
self.board.pon_textos(self.square_object, self.square_next, 0.8)
QTUtil.refresh_gui()
def muestra(self):
QTUtil.refreshGUI()
self.exec_()
QTUtil.refreshGUI()
def show_tb(self, *lista):
for opc in self.tb.dicTB:
self.tb.setAccionVisible(opc, opc in lista)
QTUtil.refresh_gui()
def run_gui(procesador):
app = QtWidgets.QApplication([])
# Usuarios
list_users = Usuarios.Usuarios().list_users
if list_users:
user = pide_usuario(list_users)
if user is None:
return
if user == list_users[0]:
user = None
else:
user = None
active_folder = Configuration.active_folder()
askfor_language = not os.path.isdir(active_folder) or not os.listdir(
active_folder)
procesador.start_with_user(user)
configuration = procesador.configuration
if user:
if not configuration.x_player:
configuration.x_player = user.name
configuration.graba()
elif configuration.x_player != user.name:
for usu in list_users:
if usu.number == user.number:
usu.name = configuration.x_player
Usuarios.Usuarios().save_list(list_users)
# Comprobamos el lenguaje
if askfor_language and not configuration.translator:
if user:
conf_main = Configuration.Configuration("")
ori = conf_main.file_external_engines()
conf_main.lee()
conf_main.limpia(user.name)
conf_main.set_folders()
conf_main.graba()
procesador.configuration = conf_main
Util.file_copy(ori, conf_main.file_external_engines())
else:
li = configuration.list_translations()
menu = QTVarios.LCMenuRondo(None)
for k, name, porc, author in li:
if porc != 100:
name += " (%d%%)" % porc
menu.opcion(k, name)
resp = menu.lanza()
if resp:
configuration.translator = resp
configuration.graba()
configuration.releeTRA()
# Estilo
# https://github.com/gmarull/qtmodern/blob/master/qtmodern/styles.py
# https://stackoverflow.com/questions/15035767/is-the-qt-5-dark-fusion-theme-available-for-windows
# darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
# darkPalette.setColor(QPalette.WindowText, QColor(180, 180, 180))
# darkPalette.setColor(QPalette.Base, QColor(42, 42, 42))
# darkPalette.setColor(QPalette.Text, QColor(180, 180, 180))
# darkPalette.setColor(QPalette.AlternateBase, QColor(66, 66, 66))
# darkPalette.setColor(QPalette.ToolTipBase, QColor(53, 53, 53))
# darkPalette.setColor(QPalette.ToolTipText, QColor(180, 180, 180))
# darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
# darkPalette.setColor(QPalette.ButtonText, QColor(180, 180, 180))
# darkPalette.setColor(QPalette.BrightText, QColor(180, 180, 180))
# darkPalette.setColor(QPalette.Link, QColor(56, 252, 196))
#
# darkPalette.setColor(QPalette.Light, QColor(180, 180, 180))
# darkPalette.setColor(QPalette.Midlight, QColor(90, 90, 90))
# darkPalette.setColor(QPalette.Dark, QColor(35, 35, 35))
# darkPalette.setColor(QPalette.Shadow, QColor(20, 20, 20))
# darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
# darkPalette.setColor(QPalette.HighlightedText, QColor(180, 180, 180))
#
# # disabled
# darkPalette.setColor(QPalette.Disabled, QPalette.WindowText,
# QColor(127, 127, 127))
# darkPalette.setColor(QPalette.Disabled, QPalette.Text,
# QColor(127, 127, 127))
# darkPalette.setColor(QPalette.Disabled, QPalette.ButtonText,
# QColor(127, 127, 127))
# darkPalette.setColor(QPalette.Disabled, QPalette.Highlight,
# QColor(80, 80, 80))
# darkPalette.setColor(QPalette.Disabled, QPalette.HighlightedText,
# QColor(127, 127, 127))
app.setStyle(QtWidgets.QStyleFactory.create(configuration.x_style))
if configuration.palette:
qpalette = QtGui.QPalette()
palette = configuration.palette
# palette_dark = {'Window': '#353535', 'WindowText': '#b4b4b4', 'Base': '#2a2a2a', 'Text': '#b4b4b4', 'AlternateBase': '#424242',
# 'ToolTipBase': '#353535', 'ToolTipText': '#b4b4b4', 'Button': '#353535', 'ButtonText': '#b4b4b4', 'BrightText': '#b4b4b4',
# 'Link': '#38fcc4'}
for key, tp in (
(QtGui.QPalette.Window, "Window"),
(QtGui.QPalette.WindowText, "WindowText"),
(QtGui.QPalette.Base, "Base"),
(QtGui.QPalette.Text, "Text"),
(QtGui.QPalette.AlternateBase, "AlternateBase"),
(QtGui.QPalette.ToolTipBase, "ToolTipBase"),
(QtGui.QPalette.ToolTipText, "ToolTipText"),
(QtGui.QPalette.Button, "Button"),
(QtGui.QPalette.ButtonText, "ButtonText"),
(QtGui.QPalette.BrightText, "BrightText"),
(QtGui.QPalette.Link, "Link"),
):
qpalette.setColor(key, QtGui.QColor(palette[tp]))
else:
qpalette = QtWidgets.QApplication.style().standardPalette()
app.setPalette(qpalette)
app.setEffectEnabled(QtCore.Qt.UI_AnimateMenu)
QtGui.QFontDatabase.addApplicationFont(
Code.path_resource("IntFiles", "ChessAlpha2.ttf"))
if configuration.x_font_family:
font = Controles.TipoLetra(configuration.x_font_family)
app.setFont(font)
Code.gc = QTUtil.GarbageCollector()
procesador.iniciar_gui()
resp = app.exec_()
return resp
def __init__(self, gestor, xmotor, nombreOP, posicion, mrm, rmOP, rmUsu,
analisis):
self.siCompetitivo = gestor.siCompetitivo
self.nombreOP = nombreOP
self.posicion = posicion
self.rmOP = rmOP
self.rmUsu = rmUsu
self.mrm = mrm
self.analisis = analisis
self.xmotor = xmotor
self.gestor = gestor
self.listaRM, self.posOP = self.hazListaRM()
self.posicion = posicion
titulo = _("Analysis")
icono = Iconos.Analizar()
extparam = "jzgm"
QTVarios.WDialogo.__init__(self, gestor.pantalla, titulo, icono,
extparam)
self.colorNegativo = QTUtil.qtColorRGB(255, 0, 0)
self.colorImpares = QTUtil.qtColorRGB(231, 244, 254)
self.lbComentario = Controles.LB(
self, "").ponTipoLetra(puntos=10).alinCentrado()
confTablero = VarGen.configuracion.confTablero("JUICIO", 32)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponerPiezasAbajo(posicion.siBlancas)
self.lbMotor = Controles.LB(self).alinCentrado()
self.lbTiempo = Controles.LB(self).alinCentrado()
liMas = ((_("Close"), "close", Iconos.Delete()), )
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self,
"",
siLibre=True,
tamIcon=24,
siMas=True,
liMasAcciones=liMas)
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("POSREAL", "#", 40, siCentrado=True)
oColumnas.nueva("JUGADAS",
"%d %s" % (len(self.listaRM), _("Moves")),
120,
siCentrado=True)
oColumnas.nueva("PLAYER", _("Player"), 120)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True)
lyT = Colocacion.V().control(self.tablero).otro(lyBM).control(
self.lbComentario)
# Layout
layout = Colocacion.H().otro(lyT).control(self.grid)
self.setLayout(layout)
self.grid.setFocus()
self.grid.goto(self.posOP, 0)
self.siMoviendoTiempo = False
self.ponPuntos()
def refresh(self):
self.update()
QTUtil.xrefreshGUI()
def mostrar(self):
QTUtil.refreshGUI()
self.exec_()
QTUtil.refreshGUI()