def me_setEditor(self, parent):
recno = self.gridValores.recno()
key = self.liKibActual[recno][2]
nk = self.krecno()
kibitzer = self.kibitzers.kibitzer(nk)
valor = control = lista = minimo = maximo = None
if key is None:
return None
elif key == "nombre":
control = "ed"
valor = kibitzer.nombre
elif key == "tipo":
valor = kibitzer.tipo
if valor == "I": # Indices no se cambian
return None
control = "cb"
lista = Kibitzers.Tipos().comboSinIndices()
elif key == "prioridad":
control = "cb"
lista = EngineThread.priorities.combo()
valor = kibitzer.prioridad
elif key == "posicionBase":
kibitzer.posicionBase = not kibitzer.posicionBase
self.kibitzers.save()
self.goto(nk)
elif key == "visible":
kibitzer.visible = not kibitzer.visible
self.kibitzers.save()
self.goto(nk)
elif key == "info":
control = "ed"
valor = kibitzer.idInfo
elif key.startswith("opcion"):
opcion = kibitzer.liOpciones[int(key[7:])]
tipo = opcion.tipo
valor = opcion.valor
if tipo == "spin":
control = "sb"
minimo = opcion.min
maximo = opcion.max
elif tipo in ("check", "button"):
opcion.valor = not valor
self.kibitzers.save()
self.goto(nk)
elif tipo == "combo":
lista = [(var, var) for var in opcion.liVars]
control = "cb"
elif tipo == "string":
control = "ed"
self.me_control = control
self.me_key = key
if control == "ed":
return Controles.ED(parent, valor)
elif control == "cb":
return Controles.CB(parent, lista, valor)
elif control == "sb":
return Controles.SB(parent, valor, minimo, maximo)
return None
def __init__(self, wParent, dicValoracion, dicVentaja):
icono = Iconos.TutorialesCrear()
extparam = "trainingMyOwnBook"
titulo = _("Create a training")
QTVarios.WDialogo.__init__(self, wParent, titulo, icono, extparam)
tb = QTUtil2.tbAcceptCancel(self)
lbName = Controles.LB(self, _("Name") + ": ")
self.name = Controles.ED(self).anchoFijo(200)
lyName = Colocacion.H().relleno().control(lbName).control(
self.name).relleno()
self.chbAddSTD = Controles.CHB(
self, _("Add a label with the standard opening"), True)
lyNameSTD = Colocacion.V().otro(lyName).control(
self.chbAddSTD).relleno()
self.sbDepth, lbDepth = QTUtil2.spinBoxLB(self,
30,
2,
999,
etiqueta=_("Depth"),
maxTam=48)
lyDepth = Colocacion.H().relleno().control(lbDepth).control(
self.sbDepth).relleno()
self.rbBlancas = Controles.RB(self, _("White")).activa()
self.rbNegras = Controles.RB(self, _("Black"))
hbox = Colocacion.H().control(self.rbBlancas).control(self.rbNegras)
gbColor = Controles.GB(self, _("Play with"), hbox)
self.tcWhite = TConf(dicValoracion, dicVentaja)
ly = Colocacion.H().control(self.tcWhite)
gbWhite = Controles.GB(self, "", ly)
gbWhite.setStyleSheet("QWidget { background-color: %s }" % "Ivory")
self.tcBlack = TConf(dicValoracion, dicVentaja)
ly = Colocacion.H().control(self.tcBlack)
gbBlack = Controles.GB(self, "", ly)
gbBlack.setStyleSheet("QWidget { background-color: %s }" % "Lavender")
tab = Controles.Tab()
tab.nuevaTab(gbWhite, _("Conditions to White"))
tab.nuevaTab(gbBlack, _("Conditions to Black"))
lyHead = Colocacion.H().otro(lyNameSTD).espacio(15).otro(
lyDepth).espacio(15).control(gbColor)
layout = Colocacion.V().control(tb).otro(lyHead).control(tab).margen(3)
self.setLayout(layout)
self.recuperarVideo()
self.siAceptado = False
def me_set_editor(self, parent):
recno = self.gridValores.recno()
key = self.liKibActual[recno][2]
nk = self.krecno()
kibitzer = self.kibitzers.kibitzer(nk)
valor = control = lista = minimo = maximo = None
if key is None:
return None
elif key == "name":
control = "ed"
valor = kibitzer.name
elif key == "prioridad":
control = "cb"
lista = Priorities.priorities.combo()
valor = kibitzer.prioridad
elif key == "pointofview":
control = "cb"
lista = Kibitzers.cb_pointofview_options()
valor = kibitzer.pointofview
elif key == "visible":
kibitzer.visible = not kibitzer.visible
self.kibitzers.save()
self.goto(nk)
elif key == "info":
control = "ed"
valor = kibitzer.id_info
elif key.startswith("opcion"):
opcion = kibitzer.li_uci_options_editable()[int(key[7:])]
tipo = opcion.tipo
valor = opcion.valor
if tipo == "spin":
control = "sb"
minimo = opcion.minimo
maximo = opcion.maximo
elif tipo in ("check", "button"):
opcion.valor = not valor
self.kibitzers.save()
self.goto(nk)
elif tipo == "combo":
lista = [(var, var) for var in opcion.li_vars]
control = "cb"
elif tipo == "string":
control = "ed"
self.me_control = control
self.me_key = key
if control == "ed":
return Controles.ED(parent, valor)
elif control == "cb":
return Controles.CB(parent, lista, valor)
elif control == "sb":
return Controles.SB(parent, valor, minimo, maximo)
return None
def __init__(self, owner, theme, your_themes):
super(WNameTheme, self).__init__(owner)
self.theme = theme
li_sections = [theme["SECCION"] for theme in your_themes if "SECCION" in theme]
self.li_sections = list(set(li_sections))
self.li_sections.sort()
self.setWindowTitle(_("Theme"))
self.setWindowIcon(Iconos.Temas())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
lb_name = Controles.LB2P(self, _("Name"))
self.ed_name = Controles.ED(self, theme.get("NOMBRE", ""))
ly_name = Colocacion.H().control(lb_name).control(self.ed_name)
lb_section = Controles.LB2P(self, _("Section"))
self.ed_section = Controles.ED(self, theme.get("SECCION", ""))
bt_section = Controles.PB(self, "", self.mira_section).ponIcono(Iconos.BuscarC(), 16).ponToolTip(_("Section lists"))
ly_section = Colocacion.H().control(lb_section).control(self.ed_section).espacio(-10).control(bt_section).relleno(1)
self.chb_pieces_set = Controles.CHB(self, _("Change piece set"), theme.get("CHANGE_PIECES", True))
li_acciones = [(_("Save"), Iconos.Aceptar(), self.aceptar), None, (_("Cancel"), Iconos.Cancelar(), self.reject), None]
self.tb = QTVarios.LCTB(self, li_acciones)
layout = Colocacion.V().control(self.tb).espacio(16)
layout.otro(ly_name).espacio(16)
layout.otro(ly_section).espacio(16)
layout.control(self.chb_pieces_set)
layout.margen(6)
self.setLayout(layout)
self.ed_name.setFocus()
if not self.li_sections:
bt_section.hide()
def __init__(self, owner, listaOpeningsStd, dic_data):
icono = Iconos.Opening()
titulo = _("Learn openings by repetition")
extparam = "opentrainingE"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
name = dic_data.get("NOMBRE", "")
self.listaOpeningsStd = listaOpeningsStd
self.liBloques = self.leeBloques(dic_data.get("LISTA", []))
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Add"), Iconos.Nuevo(), self.nueva),
None,
(_("Modify"), Iconos.Modificar(), self.modificar),
None,
(_("Remove"), Iconos.Borrar(), self.borrar),
None,
]
tb = Controles.TBrutina(self, li_acciones)
lbNombre = Controles.LB(self, _("Name") + ": ")
self.edNombre = Controles.ED(self, name)
lyNombre = Colocacion.H().control(lbNombre).control(self.edNombre)
# Lista
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NOMBRE", _("Name"), 240)
o_columns.nueva("PGN", _("Moves"), 360)
self.grid = Grid.Grid(self, o_columns, siSelecFilas=True)
n = self.grid.anchoColumnas()
self.grid.setMinimumWidth(n + 20)
self.register_grid(self.grid)
self.grid.gotop()
layout = Colocacion.V().control(tb).otro(lyNombre).control(self.grid)
self.setLayout(layout)
self.restore_video()
def genOpcionesME(owner, motorExterno):
fil = 0
col = 0
layout = Colocacion.G()
for opcion in motorExterno.liOpciones:
tipo = opcion.tipo
lb = Controles.LB(owner, opcion.nombre + ":").alinDerecha()
if tipo == "spin":
control = QTUtil2.spinBoxLB(owner,
opcion.valor,
opcion.min,
opcion.max,
maxTam=50 if opcion.max < 1000 else 80)
lb.ponTexto("%s [%d-%d] :" %
(opcion.nombre, opcion.min, opcion.max))
elif tipo == "check":
control = Controles.CHB(owner, " ", opcion.valor)
elif tipo == "combo":
liVars = []
for var in opcion.liVars:
liVars.append((var, var))
control = Controles.CB(owner, liVars, opcion.valor)
elif tipo == "string":
control = Controles.ED(
owner, opcion.valor
) # todo check si cambiar self por None no causa problemas
elif tipo == "button":
control = Controles.CHB(owner, " ", opcion.valor)
layout.controld(lb, fil, col).control(control, fil, col + 1)
col += 2
if col > 2:
fil += 1
col = 0
opcion.control = control
w = QtGui.QWidget(owner)
w.setLayout(layout)
scrollArea = QtGui.QScrollArea()
scrollArea.setBackgroundRole(QtGui.QPalette.Light)
scrollArea.setWidget(w)
scrollArea.setWidgetResizable(True)
return scrollArea
def wgen_options_engine(owner, engine):
fil = 0
col = 0
layout = Colocacion.G()
for opcion in engine.li_uci_options_editable():
tipo = opcion.tipo
lb = Controles.LB(owner, opcion.name + ":").align_right()
if tipo == "spin":
control = QTUtil2.spinBoxLB(
owner,
opcion.valor,
opcion.minimo,
opcion.maximo,
maxTam=50 if opcion.maximo < 1000 else 80)
lb.set_text("%s [%d-%d] :" %
(opcion.name, opcion.minimo, opcion.maximo))
elif tipo == "check":
control = Controles.CHB(owner, " ", opcion.valor)
elif tipo == "combo":
li_vars = []
for var in opcion.li_vars:
li_vars.append((var, var))
control = Controles.CB(owner, li_vars, opcion.valor)
elif tipo == "string":
control = Controles.ED(owner, opcion.valor)
# elif tipo == "button":
# control = Controles.CHB(owner, " ", opcion.valor)
layout.controld(lb, fil, col).control(control, fil, col + 1)
col += 2
if col > 2:
fil += 1
col = 0
opcion.control = control
w = QtWidgets.QWidget(owner)
w.setLayout(layout)
scrollArea = QtWidgets.QScrollArea()
scrollArea.setBackgroundRole(QtGui.QPalette.Light)
scrollArea.setWidget(w)
scrollArea.setWidgetResizable(True)
return scrollArea
def __init__(self, owner, titulo, wav=None, maxTime=None, nombre=None):
# titulo = _("Sound edition" )
icono = Iconos.S_Play()
extparam = "sound"
super().__init__(parent=owner,
titulo=titulo,
icono=icono,
extparam=extparam)
self.confich = VarGen.configuracion.ficheroDirSound
# toolbar
self.tb = QtWidgets.QToolBar("BASICO", self)
self.tb.setIconSize(QtCore.QSize(32, 32))
self.tb.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.preparaTB()
# Nombre
siNombre = nombre is not None
if siNombre:
lbNom = Controles.LB(self, _("Name") + ":")
self.edNom = Controles.ED(self, nombre).anchoMinimo(180)
lyNom = Colocacion.H().control(lbNom).control(self.edNom).relleno()
# MesaSonido
self.mesa = MesaSonido(self)
self.taller = Sonido.TallerSonido(wav)
self.mesa.ponCentesimas(self.taller.centesimas)
self.maxTime = maxTime if maxTime else 300.0 # segundos=5 minutos
layout = Colocacion.V().control(self.tb)
if siNombre:
layout.otro(lyNom)
layout.control(self.mesa).margen(3)
self.setLayout(layout)
self.ponBaseTB()
self.recuperarVideo(siTam=False)
def me_set_editor(self, parent):
recno = self.gridValores.recno()
key = self.li_options[recno][2]
control = lista = minimo = maximo = None
if key == "prioridad":
control = "cb"
lista = Priorities.priorities.combo()
valor = self.kibitzer.prioridad
elif key == "pointofview":
control = "cb"
lista = Kibitzers.cb_pointofview_options()
valor = self.kibitzer.pointofview
else:
opcion = self.kibitzer.li_uci_options_editable()[int(key)]
tipo = opcion.tipo
valor = opcion.valor
if tipo == "spin":
control = "sb"
minimo = opcion.minimo
maximo = opcion.maximo
elif tipo in ("check", "button"):
opcion.valor = not valor
self.li_options[recno][1] = opcion.valor
self.gridValores.refresh()
elif tipo == "combo":
lista = [(var, var) for var in opcion.li_vars]
control = "cb"
elif tipo == "string":
control = "ed"
self.me_control = control
self.me_key = key
if control == "ed":
return Controles.ED(parent, valor)
elif control == "cb":
return Controles.CB(parent, lista, valor)
elif control == "sb":
return Controles.SB(parent, valor, minimo, maximo)
return None
def me_setEditor(self, parent):
recno = self.gridValores.recno()
key = self.liOpciones[recno][2]
control = lista = minimo = maximo = None
if key == "prioridad":
control = "cb"
lista = EngineThread.priorities.combo()
valor = self.kibitzer.prioridad
elif key == "posicionBase":
self.kibitzer.posicionBase = not self.kibitzer.posicionBase
self.liOpciones[recno][1] = self.kibitzer.posicionBase
self.gridValores.refresh()
else:
opcion = self.kibitzer.liOpciones[int(key)]
tipo = opcion.tipo
valor = opcion.valor
if tipo == "spin":
control = "sb"
minimo = opcion.min
maximo = opcion.max
elif tipo in ("check", "button"):
opcion.valor = not valor
self.liOpciones[recno][1] = opcion.valor
self.gridValores.refresh()
elif tipo == "combo":
lista = [(var, var) for var in opcion.liVars]
control = "cb"
elif tipo == "string":
control = "ed"
self.me_control = control
self.me_key = key
if control == "ed":
return Controles.ED(parent, valor)
elif control == "cb":
return Controles.CB(parent, lista, valor)
elif control == "sb":
return Controles.SB(parent, valor, minimo, maximo)
return None
def __init__(self, liUsuarios):
QtWidgets.QDialog.__init__(self, None)
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint)
self.setWindowTitle(Code.lucas_chess)
self.setWindowIcon(Iconos.Aplicacion64())
self.setFont(Controles.TipoLetra(puntos=14))
self.liUsuarios = liUsuarios
li_options = [(usuario.name, nusuario)
for nusuario, usuario in enumerate(liUsuarios)]
lbU = Controles.LB(self, _("User") + ":")
self.cbU = Controles.CB(self, li_options, liUsuarios[0])
lbP = Controles.LB(self, _("Password") + ":")
self.edP = Controles.ED(self).password()
btaceptar = Controles.PB(self,
_("Accept"),
rutina=self.accept,
plano=False)
btcancelar = Controles.PB(self,
_("Cancel"),
rutina=self.reject,
plano=False)
ly = Colocacion.G()
ly.controld(lbU, 0, 0).control(self.cbU, 0, 1)
ly.controld(lbP, 1, 0).control(self.edP, 1, 1)
lybt = Colocacion.H().relleno().control(btaceptar).espacio(10).control(
btcancelar)
layout = Colocacion.V().otro(ly).espacio(10).otro(lybt).margen(10)
self.setLayout(layout)
self.edP.setFocus()
def __init__(self, parent, objetivo):
QtWidgets.QDialog.__init__(self, parent)
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.FramelessWindowHint)
self.edAnotacion = Controles.ED(self, "")
btAceptar = Controles.PB(self, "", rutina=self.aceptar).ponIcono(
Iconos.Aceptar())
btCancelar = Controles.PB(self, "", rutina=self.cancelar).ponIcono(
Iconos.Cancelar())
btAyuda = Controles.PB(self, "",
rutina=self.ayuda).ponIcono(Iconos.AyudaGR())
self.objetivo = objetivo
self.conAyuda = False
self.errores = 0
self.resultado = None
layout = (Colocacion.H().relleno(1).control(btAyuda).control(
self.edAnotacion).control(btAceptar).control(btCancelar).margen(3))
self.setLayout(layout)
self.move(parent.x() + parent.board.width() - 212,
parent.y() + parent.board.y() - 3)
def __init__(self, liUsuarios):
QtGui.QDialog.__init__(self, None)
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint)
main = liUsuarios[0]
self.setWindowTitle(main.trlucas)
self.setWindowIcon(Iconos.Usuarios())
liOpciones = [(usuario.nombre, usuario) for usuario in liUsuarios]
lbU = Controles.LB(self, main.trusuario + ":")
self.cbU = Controles.CB(self, liOpciones, main)
lbP = Controles.LB(self, main.trpassword + ":")
self.edP = Controles.ED(self).password()
btaceptar = Controles.PB(self,
main.traceptar,
rutina=self.accept,
plano=False)
btcancelar = Controles.PB(self,
main.trcancelar,
rutina=self.reject,
plano=False)
ly = Colocacion.G()
ly.controld(lbU, 0, 0).control(self.cbU, 0, 1)
ly.controld(lbP, 1, 0).control(self.edP, 1, 1)
lybt = Colocacion.H().relleno().control(btaceptar).espacio(10).control(
btcancelar)
layout = Colocacion.V().otro(ly).espacio(10).otro(lybt).margen(10)
self.setLayout(layout)
self.edP.setFocus()
def me_set_editor(self, parent):
recno = self.grid_uci.recno()
opcion = self.rival.li_uci_options_editable()[recno]
key = opcion.name
value = opcion.valor
for xkey, xvalue in self.rival.liUCI:
if xkey == key:
value = xvalue
break
if key is None:
return None
control = lista = minimo = maximo = None
tipo = opcion.tipo
if tipo == "spin":
control = "sb"
minimo = opcion.minimo
maximo = opcion.maximo
elif tipo in ("check", "button"):
self.rival.ordenUCI(key, not value)
self.grid_uci.refresh()
elif tipo == "combo":
lista = [(var, var) for var in opcion.li_vars]
control = "cb"
elif tipo == "string":
control = "ed"
self.me_control = control
self.me_key = key
if control == "ed":
return Controles.ED(parent, value)
elif control == "cb":
return Controles.CB(parent, lista, value)
elif control == "sb":
return Controles.SB(parent, value, minimo, maximo)
return None
def __init__(self, parent, objetivo):
QtWidgets.QDialog.__init__(self, parent)
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.FramelessWindowHint)
self.edAnotacion = Controles.ED(
self, "").ponTipoLetra(puntos=Code.configuration.x_menu_points)
btAceptar = Controles.PB(self, "", rutina=self.aceptar).ponIcono(
Iconos.Aceptar(), 32)
btCancelar = Controles.PB(self, "", rutina=self.cancelar).ponIcono(
Iconos.MainMenu(), 32)
btAyuda = Controles.PB(self, "", rutina=self.ayuda).ponIcono(
Iconos.AyudaGR(), 32)
self.objetivo = objetivo
self.conAyuda = False
self.errores = 0
self.resultado = None
layout = Colocacion.H().relleno(1).control(btAyuda).control(
self.edAnotacion).control(btAceptar).control(btCancelar).margen(3)
self.setLayout(layout)
self.move(parent.x() + parent.board.width() - 308,
parent.y() + parent.board.y() - 18)
def __init__(self, wParent, oColumnas, liFiltro):
super(WFiltrar, self).__init__(wParent)
self.setWindowTitle(_("Filter"))
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
self.liFiltro = liFiltro
nFiltro = len(liFiltro)
liCampos = [(x.cabecera, x.clave) for x in oColumnas.liColumnas
if x.clave != "numero"]
liCampos.insert(0, ("", None))
liCondicion = [("", None), (_("Equal"), "="), (_("Not equal"), "<>"),
(_("Greater than"), ">"), (_("Less than"), "<"),
(_("Greater than or equal"), ">="),
(_("Less than or equal"), "<="),
(_("Like (wildcard = *)"), "LIKE"),
(_("Not like (wildcard = *)"), "NOT LIKE")]
liUnion = [("", None), (_("AND"), "AND"), (_("OR"), "OR")]
f = Controles.TipoLetra(puntos=12) # 0, peso=75 )
lbCol = Controles.LB(self, _("Column")).ponFuente(f)
lbPar0 = Controles.LB(self, "(").ponFuente(f)
lbPar1 = Controles.LB(self, ")").ponFuente(f)
lbCon = Controles.LB(self, _("Condition")).ponFuente(f)
lbVal = Controles.LB(self, _("Value")).ponFuente(f)
lbUni = Controles.LB(self, "+").ponFuente(f)
ly = Colocacion.G()
ly.controlc(lbUni, 0,
0).controlc(lbPar0, 0, 1).controlc(lbCol, 0, 2).controlc(
lbCon, 0, 3).controlc(lbVal, 0,
4).controlc(lbPar1, 0, 5)
self.numC = 8
liC = []
for i in range(self.numC):
if nFiltro > i:
union, par0, campo, condicion, valor, par1 = liFiltro[i]
else:
union, par0, campo, condicion, valor, par1 = None, False, None, None, "", False
if i > 0:
c_union = Controles.CB(self, liUnion, union)
ly.controlc(c_union, i + 1, 0)
else:
c_union = None
c_par0 = Controles.CHB(self, "", par0).anchoFijo(20)
ly.controlc(c_par0, i + 1, 1)
c_campo = Controles.CB(self, liCampos, campo)
ly.controlc(c_campo, i + 1, 2)
c_condicion = Controles.CB(self, liCondicion, condicion)
ly.controlc(c_condicion, i + 1, 3)
c_valor = Controles.ED(self, valor)
ly.controlc(c_valor, i + 1, 4)
c_par1 = Controles.CHB(self, "", par1).anchoFijo(20)
ly.controlc(c_par1, i + 1, 5)
liC.append(
(c_union, c_par0, c_campo, c_condicion, c_valor, c_par1))
self.liC = liC
# Toolbar
liAcciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.reject),
None,
(_("Reinit"), Iconos.Reiniciar(), self.reiniciar),
None,
]
tb = Controles.TBrutina(self, liAcciones)
# Layout
layout = Colocacion.V().control(tb).otro(ly).margen(3)
self.setLayout(layout)
liC[0][2].setFocus()
def __init__(self, wParent, torneo):
titulo = _("Competition")
icono = Iconos.Torneos()
extparam = "untorneo"
QTVarios.WDialogo.__init__(self, wParent, titulo, icono, extparam)
self.configuracion = VarGen.configuracion
# Datos
self.torneo = torneo
self.liEnActual = []
self.xjugar = None
self.liResult = None
# Toolbar
liAcciones = (
(_("Save") + "+" + _("Quit"), Iconos.MainMenu(), "terminar"),
None,
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
None,
(_("Play"), Iconos.Empezar(), "gmJugar"),
None,
)
tb = Controles.TB(self, liAcciones)
# Tabs
self.tab = tab = Controles.Tab()
# Tab-configuracion --------------------------------------------------
w = QtGui.QWidget()
# # Nombre
lbNombre = Controles.LB(self, _("Name") + ": ")
self.edNombre = Controles.ED(w, torneo.nombre())
# # Resign
lbResign = Controles.LB(self,
_("Minimum points to assign winner") + ": ")
self.sbResign = Controles.SB(self, torneo.resign(), 60, 10000)
# Draw-plys
lbDrawMinPly = Controles.LB(self,
_("Minimum moves to assign draw") + ": ")
self.sbDrawMinPly = Controles.SB(self, torneo.drawMinPly(), 20, 9999)
# Draw-puntos
lbDrawRange = Controles.LB(self,
_("Maximum points to assign draw") + ": ")
self.sbDrawRange = Controles.SB(self, torneo.drawRange(), 0, 50)
lbBook = Controles.LB(self, _("Opening book") + ": ")
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.recuperaVar(fvar)
# Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.nombre, x.path) for x in self.listaLibros.lista]
li.insert(0, ("* " + _("Default"), ""))
self.cbBooks = Controles.CB(self, li, torneo.book())
btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=False).ponIcono(Iconos.Nuevo(),
tamIcon=16)
lyBook = Colocacion.H().control(
self.cbBooks).control(btNuevoBook).relleno()
# Posicion inicial
lbFEN = Controles.LB(self, _("Initial position") + ": ")
self.fen = torneo.fen()
self.btPosicion = Controles.PB(self, " " * 5 + _("Change") + " " * 5,
self.posicionEditar).ponPlano(False)
self.btPosicionQuitar = Controles.PB(
self, "", self.posicionQuitar).ponIcono(Iconos.Motor_No())
self.btPosicionPegar = Controles.PB(self, "",
self.posicionPegar).ponIcono(
Iconos.Pegar16()).ponToolTip(
_("Paste FEN position"))
lyFEN = Colocacion.H().control(self.btPosicionQuitar).control(
self.btPosicion).control(self.btPosicionPegar).relleno()
# Norman Pollock
lbNorman = Controles.LB(
self,
'%s(<a href="http://www.hoflink.com/~npollock/40H.html">?</a>): ' %
_("Initial position from Norman Pollock openings database"))
self.chbNorman = Controles.CHB(self, " ", self.torneo.norman())
# Layout
layout = Colocacion.G()
layout.controld(lbNombre, 0, 0).control(self.edNombre, 0, 1)
layout.controld(lbResign, 1, 0).control(self.sbResign, 1, 1)
layout.controld(lbDrawMinPly, 2, 0).control(self.sbDrawMinPly, 2, 1)
layout.controld(lbDrawRange, 3, 0).control(self.sbDrawRange, 3, 1)
layout.controld(lbBook, 4, 0).otro(lyBook, 4, 1)
layout.controld(lbFEN, 5, 0).otro(lyFEN, 5, 1)
layout.controld(lbNorman, 6, 0).control(self.chbNorman, 6, 1)
layoutV = Colocacion.V().relleno().otro(layout).relleno()
layoutH = Colocacion.H().relleno().otro(layoutV).relleno()
# Creamos
w.setLayout(layoutH)
tab.nuevaTab(w, _("Configuration"))
# Tab-engines --------------------------------------------------
self.splitterEngines = QtGui.QSplitter(self)
self.registrarSplitter(self.splitterEngines, "engines")
# TB
liAcciones = [
(_("New"), Iconos.TutorialesCrear(), "enNuevo"),
None,
(_("Modify"), Iconos.Modificar(), "enModificar"),
None,
(_("Remove"), Iconos.Borrar(), "enBorrar"),
None,
(_("Copy"), Iconos.Copiar(), "enCopiar"),
None,
(_("Import"), Iconos.MasDoc(), "enImportar"),
None,
]
tbEnA = Controles.TB(self, liAcciones, tamIcon=24)
# Grid engine
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("ALIAS", _("Alias"), 209)
self.gridEnginesAlias = Grid.Grid(self,
oColumnas,
siSelecFilas=True,
xid="EA",
siSeleccionMultiple=True)
self.registrarGrid(self.gridEnginesAlias)
w = QtGui.QWidget()
ly = Colocacion.V().control(self.gridEnginesAlias).margen(0)
w.setLayout(ly)
self.splitterEngines.addWidget(w)
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("CAMPO", _("Label"), 200, siDerecha=True)
oColumnas.nueva("VALOR", _("Value"), 286)
self.gridEnginesValores = Grid.Grid(self,
oColumnas,
siSelecFilas=False,
xid="EV")
self.registrarGrid(self.gridEnginesValores)
w = QtGui.QWidget()
ly = Colocacion.V().control(self.gridEnginesValores).margen(0)
w.setLayout(ly)
self.splitterEngines.addWidget(w)
self.splitterEngines.setSizes([250, 520]) # por defecto
w = QtGui.QWidget()
ly = Colocacion.V().control(tbEnA).control(self.splitterEngines)
w.setLayout(ly)
tab.nuevaTab(w, _("Engines"))
# Creamos
# Tab-games --------------------------------------------------
w = QtGui.QWidget()
# TB
liAcciones = [
(_("New"), Iconos.TutorialesCrear(), "gmCrear"),
None,
(_("Remove"), Iconos.Borrar(), "gmBorrar"),
None,
(_("Show"), Iconos.PGN(), "gmMostrar"),
None,
(_("Save") + "(%s)" % _("PGN"), Iconos.GrabarComo(), "gmGuardar"),
None,
]
tbEnG = Controles.TB(self, liAcciones, tamIcon=24)
# Grid engine
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("WHITE", _("White"), 190, siCentrado=True)
oColumnas.nueva("BLACK", _("Black"), 190, siCentrado=True)
oColumnas.nueva("RESULT", _("Result"), 190, siCentrado=True)
oColumnas.nueva("TIEMPO", _("Time"), 170, siCentrado=True)
self.gridGames = Grid.Grid(self,
oColumnas,
siSelecFilas=True,
xid="G",
siSeleccionMultiple=True)
self.registrarGrid(self.gridGames)
# Layout
layout = Colocacion.V().control(tbEnG).control(self.gridGames)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Games"))
# Tab-resultado --------------------------------------------------
w = QtGui.QWidget()
# Grid
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("NUMERO", _("N."), 35, siCentrado=True)
oColumnas.nueva("MOTOR", _("Engine"), 190, siCentrado=True)
oColumnas.nueva("GANADOS", _("Wins"), 120, siCentrado=True)
oColumnas.nueva("PERDIDOS", _("Lost"), 120, siCentrado=True)
oColumnas.nueva("TABLAS", _("Draw"), 120, siCentrado=True)
oColumnas.nueva("PUNTOS", _("Points"), 120, siCentrado=True)
self.gridResult = Grid.Grid(self,
oColumnas,
siSelecFilas=True,
xid="R")
self.registrarGrid(self.gridResult)
# Layout
layout = Colocacion.V().control(self.gridResult)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Result"))
# Layout
layout = Colocacion.V().control(tb).control(tab).margen(8)
self.setLayout(layout)
self.recuperarVideo(siTam=True, anchoDefecto=800, altoDefecto=430)
self.gridEnginesAlias.gotop()
self.edNombre.setFocus()
self.muestraPosicion()
def __init__(self, procesador):
self.configuracion = procesador.configuracion
self.procesador = procesador
self.dbHisto = Util.DicSQL(self.configuracion.ficheroGMhisto)
self.bloqueApertura = None
self.liAperturasFavoritas = []
wParent = procesador.pantalla
titulo = _("Play like a grandmaster")
icono = Iconos.GranMaestro()
extparam = "gm"
QTVarios.WDialogo.__init__(self, wParent, titulo, icono, extparam)
flb = Controles.TipoLetra(puntos=10)
# Toolbar
liAcciones = [(_("Accept"), Iconos.Aceptar(), self.aceptar), None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar), None,
(_("One game"), Iconos.Uno(), self.unJuego), None,
(_("Import"), Iconos.ImportarGM(), self.importar)
]
tb = Controles.TBrutina(self, liAcciones)
# Grandes maestros
self.liGM = GM.listaGM()
li = [(x[0], x[1]) for x in self.liGM]
li.insert(0, ("-", None))
self.cbGM = QTUtil2.comboBoxLB(self, li, li[0][1] if len(self.liGM) == 0 else li[1][1])
self.cbGM.capturaCambiado(self.compruebaGM)
hbox = Colocacion.H().relleno().control(self.cbGM).relleno()
gbGM = Controles.GB(self, _("Choose a grandmaster"), hbox).ponFuente(flb)
# Personales
self.liPersonal = GM.listaGMpersonal(self.procesador.configuracion.dirPersonalTraining)
if self.liPersonal:
li = [(x[0], x[1]) for x in self.liPersonal]
li.insert(0, ("-", None))
self.cbPersonal = QTUtil2.comboBoxLB(self, li, li[0][1])
self.cbPersonal.capturaCambiado(self.compruebaP)
btBorrar = Controles.PB(self, "", self.borrarPersonal, plano=False).ponIcono(Iconos.Borrar(), tamIcon=16)
hbox = Colocacion.H().relleno().control(self.cbPersonal).control(btBorrar).relleno()
gbPersonal = Controles.GB(self, _("Personal games"), hbox).ponFuente(flb)
# Color
self.rbBlancas = Controles.RB(self, _("White"), rutina=self.compruebaColor)
self.rbBlancas.activa(True)
self.rbNegras = Controles.RB(self, _("Black"), rutina=self.compruebaColor)
self.rbNegras.activa(False)
# Contrario
self.chContrario = Controles.CHB(self, _("Choose the opponent's move, when there are multiple possible answers"),
False)
# Juez
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
self.liMotores = self.configuracion.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(self, self.liMotores, self.configuracion.tutorInicial, _("Engine"))
self.edJtiempo = Controles.ED(self).tipoFloat().ponFloat(1.0).anchoFijo(50)
self.lbJtiempo = Controles.LB2P(self, _("Time in seconds"))
self.cbJdepth = Controles.CB(self, liDepths, 0).capturaCambiado(self.cambiadoDepth)
self.lbJdepth = Controles.LB2P(self, _("Depth"))
self.lbJshow = Controles.LB2P(self, _("Show rating"))
self.chbEvals = Controles.CHB(self, _("Show all evaluations"), False)
liOptions = [(_("All moves"), None), (_("Moves are different"), True), (_("Never"), False)]
self.cbJshow = Controles.CB(self, liOptions, True)
self.lbJmultiPV = Controles.LB2P(self, _("Number of moves evaluated by engine(MultiPV)"))
li = [(_("Default"), "PD"),
(_("Maximum"), "MX")]
for x in (1, 3, 5, 10, 15, 20, 30, 40, 50, 75, 100, 150, 200):
li.append((str(x), str(x)))
self.cbJmultiPV = Controles.CB(self, li, "PD")
# Inicial
self.edJugInicial, lbInicial = QTUtil2.spinBoxLB(self, 1, 1, 99, etiqueta=_("Initial move"), maxTam=40)
# Libros
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.recuperaVar(fvar)
# # Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.nombre, x) for x in self.listaLibros.lista]
li.insert(0, ("--", None))
self.cbBooks, lbBooks = QTUtil2.comboBoxLB(self, li, None, _("Bypass moves in the book"))
# Aperturas
self.btApertura = Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.aperturasEditar).ponPlano(
False)
self.btAperturasFavoritas = Controles.PB(self, "", self.aperturasFavoritas).ponIcono(Iconos.Favoritos())
self.btAperturasQuitar = Controles.PB(self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = Colocacion.H().control(self.btAperturasQuitar).control(self.btApertura).control(
self.btAperturasFavoritas).relleno()
gbOpening = Controles.GB(self, _("Opening"), hbox)
# gbBasic
# # Color
hbox = Colocacion.H().relleno().control(self.rbBlancas).espacio(10).control(self.rbNegras).relleno()
gbColor = Controles.GB(self, _("Play with"), hbox).ponFuente(flb)
# Tiempo
ly1 = Colocacion.H().control(self.lbJmotor).control(self.cbJmotor).control(self.lbJshow).control(
self.cbJshow).relleno()
ly2 = Colocacion.H().control(self.lbJtiempo).control(self.edJtiempo)
ly2.control(self.lbJdepth).control(self.cbJdepth).espacio(15).control(self.chbEvals).relleno()
ly3 = Colocacion.H().control(self.lbJmultiPV).control(self.cbJmultiPV).relleno()
ly = Colocacion.V().otro(ly1).otro(ly2).otro(ly3)
self.gbJ = Controles.GB(self, _("Adjudicator"), ly).conectar(self.cambiaJuez)
# Opciones
vlayout = Colocacion.V().control(gbColor)
vlayout.espacio(5).control(self.gbJ)
vlayout.margen(20)
gbBasic = Controles.GB(self, "", vlayout)
gbBasic.setFlat(True)
# Opciones avanzadas
lyInicial = Colocacion.H().control(lbInicial).control(self.edJugInicial).relleno().control(lbBooks).control(
self.cbBooks).relleno()
vlayout = Colocacion.V().relleno().otro(lyInicial).control(gbOpening)
vlayout.espacio(5).control(self.chContrario).margen(20).relleno()
gbAdvanced = Controles.GB(self, "", vlayout)
gbAdvanced.setFlat(True)
# Historico
self.liHisto = []
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("FECHA", _("Date"), 80, siCentrado=True)
oColumnas.nueva("PACIERTOS", _("Hints"), 90, siCentrado=True)
oColumnas.nueva("PUNTOS", _("Points accumulated"), 120, siCentrado=True)
oColumnas.nueva("ENGINE", _("Adjudicator"), 100, siCentrado=True)
oColumnas.nueva("RESUMEN", _("Game played"), 150)
self.grid = grid = Grid.Grid(self, oColumnas, siSelecFilas=True, background=None)
self.grid.coloresAlternados()
self.registrarGrid(grid)
# Tabs
self.tab = Controles.Tab().ponPosicion("S")
self.tab.nuevaTab(gbBasic, _("Basic"))
self.tab.nuevaTab(gbAdvanced, _("Advanced"))
self.tab.nuevaTab(self.grid, _("Track record"))
# Cabecera
lyCab = Colocacion.H().control(gbGM)
if self.liPersonal:
lyCab.control(gbPersonal)
layout = Colocacion.V().control(tb).otro(lyCab).control(self.tab).margen(3)
self.setLayout(layout)
self.recuperaDic()
self.cambiaJuez()
self.compruebaGM()
self.compruebaP()
self.compruebaHisto()
self.aperturaMuestra()
self.btAperturasFavoritas.hide()
self.recuperarVideo(anchoDefecto=450)
def __init__(self, wParent, configuracion, dic, siGestorSolo):
super(WCambioRival, self).__init__(wParent)
if not dic:
dic = {}
self.setWindowTitle(_("Change opponent"))
self.setWindowIcon(Iconos.Motor())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
self.configuracion = configuracion
self.personalidades = Personalidades.Personalidades(self, configuracion)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), "aceptar"),
None,
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
None,
]
tb = Controles.TB(self, li_acciones)
# Blancas o negras
self.rbBlancas = Controles.RB(self, _("White")).activa()
self.rbNegras = Controles.RB(self, _("Black"))
# Motores
self.motores = SelectEngines.SelectEngines(configuracion)
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
# # Rival
self.rival = configuracion.x_rival_inicial
self.rivalTipo = SelectEngines.INTERNO
self.btRival = Controles.PB(self, "", self.cambiaRival, plano=False)
self.edRtiempo = Controles.ED(self).tipoFloat().anchoMaximo(50)
self.cbRdepth = Controles.CB(self, liDepths, 0).capturaCambiado(self.cambiadoDepth)
lbTiempoSegundosR = Controles.LB2P(self, _("Time"))
lbNivel = Controles.LB2P(self, _("Depth"))
# # Ajustar rival
liAjustes = self.personalidades.listaAjustes(True)
self.cbAjustarRival = Controles.CB(self, liAjustes, ADJUST_BETTER).capturaCambiado(self.ajustesCambiado)
lbAjustarRival = Controles.LB2P(self, _("Set strength"))
self.btAjustarRival = Controles.PB(self, "", self.cambiaPersonalidades, plano=False).ponIcono(
Iconos.Nuevo(), tamIcon=16
)
self.btAjustarRival.ponToolTip(_("Personalities"))
# Layout
# Color
hbox = Colocacion.H().relleno().control(self.rbBlancas).espacio(30).control(self.rbNegras).relleno()
gbColor = Controles.GB(self, _("Play with"), hbox)
# #Color
hAC = Colocacion.H().control(gbColor)
# Motores
# Rival
ly = Colocacion.G()
ly.controlc(self.btRival, 0, 0, 1, 4)
ly.controld(lbTiempoSegundosR, 1, 0).controld(self.edRtiempo, 1, 1)
ly.controld(lbNivel, 1, 2).control(self.cbRdepth, 1, 3)
lyH = Colocacion.H().control(lbAjustarRival).control(self.cbAjustarRival).control(self.btAjustarRival).relleno()
ly.otroc(lyH, 2, 0, 1, 4)
gbR = Controles.GB(self, _("Opponent"), ly)
lyResto = Colocacion.V()
lyResto.otro(hAC).espacio(3)
lyResto.control(gbR).espacio(1)
lyResto.margen(8)
layout = Colocacion.V().control(tb).otro(lyResto).relleno().margen(3)
self.setLayout(layout)
self.dic = dic
self.recuperaDic()
self.ajustesCambiado()
self.ponRival()
def __init__(self, procesador, titulo):
QTVarios.WDialogo.__init__(self, procesador.pantalla, titulo,
Iconos.Libre(), "entMaquina")
self.configuracion = procesador.configuracion
self.procesador = procesador
self.personalidades = Personalidades.Personalidades(
self, self.configuracion)
self.motores = Motores.Motores(self.configuracion)
# Toolbar
liAcciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Configurations"), Iconos.Configurar(), self.configuraciones),
None,
]
tb = Controles.TBrutina(self, liAcciones)
# Tab
tab = Controles.Tab()
def nuevoG():
lyG = Colocacion.G()
lyG.filaActual = 0
return lyG
gbStyle = """
QGroupBox {
font: bold 16px;
background-color: #F2F2EC;/*qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E0E0E0, stop: 1 #FFFFFF);*/
border: 1px solid gray;
border-radius: 3px;
margin-top: 5ex; /* leave space at the top for the title */
}
QGroupBox::title {
subcontrol-origin: margin;
subcontrol-position: top center; /* position at the top center */
padding: 0 3px;
}
"""
def _label(lyG, txt, ly, rutinaCHB=None, siCheck=False):
gb = Controles.GB(self, txt, ly)
if rutinaCHB:
gb.conectar(rutinaCHB)
elif siCheck:
gb.setCheckable(True)
gb.setChecked(False)
gb.setStyleSheet(gbStyle)
lyG.controlc(gb, lyG.filaActual, 0)
lyG.filaActual += 1
return gb
# TAB General
lyG = nuevoG()
# Blancas o negras
self.rbBlancas = Controles.RB(self, "").activa()
self.rbBlancas.setIcon(
QTVarios.fsvg2ico("Pieces/Chessicons/wp.svg", 64))
self.rbNegras = Controles.RB(self, "")
self.rbNegras.setIcon(QTVarios.fsvg2ico("Pieces/Chessicons/bp.svg",
64))
self.rbRandom = Controles.RB(self, _("Random"))
hbox = Colocacion.H().relleno().control(
self.rbBlancas).espacio(30).control(
self.rbNegras).espacio(30).control(self.rbRandom).relleno()
_label(lyG, _("Select color"), hbox)
# Motores
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
# # Rival
self.rival = self.configuracion.rivalInicial
self.rivalTipo = Motores.INTERNO
self.btRival = Controles.PB(self, "", self.cambiaRival, plano=False)
self.edRtiempo = Controles.ED(self).tipoFloat().anchoMaximo(50)
self.cbRdepth = Controles.CB(self, liDepths,
0).capturaCambiado(self.cambiadoDepth)
lbTiempoSegundosR = Controles.LB2P(self, _("Time"))
lbNivel = Controles.LB2P(self, _("Depth"))
# # Ajustar rival
liAjustes = self.personalidades.listaAjustes(True)
self.cbAjustarRival = Controles.CB(self, liAjustes,
kAjustarMejor).capturaCambiado(
self.ajustesCambiado)
lbAjustarRival = Controles.LB2P(self, _("Set strength"))
btAjustarRival = Controles.PB(self,
_("Personality"),
self.cambiaPersonalidades,
plano=True).ponIcono(Iconos.Mas(),
tamIcon=16)
# Resign
lbResign = Controles.LB2P(self, _("Resign/draw by engine"))
liResign = ((_("Very early"), -100), (_("Early"), -300),
(_("Average"), -500), (_("Late"), -800),
(_("Very late"), -1000), (_("Never"), -9999999))
self.cbResign = Controles.CB(self, liResign, -800)
lyH1 = Colocacion.H().control(self.btRival).espacio(20)
lyH1.control(lbTiempoSegundosR).control(self.edRtiempo)
lyH1.control(lbNivel).control(self.cbRdepth).relleno()
lyH2 = Colocacion.H().control(lbAjustarRival).control(
self.cbAjustarRival).control(btAjustarRival).relleno()
lyH3 = Colocacion.H().control(lbResign).control(
self.cbResign).relleno()
ly = Colocacion.V().otro(lyH1).otro(lyH2).otro(lyH3)
_label(lyG, _("Opponent"), ly)
gb = Controles.GB(self, "", lyG)
tab.nuevaTab(gb, _("Basic configuration"))
# TAB Ayudas
lbAyudas = Controles.LB2P(self, _("Available hints"))
self.sbAyudas = Controles.SB(self, 7, 0, 999).tamMaximo(50)
self.cbAtras = Controles.CHB(self, _("Takeback"), True)
self.cbChance = Controles.CHB(self, _("Second chance"), True)
btTutorChange = Controles.PB(self,
_("Tutor change"),
self.tutorChange,
plano=False).ponIcono(Iconos.Tutor(),
tamIcon=16)
liThinks = [(_("Nothing"), -1), (_("Score"), 0)]
for i in range(1, 5):
liThinks.append(
("%d %s" % (i, _("ply") if i == 1 else _("plies")), i))
liThinks.append((_("All"), 9999))
lb = Controles.LB(self, _("It is showed") + ":")
self.cbThoughtTt = Controles.CB(self, liThinks, -1)
self.cbContinueTt = Controles.CHB(
self, _("The tutor thinks while you think"), True)
lbBoxHeight = Controles.LB2P(self, _("Box height"))
self.sbBoxHeight = Controles.SB(self, 7, 0, 999).tamMaximo(50)
ly1 = Colocacion.H().control(lb).control(self.cbThoughtTt).relleno()
ly2 = Colocacion.H().control(lbBoxHeight).control(
self.sbBoxHeight).relleno()
ly = Colocacion.V().otro(ly1).control(
self.cbContinueTt).espacio(16).otro(ly2).relleno()
gbThoughtTt = Controles.GB(self, _("Thought of the tutor"), ly)
gbThoughtTt.setStyleSheet(gbStyle)
lb = Controles.LB(self, _("It is showed") + ":")
self.cbThoughtOp = Controles.CB(self, liThinks, -1)
lbArrows = Controles.LB2P(self, _("Arrows to show"))
self.sbArrows = Controles.SB(self, 7, 0, 999).tamMaximo(50)
ly1 = Colocacion.H().control(lb).control(self.cbThoughtOp).relleno()
ly2 = Colocacion.H().control(lbArrows).control(self.sbArrows).relleno()
ly = Colocacion.V().otro(ly1).otro(ly2).relleno()
gbThoughtOp = Controles.GB(self, _("Thought of the opponent"), ly)
gbThoughtOp.setStyleSheet(gbStyle)
self.chbSummary = Controles.CHB(
self,
_("Save a summary when the game is finished in the main comment"),
False)
lyH1 = Colocacion.H().relleno()
lyH1.control(lbAyudas).control(self.sbAyudas).relleno()
lyH1.control(self.cbAtras).relleno()
lyH1.control(self.cbChance).relleno()
lyH1.control(btTutorChange).relleno()
# lyV1 = Colocacion.V().control(gbThoughtOp)
lyH3 = Colocacion.H().relleno()
lyH3.control(gbThoughtOp).relleno()
lyH3.control(gbThoughtTt).relleno()
ly = Colocacion.V().otro(lyH1).otro(lyH3).control(
self.chbSummary).margen(16)
gb = Controles.GB(self, "", ly)
tab.nuevaTab(gb, _("Help configuration"))
# TAB Tiempo
lyG = nuevoG()
self.edMinutos, self.lbMinutos = QTUtil2.spinBoxLB(
self, 15, 0, 999, maxTam=50, etiqueta=_("Total minutes"))
self.edSegundos, self.lbSegundos = QTUtil2.spinBoxLB(
self,
6,
-999,
999,
maxTam=54,
etiqueta=_("Seconds added per move"))
self.edMinExtra, self.lbMinExtra = QTUtil2.spinBoxLB(
self,
0,
-999,
999,
maxTam=70,
etiqueta=_("Extra minutes for the player"))
self.edZeitnot, self.lbZeitnot = QTUtil2.spinBoxLB(
self,
0,
-999,
999,
maxTam=54,
etiqueta=_("Zeitnot: alarm sounds when remaining seconds"))
lyH1 = Colocacion.H()
lyH1.control(self.lbMinutos).control(self.edMinutos).espacio(30)
lyH1.control(self.lbSegundos).control(self.edSegundos).relleno()
lyH2 = Colocacion.H()
lyH2.control(self.lbMinExtra).control(self.edMinExtra).relleno()
lyH3 = Colocacion.H()
lyH3.control(self.lbZeitnot).control(self.edZeitnot).relleno()
ly = Colocacion.V().otro(lyH1).otro(lyH2).otro(lyH3)
self.chbTiempo = _label(lyG, _("Time"), ly, siCheck=True)
gb = Controles.GB(self, "", lyG)
tab.nuevaTab(gb, _("Time"))
# TAB Initial moves
lyG = nuevoG()
# Posicion
self.btPosicion = Controles.PB(self, " " * 5 + _("Change") + " " * 5,
self.posicionEditar).ponPlano(False)
self.fen = ""
self.btPosicionQuitar = Controles.PB(
self, "", self.posicionQuitar).ponIcono(Iconos.Motor_No())
self.btPosicionPegar = Controles.PB(self, "",
self.posicionPegar).ponIcono(
Iconos.Pegar16()).ponToolTip(
_("Paste FEN position"))
hbox = Colocacion.H().relleno().control(self.btPosicionQuitar).control(
self.btPosicion).control(self.btPosicionPegar).relleno()
_label(lyG, _("Start position"), hbox)
# Aperturas
self.btApertura = Controles.PB(self,
" " * 5 + _("Undetermined") + " " * 5,
self.editarApertura).ponPlano(False)
self.bloqueApertura = None
self.btAperturasFavoritas = Controles.PB(
self, "", self.aperturasFavoritas).ponIcono(Iconos.Favoritos())
self.btAperturasQuitar = Controles.PB(
self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = Colocacion.H().relleno().control(
self.btAperturasQuitar).control(self.btApertura).control(
self.btAperturasFavoritas).relleno()
_label(lyG, _("Opening"), hbox)
# Libros
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.recuperaVar(fvar)
# Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.nombre, x) for x in self.listaLibros.lista]
libInicial = li[0][1] if li else None
self.cbBooks = QTUtil2.comboBoxLB(self, li, libInicial)
self.btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=True).ponIcono(Iconos.Mas(),
tamIcon=16)
self.chbBookMandatory = Controles.CHB(self, _("Mandatory"), False)
# Respuesta rival
li = (
(_("Selected by the player"), "su"),
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
)
self.cbBooksRR = QTUtil2.comboBoxLB(self, li, "mp")
self.lbBooksRR = Controles.LB2P(self, _("Opponent's move"))
hbox = Colocacion.H().relleno().control(self.cbBooks).control(
self.btNuevoBook).control(self.chbBookMandatory).relleno()
hboxRR = Colocacion.H().relleno().control(self.lbBooksRR).control(
self.cbBooksRR).relleno()
hboxV = Colocacion.V().otro(hbox).otro(hboxRR)
self.chbBook = _label(lyG, _("Book"), hboxV, siCheck=True)
ly = Colocacion.V().otro(lyG).relleno()
gb = Controles.GB(self, "", ly)
tab.nuevaTab(gb, _("Initial moves"))
layout = Colocacion.V().control(tb).control(tab).relleno().margen(3)
self.setLayout(layout)
self.liAperturasFavoritas = []
self.btAperturasFavoritas.hide()
dic = Util.recuperaDIC(self.configuracion.ficheroEntMaquina)
if not dic:
dic = {}
self.muestraDic(dic)
self.ajustesCambiado()
# self.ayudasCambiado()
self.ponRival()
self.recuperarVideo()
def __init__(self, procesador, titulo, save_at_end):
QTVarios.WDialogo.__init__(self, procesador.main_window, titulo, Iconos.Libre(), "entMaquina")
font = Controles.TipoLetra(puntos=procesador.configuracion.x_menu_points)
self.save_at_end = save_at_end
self.setFont(font)
self.configuracion = procesador.configuracion
self.procesador = procesador
self.personalidades = Personalidades.Personalidades(self, self.configuracion)
self.motores = SelectEngines.SelectEngines(self.configuracion)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Configurations"), Iconos.Configurar(), self.configuraciones),
None,
]
tb = QTVarios.LCTB(self, li_acciones)
# Tab
tab = Controles.Tab()
tab.dispatchChange(self.cambiada_tab)
self.tab_advanced = 4 # está en la posición 4
self.tab_advanced_active = (
False
) # Para no tener que leer las opciones uci to_sq que no sean necesarias, afecta a gridNumDatos
def nueva_tab(layout, titulo):
ly = Colocacion.V()
ly.otro(layout)
ly.relleno()
w = QtWidgets.QWidget(self)
w.setLayout(ly)
w.setFont(font)
tab.nuevaTab(w, titulo)
def nuevoG():
ly_g = Colocacion.G()
ly_g.filaActual = 0
ly_g.setMargin(10)
return ly_g
gbStyle = """
QGroupBox {
font: bold 16px;
background-color: #F2F2EC;/*qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E0E0E0, stop: 1 #FFFFFF);*/
border: 1px solid gray;
border-radius: 3px;
padding: 18px;
margin-top: 5ex; /* leave space at the top for the title */
}
QGroupBox::title {
subcontrol-origin: margin;
subcontrol-position: top left; /* position at the top center */
padding: 8px;
border: 1px solid gray;
}
"""
def _label(ly_g, txt, xlayout, rutinaCHB=None, siCheck: object = False):
groupbox = Controles.GB(self, txt, xlayout)
if rutinaCHB:
groupbox.conectar(rutinaCHB)
elif siCheck:
groupbox.setCheckable(True)
groupbox.setChecked(False)
groupbox.setStyleSheet(gbStyle)
groupbox.setMinimumWidth(640)
groupbox.setFont(font)
ly_g.controlc(groupbox, ly_g.filaActual, 0)
ly_g.filaActual += 1
return groupbox
# ##################################################################################################################################
# TAB General
# ##################################################################################################################################
lyG = nuevoG()
# # Motores
# ## Rival
self.rival = self.procesador.XTutor().confMotor
self.rivalTipo = SelectEngines.INTERNO
self.btRival = Controles.PB(self, "", self.cambiaRival, plano=False).ponFuente(font).altoFijo(48)
lbTiempoSegundosR = Controles.LB2P(self, _("Fixed time in seconds")).ponFuente(font)
self.edRtiempo = (
Controles.ED(self).tipoFloat().anchoMaximo(50).ponFuente(font).capturaCambiado(self.cambiadoTiempo)
)
bt_cancelar_tiempo = Controles.PB(self, "", rutina=self.cancelar_tiempo).ponIcono(Iconos.S_Cancelar())
ly_tiempo = Colocacion.H().control(self.edRtiempo).control(bt_cancelar_tiempo).relleno(1)
lb_depth = Controles.LB2P(self, _("Fixed depth")).ponFuente(font)
self.edRdepth = Controles.ED(self).tipoInt().anchoMaximo(50).ponFuente(font).capturaCambiado(self.cambiadoDepth)
bt_cancelar_depth = Controles.PB(self, "", rutina=self.cancelar_depth).ponIcono(Iconos.S_Cancelar())
ly_depth = Colocacion.H().control(self.edRdepth).control(bt_cancelar_depth).relleno(1)
ly = Colocacion.G()
ly.controld(lbTiempoSegundosR, 0, 0).otro(ly_tiempo, 0, 1)
ly.controld(lb_depth, 1, 0).otro(ly_depth, 1, 1)
self.gb_thinks = Controles.GB(self, _("Limits of engine thinking"), ly)
self.gb_thinks.setStyleSheet(
"""
QGroupBox {
font: bold %d;
background-color: #F2F2EC;/*qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E0E0E0, stop: 1 #FFFFFF);*/
border: 1px solid gray;
border-radius: 3px;
padding: 18px;
margin-top: 5ex; /* leave space at the top for the title */
}
QGroupBox::title {
subcontrol-position: top center; /* position at the top center */
padding: 8px;
border: 1px solid gray;
}
"""
% procesador.configuracion.x_menu_points
)
lyV = Colocacion.V().espacio(20).control(self.btRival).espacio(20).control(self.gb_thinks)
_label(lyG, _("Opponent"), lyV)
# # Color
self.rbBlancas = Controles.RB(self, "").activa()
self.rbBlancas.setIcon(Iconos.PeonBlanco())
self.rbBlancas.setIconSize(QtCore.QSize(32, 32))
self.rbNegras = Controles.RB(self, "")
self.rbNegras.setIcon(Iconos.PeonNegro())
self.rbNegras.setIconSize(QtCore.QSize(32, 32))
self.rbRandom = Controles.RB(self, _("Random"))
self.rbRandom.setFont(Controles.TipoLetra(puntos=16))
hbox = (
Colocacion.H()
.relleno()
.control(self.rbBlancas)
.espacio(30)
.control(self.rbNegras)
.espacio(30)
.control(self.rbRandom)
.relleno()
)
_label(lyG, _("Side you play with"), hbox)
nueva_tab(lyG, _("Basic configuration"))
# ##################################################################################################################################
# TAB Ayudas
# ##################################################################################################################################
self.chbSummary = Controles.CHB(
self, _("Save a summary when the game is finished in the main comment"), False
).ponFuente(font)
self.chbTakeback = Controles.CHB(
self, _("Option takeback activated"), True
).ponFuente(font)
# # Tutor
lbAyudas = Controles.LB2P(self, _("Available hints")).ponFuente(font)
liAyudas = [(_("Maximum"), 999)]
for i in range(1, 21):
liAyudas.append((str(i), i))
for i in range(25, 51, 5):
liAyudas.append((str(i), i))
self.cbAyudas = Controles.CB(self, liAyudas, 999).ponFuente(font)
self.chbChance = Controles.CHB(self, _("Second chance"), True).ponFuente(font)
btTutorChange = (
Controles.PB(self, _("Tutor change"), self.tutorChange, plano=False)
.ponIcono(Iconos.Tutor(), tamIcon=16)
.ponFuente(font)
)
liThinks = [(_("Nothing"), -1), (_("Score"), 0)]
for i in range(1, 5):
liThinks.append(("%d %s" % (i, _("ply") if i == 1 else _("plies")), i))
liThinks.append((_("All"), 9999))
lbThoughtTt = Controles.LB(self, _("It is showed") + ":").ponFuente(font)
self.cbThoughtTt = Controles.CB(self, liThinks, -1).ponFuente(font)
self.chbContinueTt = Controles.CHB(self, _("The tutor thinks while you think"), True).ponFuente(font)
lbBoxHeight = Controles.LB2P(self, _("Box height")).ponFuente(font)
self.sbBoxHeight = Controles.SB(self, 7, 0, 999).tamMaximo(50).ponFuente(font)
lbArrows = Controles.LB2P(self, _("Arrows with the best moves")).ponFuente(font)
self.sbArrowsTt = Controles.SB(self, 3, 0, 999).tamMaximo(50).ponFuente(font)
lyT1 = Colocacion.H().control(lbAyudas).control(self.cbAyudas).relleno()
lyT1.control(self.chbChance).relleno().control(btTutorChange)
lyT2 = Colocacion.H().control(self.chbContinueTt).relleno()
lyT2.control(lbBoxHeight).control(self.sbBoxHeight).relleno()
lyT3 = Colocacion.H().control(lbThoughtTt).control(self.cbThoughtTt).relleno()
lyT3.control(lbArrows).control(self.sbArrowsTt)
ly = Colocacion.V().otro(lyT1).espacio(16).otro(lyT2).otro(lyT3).relleno()
self.gbTutor = Controles.GB(self, _("Activate the tutor's help"), ly)
self.gbTutor.setCheckable(True)
self.gbTutor.setStyleSheet(gbStyle)
lb = Controles.LB(self, _("It is showed") + ":").ponFuente(font)
self.cbThoughtOp = Controles.CB(self, liThinks, -1).ponFuente(font)
lbArrows = Controles.LB2P(self, _("Arrows to show")).ponFuente(font)
self.sbArrows = Controles.SB(self, 7, 0, 999).tamMaximo(50).ponFuente(font)
ly = Colocacion.H().control(lb).control(self.cbThoughtOp).relleno()
ly.control(lbArrows).control(self.sbArrows).relleno()
gbThoughtOp = Controles.GB(self, _("Opponent's thought information"), ly)
gbThoughtOp.setStyleSheet(gbStyle)
ly = Colocacion.V().espacio(16).control(self.gbTutor).control(gbThoughtOp)
ly.espacio(16).control(self.chbSummary).control(self.chbTakeback).margen(6)
nueva_tab(ly, _("Help configuration"))
# ##################################################################################################################################
# TAB Tiempo
# ##################################################################################################################################
lyG = nuevoG()
self.lbMinutos = Controles.LB(self, _("Total minutes") + ":").ponFuente(font)
self.edMinutos = Controles.ED(self).tipoFloat(10.0).ponFuente(font).anchoFijo(50)
self.edSegundos, self.lbSegundos = QTUtil2.spinBoxLB(
self, 6, -999, 999, maxTam=54, etiqueta=_("Seconds added per move"), fuente=font
)
self.edMinExtra, self.lbMinExtra = QTUtil2.spinBoxLB(
self, 0, -999, 999, maxTam=70, etiqueta=_("Extra minutes for the player"), fuente=font
)
self.edZeitnot, self.lbZeitnot = QTUtil2.spinBoxLB(
self, 0, -999, 999, maxTam=54, etiqueta=_("Zeitnot: alarm sounds when remaining seconds"), fuente=font
)
lyH = Colocacion.H()
lyH.control(self.lbMinutos).control(self.edMinutos).espacio(30)
lyH.control(self.lbSegundos).control(self.edSegundos).relleno()
lyH2 = Colocacion.H()
lyH2.control(self.lbMinExtra).control(self.edMinExtra).relleno()
lyH3 = Colocacion.H()
lyH3.control(self.lbZeitnot).control(self.edZeitnot).relleno()
ly = Colocacion.V().otro(lyH).otro(lyH2).otro(lyH3)
self.chbTiempo = _label(lyG, _("Activate the time control"), ly, siCheck=True)
nueva_tab(lyG, _("Time"))
# ##################################################################################################################################
# TAB Initial moves
# ##################################################################################################################################
lyG = nuevoG()
# Posicion
self.btPosicion = (
Controles.PB(self, " " * 5 + _("Change") + " " * 5, self.posicionEditar).ponPlano(False).ponFuente(font)
)
self.fen = ""
self.btPosicionQuitar = Controles.PB(self, "", self.posicionQuitar).ponIcono(Iconos.Motor_No()).ponFuente(font)
self.btPosicionPegar = (
Controles.PB(self, "", self.posicionPegar).ponIcono(Iconos.Pegar16()).ponToolTip(_("Paste FEN position"))
).ponFuente(font)
hbox = (
Colocacion.H()
.relleno()
.control(self.btPosicionQuitar)
.control(self.btPosicion)
.control(self.btPosicionPegar)
.relleno()
)
_label(lyG, _("Start position"), hbox)
# Aperturas
self.btApertura = (
Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.editarApertura)
.ponPlano(False)
.ponFuente(font)
)
self.bloqueApertura = None
self.btAperturasFavoritas = Controles.PB(self, "", self.aperturasFavoritas).ponIcono(Iconos.Favoritos())
self.btAperturasQuitar = Controles.PB(self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = (
Colocacion.H()
.relleno()
.control(self.btAperturasQuitar)
.control(self.btApertura)
.control(self.btAperturasFavoritas)
.relleno()
)
_label(lyG, _("Opening"), hbox)
# Libros
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
self.listaLibros.comprueba()
li_books = [(x.name, x) for x in self.listaLibros.lista]
libInicial = li_books[0][1] if li_books else None
li_resp_book = [
(_("Selected by the player"), "su"),
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
]
## Rival
self.cbBooksR = QTUtil2.comboBoxLB(self, li_books, libInicial).ponFuente(font)
self.btNuevoBookR = Controles.PB(self, "", self.nuevoBook, plano=True).ponIcono(Iconos.Mas(), tamIcon=16)
self.cbBooksRR = QTUtil2.comboBoxLB(self, li_resp_book, "mp").ponFuente(font)
self.lbDepthBookR = Controles.LB2P(self, _("Max depth")).ponFuente(font)
self.edDepthBookR = Controles.ED(self).ponFuente(font).tipoInt(0).anchoFijo(30)
hbox = (
Colocacion.H()
.control(self.cbBooksR)
.control(self.btNuevoBookR)
.relleno()
.control(self.cbBooksRR)
.relleno()
.control(self.lbDepthBookR)
.control(self.edDepthBookR)
)
self.chbBookR = _label(lyG, "%s: %s" % (_("Activate book"), _("Opponent")), hbox, siCheck=True)
## Player
self.cbBooksP = QTUtil2.comboBoxLB(self, li_books, libInicial).ponFuente(font)
self.btNuevoBookP = Controles.PB(self, "", self.nuevoBook, plano=True).ponIcono(Iconos.Mas(), tamIcon=16)
self.lbDepthBookP = Controles.LB2P(self, _("Max depth")).ponFuente(font)
self.edDepthBookP = Controles.ED(self).ponFuente(font).tipoInt(0).anchoFijo(30)
hbox = (
Colocacion.H()
.control(self.cbBooksP)
.control(self.btNuevoBookP)
.relleno()
.control(self.lbDepthBookP)
.control(self.edDepthBookP)
)
self.chbBookP = _label(
lyG, "%s: %s" % (_("Activate book"), self.configuracion.nom_player()), hbox, siCheck=True
)
nueva_tab(lyG, _("Initial moves"))
# ##################################################################################################################################
# TAB avanzada
# ##################################################################################################################################
lyG = nuevoG()
liAjustes = self.personalidades.listaAjustes(True)
self.cbAjustarRival = (
Controles.CB(self, liAjustes, ADJUST_BETTER).capturaCambiado(self.ajustesCambiado).ponFuente(font)
)
lbAjustarRival = Controles.LB2P(self, _("Set strength")).ponFuente(font)
self.btAjustarRival = (
Controles.PB(self, _("Personality"), self.cambiaPersonalidades, plano=True)
.ponIcono(Iconos.Mas(), tamIcon=16)
.ponFuente(font)
)
# ## Resign
lbResign = Controles.LB2P(self, _("Resign/draw by engine")).ponFuente(font)
liResign = (
(_("Very early"), -100),
(_("Early"), -300),
(_("Average"), -500),
(_("Late"), -800),
(_("Very late"), -1000),
(_("Never"), -9999999),
)
self.cbResign = Controles.CB(self, liResign, -800).ponFuente(font)
self.lb_path_engine = Controles.LB(self, "").ponWrap()
o_columns = Columnas.ListaColumnas()
o_columns.nueva("OPTION", _("UCI option"), 240, centered=True)
o_columns.nueva("VALUE", _("Value"), 200, centered=True, edicion=Delegados.MultiEditor(self))
self.grid_uci = Grid.Grid(self, o_columns, siEditable=True)
self.grid_uci.ponFuente(font)
self.register_grid(self.grid_uci)
lyH2 = (
Colocacion.H().control(lbAjustarRival).control(self.cbAjustarRival).control(self.btAjustarRival).relleno()
)
lyH3 = Colocacion.H().control(lbResign).control(self.cbResign).relleno()
ly = Colocacion.V().otro(lyH2).otro(lyH3).espacio(16).control(self.lb_path_engine).control(self.grid_uci)
_label(lyG, _("Opponent"), ly)
nueva_tab(lyG, _("Advanced"))
layout = Colocacion.V().control(tb).control(tab).relleno().margen(3)
self.setLayout(layout)
self.liAperturasFavoritas = []
self.btAperturasFavoritas.hide()
dic = Util.restore_pickle(self.configuracion.ficheroEntMaquina)
if not dic:
dic = {}
self.restore_dic(dic)
self.ajustesCambiado()
# self.ayudasCambiado()
self.ponRival()
self.restore_video()
def __init__(self, procesador):
self.configuration = procesador.configuration
self.procesador = procesador
self.db_histo = UtilSQL.DictSQL(self.configuration.ficheroGMhisto)
self.opening_block = None
self.li_preferred_openings = []
w_parent = procesador.main_window
titulo = _("Play like a Grandmaster")
icono = Iconos.GranMaestro()
extparam = "gm"
QTVarios.WDialogo.__init__(self, w_parent, titulo, icono, extparam)
flb = Controles.TipoLetra(puntos=procesador.configuration.x_menu_points)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("One game"), Iconos.Uno(), self.unJuego),
None,
(_("Import"), Iconos.ImportarGM(), self.importar),
]
tb = Controles.TBrutina(self, li_acciones)
# Grandes maestros
self.li_gm = GM.lista_gm()
gb_style = Common.gb_style()
li = [(x[0], x[1]) for x in self.li_gm]
li.insert(0, ("-", None))
self.cb_gm = QTUtil2.comboBoxLB(self, li, li[0][1] if len(self.li_gm) == 0 else li[1][1])
self.cb_gm.capture_changes(self.check_gm)
hbox = Colocacion.H().relleno().control(self.cb_gm).relleno()
gbGM = Controles.GB(self, _("Choose a Grandmaster"), hbox).ponFuente(flb)
gbGM.setStyleSheet(gb_style)
# Personales
self.li_personal = GM.lista_gm_personal(self.procesador.configuration.personal_training_folder)
if self.li_personal:
li = [(x[0], x[1]) for x in self.li_personal]
li.insert(0, ("-", None))
self.cbPersonal = QTUtil2.comboBoxLB(self, li, li[0][1])
self.cbPersonal.capture_changes(self.check_personal)
btBorrar = Controles.PB(self, "", self.borrarPersonal).ponIcono(Iconos.Borrar(), icon_size=24)
hbox = Colocacion.H().relleno().control(self.cbPersonal).control(btBorrar).relleno()
gb_personal = Controles.GB(self, _("Personal games"), hbox).ponFuente(flb)
gb_personal.setStyleSheet(gb_style)
# Color
self.rb_white = Controles.RB(self, _("White"), rutina=self.check_color)
self.rb_white.setFont(flb)
self.rb_white.activa(True)
self.rb_black = Controles.RB(self, _("Black"), rutina=self.check_color)
self.rb_black.setFont(flb)
self.rb_black.activa(False)
# Contrario
self.chContrario = Controles.CHB(self, _("Choose the opponent's move, when there are multiple possible answers"), False)
# Juez
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
self.liMotores = self.configuration.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(self, self.liMotores, self.configuration.tutor_inicial, _("Engine"))
self.edJtiempo = Controles.ED(self).tipoFloat().ponFloat(1.0).anchoFijo(50)
self.lbJtiempo = Controles.LB2P(self, _("Time in seconds"))
self.cbJdepth = Controles.CB(self, liDepths, 0).capture_changes(self.change_depth)
self.lbJdepth = Controles.LB2P(self, _("Depth"))
self.lbJshow = Controles.LB2P(self, _("Show rating"))
self.chbEvals = Controles.CHB(self, _("Show all evaluations"), False)
li_options = [(_("All moves"), None), (_("Moves are different"), True), (_("Never"), False)]
self.cbJshow = Controles.CB(self, li_options, True)
self.lbJmultiPV = Controles.LB2P(self, _("Number of moves evaluated by engine(MultiPV)"))
li = [(_("Default"), "PD"), (_("Maximum"), "MX")]
for x in (1, 3, 5, 10, 15, 20, 30, 40, 50, 75, 100, 150, 200):
li.append((str(x), str(x)))
self.cbJmultiPV = Controles.CB(self, li, "PD")
self.li_adjudicator_controls = (
self.cbJmotor,
self.lbJmotor,
self.edJtiempo,
self.lbJtiempo,
self.lbJdepth,
self.cbJdepth,
self.lbJshow,
self.cbJshow,
self.lbJmultiPV,
self.cbJmultiPV,
self.chbEvals,
)
for control in self.li_adjudicator_controls:
control.setFont(flb)
# Inicial
self.edJugInicial, lbInicial = QTUtil2.spinBoxLB(self, 1, 1, 99, etiqueta=_("Initial move"), maxTam=40)
# Libros
fvar = self.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.restore_pickle(fvar)
# # Comprobamos que todos esten accesibles
self.list_books.check()
li = [(x.name, x) for x in self.list_books.lista]
li.insert(0, ("--", None))
self.cbBooks, lbBooks = QTUtil2.comboBoxLB(self, li, None, _("Bypass moves in the book"))
# Openings
self.btOpening = Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.aperturasEditar).ponPlano(False)
self.btOpeningsFavoritas = Controles.PB(self, "", self.preferred_openings).ponIcono(Iconos.Favoritos())
self.btOpeningsQuitar = Controles.PB(self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = Colocacion.H().control(self.btOpeningsQuitar).control(self.btOpening).control(self.btOpeningsFavoritas).relleno()
gbOpening = Controles.GB(self, _("Opening"), hbox)
# gbBasic
# # Color
hbox = Colocacion.H().relleno().control(self.rb_white).espacio(10).control(self.rb_black).relleno()
gbColor = Controles.GB(self, _("Play with"), hbox).ponFuente(flb)
gbColor.setStyleSheet(gb_style)
# Tiempo
ly1 = Colocacion.H().control(self.lbJmotor).control(self.cbJmotor).relleno().control(self.lbJshow).control(self.cbJshow)
ly2 = Colocacion.H().control(self.lbJtiempo).control(self.edJtiempo)
ly2.control(self.lbJdepth).control(self.cbJdepth).relleno().control(self.chbEvals)
ly3 = Colocacion.H().control(self.lbJmultiPV).control(self.cbJmultiPV).relleno()
ly = Colocacion.V().otro(ly1).otro(ly2).otro(ly3)
self.gbJ = Controles.GB(self, _("Adjudicator"), ly).to_connect(self.change_adjudicator)
self.gbJ.setStyleSheet(gb_style)
# Opciones
vlayout = Colocacion.V().control(gbColor)
vlayout.espacio(5).control(self.gbJ)
vlayout.margen(20)
gbBasic = Controles.GB(self, "", vlayout)
gbBasic.setFlat(True)
# Opciones avanzadas
lyInicial = Colocacion.H().control(lbInicial).control(self.edJugInicial).relleno().control(lbBooks).control(self.cbBooks).relleno()
vlayout = Colocacion.V().otro(lyInicial).control(gbOpening)
vlayout.espacio(5).control(self.chContrario).margen(20).relleno()
gbAdvanced = Controles.GB(self, "", vlayout)
gbAdvanced.setFlat(True)
# Historico
self.liHisto = []
o_columns = Columnas.ListaColumnas()
o_columns.nueva("FECHA", _("Date"), 100, centered=True)
o_columns.nueva("PACIERTOS", _("Hints"), 90, centered=True)
o_columns.nueva("PUNTOS", _("Points accumulated"), 140, centered=True)
o_columns.nueva("ENGINE", _("Adjudicator"), 100, centered=True)
o_columns.nueva("RESUMEN", _("Game played"), 280)
self.grid = grid = Grid.Grid(self, o_columns, siSelecFilas=True, background=None)
self.grid.coloresAlternados()
self.register_grid(grid)
# Tabs
self.tab = Controles.Tab().set_position("S")
self.tab.nuevaTab(gbBasic, _("Basic"))
self.tab.nuevaTab(gbAdvanced, _("Advanced"))
self.tab.nuevaTab(self.grid, _("Track record"))
self.tab.setFont(flb)
# Cabecera
lyCab = Colocacion.H().control(gbGM)
if self.li_personal:
lyCab.control(gb_personal)
layout = Colocacion.V().control(tb).otro(lyCab).control(self.tab).margen(6)
self.setLayout(layout)
self.restore_dic()
self.change_adjudicator()
self.check_gm()
self.check_personal()
self.check_histo()
self.aperturaMuestra()
self.btOpeningsFavoritas.hide()
self.restore_video(anchoDefecto=750)
def __init__(self, owner, tactica, ncopia=None):
QtWidgets.QWidget.__init__(self)
self.owner = owner
self.tacticaINI = tactica
if ncopia is not None:
reg_historico = tactica.historico()[ncopia]
else:
reg_historico = None
# Total por ficheros
self.liFTOTAL = tactica.calculaTotales()
total = sum(self.liFTOTAL)
# N. puzzles
if reg_historico:
num = reg_historico["PUZZLES"]
else:
num = tactica.puzzles
if not num or num > total:
num = total
lb_puzzles = Controles.LB(self, _("Max number of puzzles in each block") + ": ")
self.sb_puzzles = Controles.SB(self, num, 1, total)
# Reference
lb_reference = Controles.LB(self, _("Reference") + ": ")
self.ed_reference = Controles.ED(self)
# Iconos
ico_mas = Iconos.Add()
ico_menos = Iconos.Delete()
ico_cancel = Iconos.CancelarPeque()
ico_reset = Iconos.MoverAtras()
def tb_gen(prev):
li_acciones = (
(_("Add"), ico_mas, "%s_add" % prev),
(_("Delete"), ico_menos, "%s_delete" % prev),
None,
(_("Delete all"), ico_cancel, "%s_delete_all" % prev),
None,
(_("Reset"), ico_reset, "%s_reset" % prev),
None,
)
tb = Controles.TB(self, li_acciones, icon_size=16, with_text=False)
return tb
f = Controles.TipoLetra(peso=75)
# Repeticiones de cada puzzle
if reg_historico:
self.liJUMPS = reg_historico["JUMPS"][:]
else:
self.liJUMPS = tactica.jumps[:]
tb = tb_gen("jumps")
o_col = Columnas.ListaColumnas()
o_col.nueva("NUMBER", _("Repetition"), 80, centered=True)
o_col.nueva("JUMPS_SEPARATION", _("Separation"), 80, centered=True, edicion=Delegados.LineaTexto(siEntero=True))
self.grid_jumps = Grid.Grid(self, o_col, siSelecFilas=True, siEditable=True, xid="j")
self.grid_jumps.setMinimumWidth(self.grid_jumps.anchoColumnas() + 20)
ly = Colocacion.V().control(tb).control(self.grid_jumps)
gb_jumps = Controles.GB(self, _("Repetitions of each puzzle"), ly).ponFuente(f)
self.grid_jumps.gotop()
# Repeticion del bloque
if reg_historico:
self.liREPEAT = reg_historico["REPEAT"][:]
else:
self.liREPEAT = tactica.repeat[:]
tb = tb_gen("repeat")
o_col = Columnas.ListaColumnas()
o_col.nueva("NUMBER", _("Block"), 40, centered=True)
self.liREPEATtxt = (_("Original"), _("Random"), _("Previous"))
o_col.nueva("REPEAT_ORDER", _("Order"), 100, centered=True, edicion=Delegados.ComboBox(self.liREPEATtxt))
self.grid_repeat = Grid.Grid(self, o_col, siSelecFilas=True, siEditable=True, xid="r")
self.grid_repeat.setMinimumWidth(self.grid_repeat.anchoColumnas() + 20)
ly = Colocacion.V().control(tb).control(self.grid_repeat)
gb_repeat = Controles.GB(self, _("Blocks"), ly).ponFuente(f)
self.grid_repeat.gotop()
# Penalizaciones
if reg_historico:
self.liPENAL = reg_historico["PENALIZATION"][:]
else:
self.liPENAL = tactica.penalization[:]
tb = tb_gen("penal")
o_col = Columnas.ListaColumnas()
o_col.nueva("NUMBER", _("N."), 20, centered=True)
o_col.nueva("PENAL_POSITIONS", _("Positions"), 100, centered=True, edicion=Delegados.LineaTexto(siEntero=True))
o_col.nueva("PENAL_%", _("Affected"), 100, centered=True)
self.grid_penal = Grid.Grid(self, o_col, siSelecFilas=True, siEditable=True, xid="p")
self.grid_penal.setMinimumWidth(self.grid_penal.anchoColumnas() + 20)
ly = Colocacion.V().control(tb).control(self.grid_penal)
gb_penal = Controles.GB(self, _("Penalties"), ly).ponFuente(f)
self.grid_penal.gotop()
# ShowText
if reg_historico:
self.liSHOWTEXT = reg_historico["SHOWTEXT"][:]
else:
self.liSHOWTEXT = tactica.showtext[:]
tb = tb_gen("show")
o_col = Columnas.ListaColumnas()
self.liSHOWTEXTtxt = (_("No"), _("Yes"))
o_col.nueva("NUMBER", _("N."), 20, centered=True)
o_col.nueva("SHOW_VISIBLE", _("Visible"), 100, centered=True, edicion=Delegados.ComboBox(self.liSHOWTEXTtxt))
o_col.nueva("SHOW_%", _("Affected"), 100, centered=True)
self.grid_show = Grid.Grid(self, o_col, siSelecFilas=True, siEditable=True, xid="s")
self.grid_show.setMinimumWidth(self.grid_show.anchoColumnas() + 20)
ly = Colocacion.V().control(tb).control(self.grid_show)
gbShow = Controles.GB(self, _("Show text associated with each puzzle"), ly).ponFuente(f)
self.grid_show.gotop()
# Reinforcement
if reg_historico:
self.reinforcement_errors = reg_historico["REINFORCEMENT_ERRORS"]
self.reinforcement_cycles = reg_historico["REINFORCEMENT_CYCLES"]
else:
self.reinforcement_errors = tactica.reinforcement_errors
self.reinforcement_cycles = tactica.reinforcement_cycles
lb_r_errors = Controles.LB(self, _("Accumulated errors to launch reinforcement") + ": ")
li_opciones = [(_("Disable"), 0), ("5", 5), ("10", 10), ("15", 15), ("20", 20)]
self.cb_reinf_errors = Controles.CB(self, li_opciones, self.reinforcement_errors)
lb_r_cycles = Controles.LB(self, _("Cycles") + ": ")
self.sb_reinf_cycles = Controles.SB(self, self.reinforcement_cycles, 1, 10)
ly = (
Colocacion.H()
.control(lb_r_errors)
.control(self.cb_reinf_errors)
.espacio(30)
.control(lb_r_cycles)
.control(self.sb_reinf_cycles)
)
gb_reinforcement = Controles.GB(self, _("Reinforcement"), ly).ponFuente(f)
# Files
if reg_historico:
self.liFILES = reg_historico["FILESW"][:]
else:
self.liFILES = []
for num, (fich, w, d, h) in enumerate(tactica.filesw):
if not d or d < 1:
d = 1
if not h or h > self.liFTOTAL[num] or h < 1:
h = self.liFTOTAL[num]
if d > h:
d, h = h, d
self.liFILES.append([fich, w, d, h])
o_col = Columnas.ListaColumnas()
o_col.nueva("FILE", _("File"), 220, centered=True)
o_col.nueva("WEIGHT", _("Weight"), 100, centered=True, edicion=Delegados.LineaTexto(siEntero=True))
o_col.nueva("TOTAL", _("Total"), 100, centered=True)
o_col.nueva("FROM", _("From"), 100, centered=True, edicion=Delegados.LineaTexto(siEntero=True))
o_col.nueva("TO", _("To"), 100, centered=True, edicion=Delegados.LineaTexto(siEntero=True))
self.grid_files = Grid.Grid(self, o_col, siSelecFilas=True, siEditable=True, xid="f")
self.grid_files.setMinimumWidth(self.grid_files.anchoColumnas() + 20)
ly = Colocacion.V().control(self.grid_files)
gb_files = Controles.GB(self, _("FNS files"), ly).ponFuente(f)
self.grid_files.gotop()
# Layout
ly_reference = Colocacion.H().control(lb_reference).control(self.ed_reference)
ly_puzzles = Colocacion.H().control(lb_puzzles).control(self.sb_puzzles)
ly = Colocacion.G()
ly.otro(ly_puzzles, 0, 0).otro(ly_reference, 0, 1)
ly.filaVacia(1, 5)
ly.controld(gb_jumps, 2, 0).control(gb_penal, 2, 1)
ly.filaVacia(3, 5)
ly.controld(gb_repeat, 4, 0)
ly.control(gbShow, 4, 1)
ly.filaVacia(5, 5)
ly.control(gb_reinforcement, 6, 0, 1, 2)
ly.filaVacia(6, 5)
ly.control(gb_files, 7, 0, 1, 2)
layout = Colocacion.V().espacio(10).otro(ly)
self.setLayout(layout)
self.grid_repeat.gotop()
def __init__(self, wParent, o_columns, liFiltro, dbSaveNom=None):
super(WFiltrar, self).__init__()
if dbSaveNom is None:
dbSaveNom = Code.configuracion.ficheroFiltrosPGN
self.setWindowTitle(_("Filter"))
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint)
self.setWindowIcon(Iconos.Filtrar())
self.liFiltro = liFiltro
nFiltro = len(liFiltro)
self.dbSaveNom = dbSaveNom
li_fields = [(x.cabecera, '"%s"' % x.clave)
for x in o_columns.liColumnas
if x.clave != "number" and x.clave != "opening"]
li_fields.insert(0, ("", None))
liCondicion = [
("", None),
(_("Equal"), "="),
(_("Not equal"), "<>"),
(_("Greater than"), ">"),
(_("Less than"), "<"),
(_("Greater than or equal"), ">="),
(_("Less than or equal"), "<="),
(_("Like (wildcard = *)"), "LIKE"),
(_("Not like (wildcard = *)"), "NOT LIKE"),
]
liUnion = [("", None), (_("AND"), "AND"), (_("OR"), "OR")]
f = Controles.TipoLetra(puntos=12) # 0, peso=75 )
lbCol = Controles.LB(self, _("Column")).ponFuente(f)
lbPar0 = Controles.LB(self, "(").ponFuente(f)
lbPar1 = Controles.LB(self, ")").ponFuente(f)
lbCon = Controles.LB(self, _("Condition")).ponFuente(f)
lbVal = Controles.LB(self, _("Value")).ponFuente(f)
lbUni = Controles.LB(self, "+").ponFuente(f)
ly = Colocacion.G()
ly.controlc(lbUni, 0, 0).controlc(lbPar0, 0, 1).controlc(lbCol, 0, 2)
ly.controlc(lbCon, 0, 3).controlc(lbVal, 0, 4).controlc(lbPar1, 0, 5)
self.numC = 8
liC = []
union, par0, campo, condicion, valor, par1 = None, False, None, None, "", False
for i in range(self.numC):
if i > 0:
c_union = Controles.CB(self, liUnion, union)
ly.controlc(c_union, i + 1, 0)
else:
c_union = None
c_par0 = Controles.CHB(self, "", par0).anchoFijo(20)
ly.controlc(c_par0, i + 1, 1)
c_campo = Controles.CB(self, li_fields, campo)
ly.controlc(c_campo, i + 1, 2)
c_condicion = Controles.CB(self, liCondicion, condicion)
ly.controlc(c_condicion, i + 1, 3)
c_valor = Controles.ED(self, valor)
ly.controlc(c_valor, i + 1, 4)
c_par1 = Controles.CHB(self, "", par1).anchoFijo(20)
ly.controlc(c_par1, i + 1, 5)
liC.append(
(c_union, c_par0, c_campo, c_condicion, c_valor, c_par1))
self.liC = liC
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.reject),
None,
(_("Reinit"), Iconos.Reiniciar(), self.reiniciar),
None,
(_("Save/Restore"), Iconos.Grabar(), self.grabar),
None,
]
tb = QTVarios.LCTB(self, li_acciones)
# Layout
layout = Colocacion.V().control(tb).otro(ly).margen(3)
self.setLayout(layout)
liC[0][2].setFocus()
if nFiltro > 0:
self.lee_filtro(self.liFiltro)
def __init__(self, wparent, is_game, game):
self.game = game
self.position = game.first_position
self.configuration = configuration = Code.configuration
self.is_game = is_game
self.wparent = wparent
QtWidgets.QWidget.__init__(self, wparent)
li_acciones = (
(_("Save"), Iconos.GrabarComo(), self.save),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Start position"), Iconos.Inicio(), self.inicial),
None,
(_("Clear board"), Iconos.Borrar(), self.limpiaBoard),
(_("Paste FEN position"), Iconos.Pegar16(), self.pegar),
(_("Copy FEN position"), Iconos.Copiar(), self.copiar),
(_("Scanner"), Iconos.Scanner(), self.scanner),
)
self.tb = Controles.TBrutina(self,
li_acciones,
with_text=False,
icon_size=20)
config_board = configuration.config_board("VOYAGERPOS", 24)
self.board = Board.PosBoard(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.mueve)
self.board.mensBorrar = self.borraCasilla
self.board.mensCrear = self.creaCasilla
self.board.mensRepetir = self.repitePieza
self.board.ponDispatchDrop(self.dispatchDrop)
self.board.baseCasillasSC.setAcceptDrops(True)
dragDropWB = QTVarios.ListaPiezas(self,
"P,N,B,R,Q,K",
self.board,
margen=0)
dragDropBA = QTVarios.ListaPiezas(self,
"k,q,r,b,n,p",
self.board,
margen=0)
self.rbWhite = Controles.RB(self, _("White"), rutina=self.cambiaColor)
self.rbBlack = Controles.RB(self, _("Black"), rutina=self.cambiaColor)
self.cbWoo = Controles.CHB(self, _("White") + " O-O", True)
self.cbWooo = Controles.CHB(self, _("White") + " O-O-O", True)
self.cbBoo = Controles.CHB(self, _("Black") + " O-O", True)
self.cbBooo = Controles.CHB(self, _("Black") + " O-O-O", True)
lbEnPassant = Controles.LB(self, _("En passant") + ":")
self.edEnPassant = Controles.ED(self).controlrx(
"(-|[a-h][36])").anchoFijo(30)
self.edMovesPawn, lbMovesPawn = QTUtil2.spinBoxLB(
self, 0, 0, 999, etiqueta=_("Halfmove clock"), maxTam=50)
self.edFullMoves, lbFullMoves = QTUtil2.spinBoxLB(
self, 1, 1, 999, etiqueta=_("Fullmove number"), maxTam=50)
self.vars_scanner = Scanner.Scanner_vars(
self.configuration.carpetaScanners)
self.lb_scanner = Controles.LB(self)
pb_scanner_deduce = Controles.PB(self,
_("Deduce"),
self.scanner_deduce,
plano=False)
self.chb_scanner_flip = Controles.CHB(self, _("Flip the board"),
False).capture_changes(
self, self.scanner_flip)
self.pb_scanner_learn = Controles.PB(self,
_("Learn"),
self.scanner_learn,
plano=False)
self.pb_scanner_learn_quit = Controles.PB(
self, "", self.scanner_learn_quit).ponIcono(Iconos.Menos(),
icon_size=24)
self.pb_scanner_learn_quit.ponToolTip(
_("Remove last learned")).anchoFijo(24)
self.sb_scanner_tolerance, lb_scanner_tolerance = QTUtil2.spinBoxLB(
self,
self.vars_scanner.tolerance,
3,
20,
etiqueta=_("Deduction tolerance"),
maxTam=50)
self.sb_scanner_tolerance_learns, lb_scanner_tolerance_learns = QTUtil2.spinBoxLB(
self,
self.vars_scanner.tolerance_learns,
1,
6,
etiqueta=_("Learning tolerance"),
maxTam=50)
self.chb_rem_ghost_deductions = Controles.CHB(
self, _("Remove ghost deductions"), self.vars_scanner.rem_ghost)
self.cb_scanner_select, lb_scanner_select = QTUtil2.comboBoxLB(
self, [], None, _("OPR"))
self.cb_scanner_select.capture_changes(self.scanner_change)
pb_scanner_more = Controles.PB(self, "", self.scanner_more).ponIcono(
Iconos.Mas())
self.chb_scanner_ask = Controles.CHB(self, _("Ask before new capture"),
self.vars_scanner.ask)
self.li_scan_pch = []
self.is_scan_init = False
# LAYOUT -------------------------------------------------------------------------------------------
hbox = Colocacion.H().control(self.rbWhite).espacio(15).control(
self.rbBlack)
gbColor = Controles.GB(self, _("Side to play"), hbox)
ly = Colocacion.G().control(self.cbWoo, 0, 0).control(self.cbBoo, 0, 1)
ly.control(self.cbWooo, 1, 0).control(self.cbBooo, 1, 1)
gbEnroques = Controles.GB(self, _("Castling moves possible"), ly)
ly = Colocacion.G()
ly.controld(lbMovesPawn, 0, 0, 1, 3).control(self.edMovesPawn, 0, 3)
ly.controld(lbEnPassant, 1, 0).control(self.edEnPassant, 1, 1)
ly.controld(lbFullMoves, 1, 2).control(self.edFullMoves, 1, 3)
gbOtros = Controles.GB(self, "", ly)
lyT = (Colocacion.H().relleno().control(lb_scanner_tolerance).espacio(
5).control(self.sb_scanner_tolerance).relleno())
lyTL = (Colocacion.H().relleno().control(
lb_scanner_tolerance_learns).espacio(5).control(
self.sb_scanner_tolerance_learns).relleno())
lyL = Colocacion.H().control(self.pb_scanner_learn).control(
self.pb_scanner_learn_quit)
lyS = Colocacion.H().control(lb_scanner_select).control(
self.cb_scanner_select).control(pb_scanner_more)
ly = Colocacion.V().control(self.chb_scanner_flip).control(
pb_scanner_deduce).otro(lyL).otro(lyT).otro(lyTL)
ly.control(self.chb_rem_ghost_deductions).otro(lyS)
ly.control(self.chb_scanner_ask)
self.gb_scanner = Controles.GB(self, _("Scanner"), ly)
lyG = Colocacion.G()
lyG.controlc(dragDropBA, 0, 0)
lyG.control(self.board, 1, 0).control(self.lb_scanner, 1, 1)
lyG.controlc(dragDropWB, 2, 0).controlc(self.gb_scanner,
2,
1,
numFilas=4)
lyG.controlc(gbColor, 3, 0)
lyG.controlc(gbEnroques, 4, 0)
lyG.controlc(gbOtros, 5, 0)
layout = Colocacion.V()
layout.controlc(self.tb)
layout.otro(lyG)
layout.margen(1)
self.setLayout(layout)
self.ultimaPieza = "P"
self.piezas = self.board.piezas
self.resetPosicion()
self.ponCursor()
self.lb_scanner.hide()
self.pb_scanner_learn_quit.hide()
self.gb_scanner.hide()
def __init__(self, wParent, sts, work):
super(WWork, self).__init__(wParent)
self.work = work
self.setWindowTitle(sts.name)
self.setWindowIcon(Iconos.Motor())
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowMinimizeButtonHint
| QtCore.Qt.WindowMaximizeButtonHint)
tb = QTUtil2.tbAcceptCancel(self)
# Tabs
tab = Controles.Tab()
# Tab-basic --------------------------------------------------
lbRef = Controles.LB(self, _("Reference") + ": ")
self.edRef = Controles.ED(self, work.ref).anchoMinimo(360)
lbInfo = Controles.LB(self, _("Information") + ": ")
self.emInfo = Controles.EM(self, work.info,
siHTML=False).anchoMinimo(360).altoFijo(60)
lbDepth = Controles.LB(self, _("Maximum depth") + ": ")
self.sbDepth = Controles.SB(self, work.depth, 0, 50)
lbSeconds = Controles.LB(self, _("Maximum seconds to think") + ": ")
self.sbSeconds = Controles.SB(self, work.seconds, 0, 9999)
lbSample = Controles.LB(self, _("Sample") + ": ")
self.sbIni = Controles.SB(self, work.ini + 1, 1,
100).capturaCambiado(self.changeSample)
self.sbIni.isIni = True
lbGuion = Controles.LB(self, _("to"))
self.sbEnd = Controles.SB(self, work.end + 1, 1,
100).capturaCambiado(self.changeSample)
self.sbEnd.isIni = False
# self.lbError = Controles.LB(self).ponTipoLetra(peso=75).ponColorN("red")
# self.lbError.hide()
lySample = Colocacion.H().control(self.sbIni).control(lbGuion).control(
self.sbEnd)
ly = Colocacion.G()
ly.controld(lbRef, 0, 0).control(self.edRef, 0, 1)
ly.controld(lbInfo, 1, 0).control(self.emInfo, 1, 1)
ly.controld(lbDepth, 2, 0).control(self.sbDepth, 2, 1)
ly.controld(lbSeconds, 3, 0).control(self.sbSeconds, 3, 1)
ly.controld(lbSample, 4, 0).otro(lySample, 4, 1)
w = QtGui.QWidget()
w.setLayout(ly)
tab.nuevaTab(w, _("Basic data"))
# Tab-Engine
scrollArea = PantallaMotores.genOpcionesME(self, work.me)
tab.nuevaTab(scrollArea, _("Engine options"))
# Tab-Groups
btAll = Controles.PB(self, _("All"), self.setAll, plano=False)
btNone = Controles.PB(self, _("None"), self.setNone, plano=False)
lyAN = Colocacion.H().control(btAll).espacio(10).control(btNone)
self.liGroups = []
ly = Colocacion.G()
ly.columnaVacia(1, 10)
fil = 0
col = 0
num = len(sts.groups)
mitad = num / 2 + num % 2
for x in range(num):
group = sts.groups.group(x)
chb = Controles.CHB(self, _F(group.name), work.liGroupActive[x])
self.liGroups.append(chb)
col = 0 if x < mitad else 2
fil = x % mitad
ly.control(chb, fil, col)
ly.otroc(lyAN, mitad, 0, numColumnas=3)
w = QtGui.QWidget()
w.setLayout(ly)
tab.nuevaTab(w, _("Groups"))
layout = Colocacion.V().control(tb).control(tab).margen(8)
self.setLayout(layout)
self.edRef.setFocus()
def __init__(self, owner, db_counts, count):
QTVarios.WDialogo.__init__(self, owner, _("Count moves"),
Iconos.Count(), "runcounts")
self.configuracion = Code.configuracion
self.count = count
self.db_counts = db_counts
conf_board = self.configuracion.config_board("RUNCOUNTS", 64)
self.board = Tablero.TableroEstaticoMensaje(self, conf_board, None)
self.board.crea()
# Rotulo informacion
self.lb_info_game = Controles.LB(
self,
self.count.game.titulo(
"DATE", "EVENT", "WHITE", "BLACK", "RESULT")).ponTipoLetra(
puntos=self.configuracion.x_pgn_fontpoints)
# Movimientos
self.ed_moves = Controles.ED(self, "").ponTipoLetra(puntos=32)
self.ed_moves.setValidator(QtGui.QIntValidator(self.ed_moves))
self.ed_moves.setAlignment(QtCore.Qt.AlignRight)
self.ed_moves.anchoFijo(72)
ly = Colocacion.H().relleno().control(self.ed_moves).relleno()
self.gb_counts = Controles.GB(self, _("Number of moves"),
ly).ponFuente(
Controles.TipoLetra(puntos=10,
peso=75))
self.lb_result = Controles.LB(self).ponTipoLetra(
puntos=10, peso=500).anchoFijo(254).altoFijo(32).ponWrap()
self.lb_info = (Controles.LB(self).ponTipoLetra(
puntos=14,
peso=500).anchoFijo(254).ponColorFondoN("white",
"#496075").alinCentrado())
# Botones
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Begin"), Iconos.Empezar(), self.begin),
(_("Check"), Iconos.Check(), self.check),
(_("Continue"), Iconos.Pelicula_Seguir(), self.seguir),
)
self.tb = QTVarios.LCTB(self,
li_acciones,
style=QtCore.Qt.ToolButtonTextBesideIcon,
tamIcon=32)
self.show_tb(self.terminar, self.begin)
ly_right = (Colocacion.V().control(self.tb).controlc(
self.lb_info).relleno().control(self.gb_counts).relleno().control(
self.lb_result).relleno())
ly_center = Colocacion.H().control(self.board).otro(ly_right)
ly = Colocacion.V().otro(ly_center).control(
self.lb_info_game).margen(3)
self.setLayout(ly)
self.restore_video()
self.adjustSize()
# Tiempo
self.time_base = time.time()
self.gb_counts.setDisabled(True)
self.pon_info_posic()
self.set_position()
def __init__(self, wParent, listaMotores, motorExterno, siTorneo=False):
super(WMotor, self).__init__(wParent)
self.setWindowTitle(motorExterno.idName)
self.setWindowIcon(Iconos.Motor())
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowMinimizeButtonHint
| QtCore.Qt.WindowMaximizeButtonHint)
scrollArea = genOpcionesME(self, motorExterno)
self.motorExterno = motorExterno
self.liMotores = listaMotores if siTorneo else listaMotores.liMotores
self.siTorneo = siTorneo
# Toolbar
tb = QTUtil2.tbAcceptCancel(self)
lbAlias = Controles.LB(self, _("Alias") + ": ")
self.edAlias = Controles.ED(self, motorExterno.alias).anchoMinimo(360)
lbInfo = Controles.LB(self, _("Information") + ": ")
self.emInfo = Controles.EM(self, motorExterno.idInfo,
siHTML=False).anchoMinimo(360).altoFijo(60)
lbElo = Controles.LB(self, "ELO" + ": ")
self.sbElo = Controles.SB(self, motorExterno.elo, 0, 4000)
if siTorneo:
lbDepth = Controles.LB(self, _("Maximum depth") + ": ")
self.sbDepth = Controles.SB(self, motorExterno.depth(), 0, 50)
lbTime = Controles.LB(self, _("Maximum seconds to think") + ": ")
self.sbTime = Controles.SB(self, motorExterno.time(), 0, 9999)
lbBook = Controles.LB(self, _("Opening book") + ": ")
fvar = VarGen.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.recuperaVar(fvar)
# # Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.nombre, x.path) for x in self.listaLibros.lista]
li.insert(0, ("* " + _("Engine book"), "-"))
li.insert(0, ("* " + _("Default"), "*"))
self.cbBooks = Controles.CB(self, li, motorExterno.book())
btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=False).ponIcono(Iconos.Nuevo(),
tamIcon=16)
# # Respuesta rival
li = (
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
)
self.cbBooksRR = QTUtil2.comboBoxLB(self, li,
motorExterno.bookRR())
lyBook = Colocacion.H().control(lbBook).control(
self.cbBooks).control(
self.cbBooksRR).control(btNuevoBook).relleno()
lyDT = Colocacion.H().control(lbDepth).control(
self.sbDepth).espacio(40).control(lbTime).control(
self.sbTime).relleno()
lyTorneo = Colocacion.V().otro(lyDT).otro(lyBook)
# Layout
ly = Colocacion.G()
ly.controld(lbAlias, 0, 0).control(self.edAlias, 0, 1)
ly.controld(lbInfo, 1, 0).control(self.emInfo, 1, 1)
ly.controld(lbElo, 2, 0).control(self.sbElo, 2, 1)
if siTorneo:
ly.otro(lyTorneo, 3, 0, 1, 2)
layout = Colocacion.V().control(tb).espacio(30).otro(ly).control(
scrollArea)
self.setLayout(layout)
self.edAlias.setFocus()
def __init__(self, wParent, nombre_torneo):
torneo = self.torneo = Tournament.Tournament(nombre_torneo)
titulo = nombre_torneo
icono = Iconos.Torneos()
extparam = "untorneo_v1"
QTVarios.WDialogo.__init__(self, wParent, titulo, icono, extparam)
self.configuracion = Code.configuracion
# Datos
self.liEnActual = []
self.xjugar = None
self.liResult = None
self.last_change = Util.today()
self.li_results = []
# Toolbar
tb = Controles.TBrutina(self, tamIcon=24)
tb.new(_("Close"), Iconos.MainMenu(), self.terminar)
tb.new(_("Launch a worker"), Iconos.Lanzamiento(), self.gm_launch)
# Tabs
self.tab = tab = Controles.Tab()
# Tab-configuracion --------------------------------------------------
w = QtWidgets.QWidget()
# Adjudicator
lb_resign = Controles.LB(
self, "%s (%s): " %
(_("Minimum centipawns to assign winner"), _("0=disable")))
self.ed_resign = Controles.ED(self).tipoInt(
torneo.resign()).anchoFijo(30)
bt_resign = Controles.PB(self, "", rutina=self.borra_resign).ponIcono(
Iconos.Reciclar())
# Draw-plys
lbDrawMinPly = Controles.LB(
self,
"%s (%s): " % (_("Minimum moves to assign draw"), _("0=disable")))
self.sbDrawMinPly = Controles.SB(self, torneo.drawMinPly(), 20, 1000)
# Draw-puntos
lb_draw_range = Controles.LB(
self,
_("Maximum centipawns to assign draw") + ": ")
self.ed_draw_range = Controles.ED(self).tipoInt(
torneo.drawRange()).anchoFijo(30)
bt_draw_range = Controles.PB(
self, "", rutina=self.borra_draw_range).ponIcono(Iconos.Reciclar())
# adjudicator
self.liMotores = self.configuracion.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(
self, self.liMotores, torneo.adjudicator(), _("Engine"))
self.edJtiempo = Controles.ED(self).tipoFloat().ponFloat(
1.0).anchoFijo(50).ponFloat(torneo.adjudicator_time())
self.lbJtiempo = Controles.LB2P(self, _("Time in seconds"))
layout = Colocacion.G()
layout.controld(self.lbJmotor, 3, 0).control(self.cbJmotor, 3, 1)
layout.controld(self.lbJtiempo, 4, 0).control(self.edJtiempo, 4, 1)
self.gbJ = Controles.GB(self, _("Adjudicator"), layout)
self.gbJ.setCheckable(True)
self.gbJ.setChecked(torneo.adjudicator_active())
lbBook = Controles.LB(self, _("Opening book") + ": ")
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.name, x.path) for x in self.listaLibros.lista]
li.insert(0, ("* " + _("None"), "-"))
self.cbBooks = Controles.CB(self, li, torneo.book())
btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=False).ponIcono(Iconos.Nuevo(),
tamIcon=16)
lyBook = Colocacion.H().control(
self.cbBooks).control(btNuevoBook).relleno()
lbBookDepth = Controles.LB(self,
_("Max depth of book (0=Maximum)") + ": ")
self.sbBookDepth = Controles.SB(self, torneo.bookDepth(), 0, 200)
# Posicion inicial
lbFEN = Controles.LB(self, _("Initial position") + ": ")
self.fen = torneo.fen()
self.btPosicion = Controles.PB(self, " " * 5 + _("Change") + " " * 5,
self.posicionEditar).ponPlano(False)
self.btPosicionQuitar = Controles.PB(
self, "", self.posicionQuitar).ponIcono(Iconos.Motor_No())
self.btPosicionPegar = (Controles.PB(self, "",
self.posicionPegar).ponIcono(
Iconos.Pegar16()).ponToolTip(
_("Paste FEN position")))
lyFEN = (Colocacion.H().control(self.btPosicionQuitar).control(
self.btPosicion).control(self.btPosicionPegar).relleno())
# Norman Pollock
lbNorman = Controles.LB(
self,
'%s(<a href="https://komodochess.com/pub/40H-pgn-utilities">?</a>): '
% _("Initial position from Norman Pollock openings database"),
)
self.chbNorman = Controles.CHB(self, " ", self.torneo.norman())
# Layout
layout = Colocacion.G()
ly_res = Colocacion.H().control(
self.ed_resign).control(bt_resign).relleno()
ly_dra = Colocacion.H().control(
self.ed_draw_range).control(bt_draw_range).relleno()
layout.controld(lb_resign, 0, 0).otro(ly_res, 0, 1)
layout.controld(lbDrawMinPly, 1, 0).control(self.sbDrawMinPly, 1, 1)
layout.controld(lb_draw_range, 2, 0).otro(ly_dra, 2, 1)
layout.controld(lbBook, 3, 0).otro(lyBook, 3, 1)
layout.controld(lbBookDepth, 4, 0).control(self.sbBookDepth, 4, 1)
layout.controld(lbFEN, 5, 0).otro(lyFEN, 5, 1)
layout.controld(lbNorman, 6, 0).control(self.chbNorman, 6, 1)
layoutV = Colocacion.V().relleno().otro(layout).control(
self.gbJ).relleno()
layoutH = Colocacion.H().relleno().otro(layoutV).relleno()
# Creamos
w.setLayout(layoutH)
tab.nuevaTab(w, _("Configuration"))
# Tab-engines --------------------------------------------------
self.splitterEngines = QtWidgets.QSplitter(self)
self.register_splitter(self.splitterEngines, "engines")
# TB
li_acciones = [
(_("New"), Iconos.TutorialesCrear(), self.enNuevo),
None,
(_("Modify"), Iconos.Modificar(), self.enModificar),
None,
(_("Remove"), Iconos.Borrar(), self.enBorrar),
None,
(_("Copy"), Iconos.Copiar(), self.enCopiar),
None,
(_("Import"), Iconos.MasDoc(), self.enImportar),
None,
]
tbEnA = Controles.TBrutina(self,
li_acciones,
tamIcon=16,
style=QtCore.Qt.ToolButtonTextBesideIcon)
# Grid engine
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("ALIAS", _("Alias"), 209)
self.gridEnginesAlias = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True,
xid=GRID_ALIAS)
self.register_grid(self.gridEnginesAlias)
w = QtWidgets.QWidget()
ly = Colocacion.V().control(self.gridEnginesAlias).margen(0)
w.setLayout(ly)
self.splitterEngines.addWidget(w)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("CAMPO", _("Label"), 200, siDerecha=True)
o_columns.nueva("VALOR", _("Value"), 286)
self.gridEnginesValores = Grid.Grid(self,
o_columns,
siSelecFilas=False,
xid=GRID_VALUES)
self.register_grid(self.gridEnginesValores)
w = QtWidgets.QWidget()
ly = Colocacion.V().control(self.gridEnginesValores).margen(0)
w.setLayout(ly)
self.splitterEngines.addWidget(w)
self.splitterEngines.setSizes([250, 520]) # por defecto
w = QtWidgets.QWidget()
ly = Colocacion.V().control(tbEnA).control(self.splitterEngines)
w.setLayout(ly)
tab.nuevaTab(w, _("Engines"))
# Creamos
# Tab-games queued--------------------------------------------------
w = QtWidgets.QWidget()
# TB
li_acciones = [
(_("New"), Iconos.TutorialesCrear(), self.gm_crear_queued),
None,
(_("Remove"), Iconos.Borrar(), self.gm_borrar_queued),
None,
]
tbEnG = Controles.TBrutina(self,
li_acciones,
tamIcon=16,
style=QtCore.Qt.ToolButtonTextBesideIcon)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("WHITE", _("White"), 190, centered=True)
o_columns.nueva("BLACK", _("Black"), 190, centered=True)
o_columns.nueva("TIME", _("Time"), 170, centered=True)
# o_columns.nueva("STATE", _("State"), 190, centered=True)
self.gridGamesQueued = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True,
xid=GRID_GAMES_QUEUED)
self.register_grid(self.gridGamesQueued)
# Layout
layout = Colocacion.V().control(tbEnG).control(self.gridGamesQueued)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Games queued"))
# Tab-games terminados--------------------------------------------------
w = QtWidgets.QWidget()
# TB
li_acciones = [
(_("Remove"), Iconos.Borrar(), self.gm_borrar_finished),
None,
(_("Show"), Iconos.PGN(), self.gm_show_finished),
None,
(_("Save") + "(%s)" % _("PGN"), Iconos.GrabarComo(),
self.gm_save_pgn),
None,
]
tbEnGt = Controles.TBrutina(self,
li_acciones,
tamIcon=16,
style=QtCore.Qt.ToolButtonTextBesideIcon)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("WHITE", _("White"), 190, centered=True)
o_columns.nueva("BLACK", _("Black"), 190, centered=True)
o_columns.nueva("TIME", _("Time"), 170, centered=True)
o_columns.nueva("RESULT", _("Result"), 190, centered=True)
self.gridGamesFinished = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True,
xid=GRID_GAMES_FINISHED)
self.register_grid(self.gridGamesFinished)
# Layout
layout = Colocacion.V().control(tbEnGt).control(self.gridGamesFinished)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Games finished"))
# Tab-resultado --------------------------------------------------
w = QtWidgets.QWidget()
# Grid
wh = _("W")
bl = _("B")
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 35, centered=True)
o_columns.nueva("ENGINE", _("Engine"), 120, centered=True)
o_columns.nueva("SCORE", _("Score") + "%", 50, centered=True)
o_columns.nueva("WIN", _("Wins"), 50, centered=True)
o_columns.nueva("DRAW", _("Draws"), 50, centered=True)
o_columns.nueva("LOST", _("Losses"), 50, centered=True)
o_columns.nueva("WIN-WHITE",
"%s %s" % (wh, _("Wins")),
60,
centered=True)
o_columns.nueva("DRAW-WHITE",
"%s %s" % (wh, _("Draws")),
60,
centered=True)
o_columns.nueva("LOST-WHITE",
"%s %s" % (wh, _("Losses")),
60,
centered=True)
o_columns.nueva("WIN-BLACK",
"%s %s" % (bl, _("Wins")),
60,
centered=True)
o_columns.nueva("DRAW-BLACK",
"%s %s" % (bl, _("Draws")),
60,
centered=True)
o_columns.nueva("LOST-BLACK",
"%s %s" % (bl, _("Losses")),
60,
centered=True)
o_columns.nueva("GAMES", _("Games"), 50, centered=True)
self.gridResults = Grid.Grid(self,
o_columns,
siSelecFilas=True,
xid=GRID_RESULTS)
self.register_grid(self.gridResults)
self.qtColor = {
"WHITE": QTUtil.qtColorRGB(255, 250, 227),
"BLACK": QTUtil.qtColorRGB(221, 255, 221),
"SCORE": QTUtil.qtColorRGB(170, 170, 170),
}
# Layout
layout = Colocacion.V().control(self.gridResults)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Results"))
# Layout
# tab.setposition("W")
layout = Colocacion.V().control(tb).espacio(-3).control(tab).margen(2)
self.setLayout(layout)
self.restore_video(siTam=True, anchoDefecto=800, altoDefecto=430)
self.gridEnginesAlias.gotop()
self.ed_resign.setFocus()
self.muestraPosicion()
QtCore.QTimer.singleShot(5000, self.comprueba_cambios)
self.rotulos_tabs()
def __init__(self, owner, dicdatos):
self.dicdatos = dicdatos
site = dicdatos["SITE"]
self.level = dicdatos["LEVEL"]
self.intervalo = dicdatos["INTERVAL"]
self.intervaloPorPieza = dicdatos["INTERVALPIECE"]
self.esatacada = dicdatos["ISATTACKED"]
self.esatacante = dicdatos["ISATTACKING"]
self.posicion = dicdatos["POSITION"]
self.color = dicdatos["COLOR"]
self.errors = dicdatos["ERRORS"]
self.time = dicdatos["TIME"]
self.liFENs = dicdatos["FENS"]
mas = "x" if self.intervaloPorPieza else ""
titulo = "%s (%s%d\")" % (site, mas, self.intervalo)
super(WPlay, self).__init__(owner, titulo, Iconos.Gafas(),
"visualplay")
self.procesador = owner.procesador
self.configuracion = self.procesador.configuracion
# Tiempo en tablero
intervaloMax = self.intervalo
if self.intervaloPorPieza:
intervaloMax *= 32
# Tablero
confTablero = self.configuracion.confTablero("VISUALPLAY", 48)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
lyT = Colocacion.V().control(self.tablero)
self.gbTablero = Controles.GB(self, "", lyT)
# entradas
ly = Colocacion.G()
self.posPosicion = None
self.posColor = None
self.posIsAttacked = None
self.posIsAttacking = None
lista = [_("Piece")]
if self.posicion:
lista.append(_("Position"))
if self.color:
lista.append(_("Square color"))
if self.esatacada:
lista.append(_("Is attacked?"))
if self.esatacante:
lista.append(_("Is attacking?"))
self.liLB2 = []
for col, eti in enumerate(lista):
ly.control(Controles.LB(self, eti), 0, col + 1)
lb2 = Controles.LB(self, eti)
ly.control(lb2, 0, col + len(lista) + 2)
self.liLB2.append(lb2)
elementos = len(lista) + 1
liComboPieces = []
for c in "PNBRQKpnbrqk":
liComboPieces.append(("", c, self.tablero.piezas.icono(c)))
self.pmBien = Iconos.pmAceptarPeque()
self.pmMal = Iconos.pmCancelarPeque()
self.pmNada = Iconos.pmPuntoAmarillo()
self.liBloques = []
for x in range(32):
fila = x % 16 + 1
colPos = elementos if x > 15 else 0
unBloque = []
self.liBloques.append(unBloque)
# # Solucion
lb = Controles.LB(self, "").ponImagen(self.pmNada)
ly.control(lb, fila, colPos)
unBloque.append(lb)
# # Piezas
colPos += 1
cb = Controles.CB(self, liComboPieces, "P")
# cb.setStyleSheet("* { min-height:32px }")
cb.setIconSize(QtCore.QSize(20, 20))
ly.control(cb, fila, colPos)
unBloque.append(cb)
if self.posicion:
ec = Controles.ED(self, "").caracteres(2).controlrx(
"(|[a-h][1-8])").anchoFijo(24).alinCentrado()
colPos += 1
ly.controlc(ec, fila, colPos)
unBloque.append(ec)
if self.color:
cl = QTVarios.TwoImages(Iconos.pmBlancas(), Iconos.pmNegras())
colPos += 1
ly.controlc(cl, fila, colPos)
unBloque.append(cl)
if self.esatacada:
isat = QTVarios.TwoImages(Iconos.pmAtacada().scaledToWidth(24),
Iconos.pmPuntoNegro())
colPos += 1
ly.controlc(isat, fila, colPos)
unBloque.append(isat)
if self.esatacante:
at = QTVarios.TwoImages(Iconos.pmAtacante().scaledToWidth(24),
Iconos.pmPuntoNegro())
colPos += 1
ly.controlc(at, fila, colPos)
unBloque.append(at)
ly1 = Colocacion.H().otro(ly).relleno()
ly2 = Colocacion.V().otro(ly1).relleno()
self.gbSolucion = Controles.GB(self, "", ly2)
f = Controles.TipoLetra("", 11, 80, False, False, False, None)
bt = Controles.PB(self, _("End game"), self.terminar,
plano=False).ponIcono(
Iconos.FinPartida()).ponFuente(f)
self.btTablero = Controles.PB(self,
_("Go to board"),
self.activaTablero,
plano=False).ponIcono(
Iconos.Tablero()).ponFuente(f)
self.btComprueba = Controles.PB(self,
_("Test the solution"),
self.compruebaSolucion,
plano=False).ponIcono(
Iconos.Check()).ponFuente(f)
self.btGotoNextLevel = Controles.PB(self,
_("Go to next level"),
self.gotoNextLevel,
plano=False).ponIcono(
Iconos.GoToNext()).ponFuente(f)
ly0 = Colocacion.H().control(bt).relleno().control(
self.btTablero).control(self.btComprueba).control(
self.btGotoNextLevel)
lyBase = Colocacion.H().control(self.gbTablero).control(
self.gbSolucion)
layout = Colocacion.V().otro(ly0).otro(lyBase)
self.setLayout(layout)
self.recuperarVideo()
self.gotoNextLevel()
