def __init__(self, procesador, name, title, icono, folder, li_tam_blocks,
one_line):
self.one_line = one_line
if one_line:
self.tol = TurnOnLights.read_oneline_tol()
else:
self.tol = TurnOnLights.read_tol(name, title, folder,
li_tam_blocks)
self.reinit = False
titulo = _("Turn on the lights") + ": " + title
if self.tol.is_calculation_mode():
tipo = _("Calculation mode")
background = "#88AA3A"
else:
tipo = _("Memory mode")
background = "#BDDBE8"
self.procesador = procesador
extparam = "tol%s-%d" % (name, self.tol.work_level)
QTVarios.WDialogo.__init__(self, procesador.pantalla, titulo, icono,
extparam)
self.colorTheme = QTUtil.qtColor("#F0F0F0")
lb = Controles.LB(self, tipo)
lb.ponFondoN(background).alinCentrado().ponTipoLetra(puntos=14)
# Toolbar
tb = Controles.TBrutina(self)
tb.new(_("Close"), Iconos.MainMenu(), self.terminar)
anterior, siguiente, terminado = self.tol.prev_next()
if terminado:
tb.new(_("Rebuild"), Iconos.Reindexar(), self.rebuild)
if anterior:
tb.new(_("Previous"), Iconos.Anterior(), self.goto_previous)
if siguiente:
tb.new(_("Next"), Iconos.Siguiente(), self.goto_next)
if one_line:
tb.new(_("Change"), Iconos.TOLchange(), self.cambiar_one_line)
tb.new(_("Config"), Iconos.Configurar(), self.config)
tb.new(_("Information"), Iconos.Informacion(), self.colors)
# Lista
oColumnas = Columnas.ListaColumnas()
work_level = self.tol.work_level + 1
oColumnas.nueva("THEME",
_("Level %d/%d") % (work_level, self.tol.num_levels),
175)
edicionIconos = Delegados.PmIconosColor()
self.dicIconos = {}
for k, pm in edicionIconos.dicpmIconos.iteritems():
self.dicIconos[k] = QtGui.QIcon(pm)
for x in range(self.tol.num_blocks):
oColumnas.nueva("BLOCK%d" % x,
"%d" % (x + 1, ),
42,
siCentrado=True,
edicion=edicionIconos)
self.grid = grid = Grid.Grid(self,
oColumnas,
altoFila=42,
background="white")
self.grid.setAlternatingRowColors(False)
self.grid.tipoLetra(puntos=10, peso=500)
nAnchoPgn = self.grid.anchoColumnas() + 20
self.grid.setMinimumWidth(nAnchoPgn)
self.registrarGrid(grid)
# Colocamos ---------------------------------------------------------------
ly = Colocacion.V().control(lb).control(tb).control(self.grid)
self.setLayout(ly)
alto = self.tol.num_themes * 42 + 146
self.recuperarVideo(siTam=True,
altoDefecto=alto,
anchoDefecto=max(nAnchoPgn, 480))
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, panelOpening, configuracion):
QtGui.QWidget.__init__(self)
self.panelOpening = panelOpening
self.dbop = panelOpening.dbop
self.partidabase = panelOpening.partidabase
self.num_jg_inicial = len(self.partidabase)
self.posJugada = self.num_jg_inicial
confTablero = configuracion.confTablero("POSLINES", 32)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponerPiezasAbajo(True)
self.tablero.ponMensajero(self.mueveHumano)
self.tablero.dispatchSize(self.ajustaAncho)
self.tablero.dbVisual_setFichero(self.dbop.nomFichero)
self.tablero.dbVisual_setShowAllways(True)
self.dbop.setdbVisual_Tablero(self.tablero) # To close
self.intervalo = 1400
tipoLetra = Controles.TipoLetra(puntos=configuracion.puntosPGN)
lybt, bt = QTVarios.lyBotonesMovimiento(self,
"",
siTiempo=True,
siLibre=False,
tamIcon=24)
self.lbPGN = Controles.LB(self).ponWrap()
self.lbPGN.colocate = self.colocatePartida
self.lbPGN.setStyleSheet(
"QLabel{ border-style: groove; border-width: 2px; border-color: LightSlateGray; padding: 8px;}"
)
self.lbPGN.ponFuente(tipoLetra)
self.lbPGN.setOpenExternalLinks(False)
def muestraPos(txt):
self.colocatePartida(int(txt))
self.connect(self.lbPGN, QtCore.SIGNAL("linkActivated(QString)"),
muestraPos)
self.siFigurines = configuracion.figurinesPGN
dicNAGs = TrListas.dicNAGs()
self.dicValoracion = collections.OrderedDict()
self.dicValoracion[BUENO] = (dicNAGs[1],
PantallaColores.nag2ico(1, 16))
self.dicValoracion[MALO] = (dicNAGs[2], PantallaColores.nag2ico(2, 16))
self.dicValoracion[MUY_BUENO] = (dicNAGs[3],
PantallaColores.nag2ico(3, 16))
self.dicValoracion[MUY_MALO] = (dicNAGs[4],
PantallaColores.nag2ico(4, 16))
self.dicValoracion[INTERESANTE] = (dicNAGs[5],
PantallaColores.nag2ico(5, 16))
self.dicValoracion[DUDOSA] = (dicNAGs[6],
PantallaColores.nag2ico(6, 16))
self.dicValoracion[SIN_VALORACION] = (_("No rating"), QtGui.QIcon())
self.dicVentaja = collections.OrderedDict()
self.dicVentaja[V_SIN] = (_("Undefined"), QtGui.QIcon())
self.dicVentaja[V_IGUAL] = (dicNAGs[11],
Iconos.V_Blancas_Igual_Negras())
self.dicVentaja[V_BLANCAS] = (dicNAGs[14], Iconos.V_Blancas())
self.dicVentaja[V_BLANCAS_MAS] = (dicNAGs[16], Iconos.V_Blancas_Mas())
self.dicVentaja[V_BLANCAS_MAS_MAS] = (dicNAGs[18],
Iconos.V_Blancas_Mas_Mas())
self.dicVentaja[V_NEGRAS] = (dicNAGs[15], Iconos.V_Negras())
self.dicVentaja[V_NEGRAS_MAS] = (dicNAGs[17], Iconos.V_Negras_Mas())
self.dicVentaja[V_NEGRAS_MAS_MAS] = (dicNAGs[19],
Iconos.V_Negras_Mas_Mas())
# Valoracion
liOpciones = [(tit[0], k, tit[1])
for k, tit in self.dicValoracion.iteritems()]
self.cbValoracion = Controles.CB(self, liOpciones, 0).capturaCambiado(
self.cambiadoValoracion)
self.cbValoracion.ponFuente(tipoLetra)
# Ventaja
liOpciones = [(tit, k, icon)
for k, (tit, icon) in self.dicVentaja.iteritems()]
self.cbVentaja = Controles.CB(self, liOpciones,
0).capturaCambiado(self.cambiadoVentaja)
self.cbVentaja.ponFuente(tipoLetra)
# Comentario
self.emComentario = Controles.EM(self, siHTML=False).capturaCambios(
self.cambiadoComentario)
self.emComentario.ponFuente(tipoLetra)
self.emComentario.altoFijo(5 * configuracion.altoFilaPGN)
lyVal = Colocacion.H().control(self.cbValoracion).control(
self.cbVentaja)
lyEd = Colocacion.V().otro(lyVal).control(self.emComentario)
# Apertura
self.lbApertura = Controles.LB(self).alinCentrado().ponFuente(
tipoLetra).ponWrap()
lyt = Colocacion.H().relleno().control(self.tablero).relleno()
lya = Colocacion.H().relleno().control(self.lbPGN).relleno()
layout = Colocacion.V()
layout.otro(lyt)
layout.otro(lybt)
layout.otro(lya)
layout.otro(lyEd)
layout.control(self.lbApertura)
layout.relleno()
self.setLayout(layout)
self.ajustaAncho()
self.siReloj = False
self.ponPartida(self.partidabase)
def __init__(self, owner, listaFlechas, dbFlechas):
titulo = _("Arrows")
icono = Iconos.Flechas()
extparam = "flechas"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.owner = owner
flb = Controles.TipoLetra(puntos=8)
self.configuracion = VarGen.configuracion
self.dbFlechas = dbFlechas
self.liPFlechas = owner.listaFlechas()
# Lista
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("NUMERO", _("N."), 60, siCentrado=True)
oColumnas.nueva("NOMBRE", _("Name"), 256)
self.grid = Grid.Grid(self, oColumnas, xid="F", siSelecFilas=True)
liAcciones = [
(_("Close"), Iconos.MainMenu(), "terminar"), None,
(_("New"), Iconos.Nuevo(), "mas"), None,
(_("Remove"), Iconos.Borrar(), "borrar"), None,
(_("Modify"), Iconos.Modificar(), "modificar"), None,
(_("Copy"), Iconos.Copiar(), "copiar"), None,
(_("Up"), Iconos.Arriba(), "arriba"), None,
(_("Down"), Iconos.Abajo(), "abajo"), None,
]
tb = Controles.TB(self, liAcciones)
tb.setFont(flb)
ly = Colocacion.V().control(tb).control(self.grid)
# Tablero
confTablero = owner.tablero.confTablero
self.tablero = Tablero.TableroVisual(self, confTablero)
self.tablero.crea()
self.tablero.copiaPosicionDe(owner.tablero)
# Layout
layout = Colocacion.H().otro(ly).control(self.tablero)
self.setLayout(layout)
self.registrarGrid(self.grid)
self.recuperarVideo()
# Ejemplos
liMovs = ["d2d6", "a8h8", "h5b7"]
self.liEjemplos = []
regFlecha = TabTipos.Flecha()
for a1h8 in liMovs:
regFlecha.a1h8 = a1h8
regFlecha.siMovible = True
flecha = self.tablero.creaFlecha(regFlecha)
self.liEjemplos.append(flecha)
self.grid.gotop()
self.grid.setFocus()
def comboBoxLB(parent, liOpciones, valor, etiqueta=None):
cb = Controles.CB(parent, liOpciones, valor)
if etiqueta:
return cb, Controles.LB(parent, etiqueta + ": ")
else:
return cb
def __init__(self, owner, game, configuracion):
titulo = _("Save to PGN")
icono = Iconos.PGN()
extparam = "savepgn"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.game = game
self.game.order_tags()
self.body = self.game.pgnBase()
self.li_labels = self.game.li_tags
self.configuracion = configuracion
self.file = ""
self.vars_read()
# Opciones
li_options = [
(_("Save"), Iconos.GrabarFichero(), self.save),
None,
(_("Cancel"), Iconos.Cancelar(), self.terminar),
None,
(_("Clipboard"), Iconos.Clipboard(), self.portapapeles),
None,
(_("Reinit"), Iconos.Reiniciar(), self.reinit),
None,
]
tb = QTVarios.LCTB(self, li_options)
tabs = Controles.Tab(self)
# Tab-fichero -----------------------------------------------------------------------------------------------
lb_file = Controles.LB(self, _("File to save") + ": ")
bt_history = Controles.PB(self, "", self.history).ponIcono(
Iconos.Favoritos(), 24).ponToolTip(_("Previous"))
bt_boxrooms = (Controles.PB(self, "", self.boxrooms).ponIcono(
Iconos.BoxRooms(), 24).ponToolTip(_("Boxrooms PGN")))
self.bt_file = Controles.PB(self, "", self.file_select,
plano=False).anchoMinimo(300)
# Codec
lb_codec = Controles.LB(self, _("Encoding") + ": ")
liCodecs = [
k for k in set(v for k, v in encodings.aliases.aliases.items())
]
liCodecs.sort()
liCodecs = [(k, k) for k in liCodecs]
liCodecs.insert(0, (_("Same as file"), "file"))
liCodecs.insert(0,
("%s: %s" % (_("By default"), _("UTF-8")), "default"))
self.cb_codecs = Controles.CB(self, liCodecs, self.codec)
# Rest
self.chb_overwrite = Controles.CHB(self, _("Overwrite"), False)
self.chb_remove_c_v = Controles.CHB(
self, _("Remove comments and variations"), self.remove_c_v)
lyF = Colocacion.H().control(lb_file).control(
self.bt_file).control(bt_history).control(bt_boxrooms).relleno(1)
lyC = Colocacion.H().control(lb_codec).control(
self.cb_codecs).relleno(1)
ly = (Colocacion.V().espacio(15).otro(lyF).otro(lyC).control(
self.chb_overwrite).control(self.chb_remove_c_v).relleno(1))
w = QtWidgets.QWidget()
w.setLayout(ly)
tabs.nuevaTab(w, _("File"))
self.chb_overwrite.hide()
# Tab-labels -----------------------------------------------------------------------------------------------
liAccionesWork = (
("", Iconos.Mas22(), self.labels_more),
None,
("", Iconos.Menos22(), self.labels_less),
None,
("", Iconos.Arriba(), self.labels_up),
None,
("", Iconos.Abajo(), self.labels_down),
None,
)
tb_labels = Controles.TBrutina(self,
liAccionesWork,
tamIcon=16,
siTexto=False)
# Lista
o_columns = Columnas.ListaColumnas()
o_columns.nueva("ETIQUETA",
_("Label"),
150,
edicion=Delegados.LineaTextoUTF8())
o_columns.nueva("VALOR",
_("Value"),
400,
edicion=Delegados.LineaTextoUTF8())
self.grid_labels = Grid.Grid(self, o_columns, siEditable=True)
n = self.grid_labels.anchoColumnas()
self.grid_labels.setFixedWidth(n + 20)
# Layout
ly = Colocacion.V().control(tb_labels).control(
self.grid_labels).margen(3)
w = QtWidgets.QWidget()
w.setLayout(ly)
tabs.nuevaTab(w, _("Labels"))
# Tab-Body -----------------------------------------------------------------------------------------------
self.em_body = Controles.EM(self, self.body, siHTML=False)
tabs.nuevaTab(self.em_body, _("Body"))
layout = Colocacion.V().control(tb).control(tabs)
self.setLayout(layout)
if self.history_list:
fich = self.history_list[0]
if os.path.isfile(fich):
self.file = fich
self.show_file()
self.register_grid(self.grid_labels)
self.restore_video()
def __init__(self, wmoves):
QtGui.QTreeWidget.__init__(self)
self.wmoves = wmoves
self.itemActivo = None
self.setAlternatingRowColors(True)
self.dicItems = {}
self.posMoves = 0
self.posTransposition = 1
self.posBookmark = 2
self.posAnalisis = 3
self.posComment = 4
self.setHeaderLabels(
(_("Moves"), "", "", _("Analysis"), _("Comments"), ""))
self.setColumnHidden(5, True)
self.setIndentation(14)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.menuContexto)
self.setStyleSheet(
"selection-background-color: #F1D369; selection-color: #000000;")
ftxt = Controles.TipoLetra(puntos=9)
self.setFont(ftxt)
self.connect(self, QtCore.SIGNAL("itemExpanded(QTreeWidgetItem *)"),
self.expandido)
self.connect(self, QtCore.SIGNAL("itemSelectionChanged()"),
self.seleccionadoISC)
self.connect(self,
QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"),
self.dobleClick)
self.noIcon = QtGui.QIcon()
self.iconBookmark = Iconos.Favoritos()
self.iconTransposition = Iconos.Transposition()
dicNAGs = TrListas.dicNAGs()
self.dicValoracion = collections.OrderedDict()
self.dicValoracion[BUENO] = (dicNAGs[1],
PantallaColores.nag2ico(1, 16))
self.dicValoracion[MALO] = (dicNAGs[2], PantallaColores.nag2ico(2, 16))
self.dicValoracion[MUY_BUENO] = (dicNAGs[3],
PantallaColores.nag2ico(3, 16))
self.dicValoracion[MUY_MALO] = (dicNAGs[4],
PantallaColores.nag2ico(4, 16))
self.dicValoracion[INTERESANTE] = (dicNAGs[5],
PantallaColores.nag2ico(5, 16))
self.dicValoracion[DUDOSA] = (dicNAGs[6],
PantallaColores.nag2ico(6, 16))
self.dicValoracion[SIN_VALORACION] = (_("No rating"), self.noIcon)
self.dicVentaja = collections.OrderedDict()
self.dicVentaja[V_SIN] = (_("Undefined"), self.noIcon)
self.dicVentaja[V_IGUAL] = (dicNAGs[11],
Iconos.V_Blancas_Igual_Negras())
self.dicVentaja[V_BLANCAS] = (dicNAGs[14], Iconos.V_Blancas())
self.dicVentaja[V_BLANCAS_MAS] = (dicNAGs[16], Iconos.V_Blancas_Mas())
self.dicVentaja[V_BLANCAS_MAS_MAS] = (dicNAGs[18],
Iconos.V_Blancas_Mas_Mas())
self.dicVentaja[V_NEGRAS] = (dicNAGs[15], Iconos.V_Negras())
self.dicVentaja[V_NEGRAS_MAS] = (dicNAGs[17], Iconos.V_Negras_Mas())
self.dicVentaja[V_NEGRAS_MAS_MAS] = (dicNAGs[19],
Iconos.V_Negras_Mas_Mas())
def __init__(self, wowner, procesador, album):
self.album = album
titulo = album.nombre
super().__init__(parent=wowner,
titulo=titulo,
icono=album.icono(),
extparam="albumes")
self.configuracion = procesador.configuracion
ncromos = len(album)
dicT = {
6: 3,
8: 4,
10: 5,
12: 6,
14: 7,
16: 8,
18: 6,
20: 5,
24: 6,
28: 7,
32: 8,
40: 8
}
divisor = dicT.get(ncromos, 6)
layout = Colocacion.G()
pte = False
icoCaracol = Iconos.Caracol()
for pos in range(ncromos):
cromo = album.get_cromo(pos)
if not cromo.hecho:
pte = True
pb = Controles.PB(self, "", rutina=self.pulsado, plano=False)
pb.setFixedSize(110, 110)
pb.clave = cromo
if cromo.hecho:
icono = cromo.icono()
pixmap = icono.pixmap(64, 64)
icono.addPixmap(pixmap, QtGui.QIcon.Disabled)
pb.setEnabled(False)
else:
icono = icoCaracol
pb.ponIcono(icono, 64)
lb = Controles.LB(self, cromo.nombre)
lb.ponTipoLetra(puntos=10, peso=75)
fila = pos // divisor
col = pos % divisor
layout.controlc(pb, fila * 2, col)
layout.controlc(lb, fila * 2 + 1, col)
mensaje = _(
"Select a slot to play against and get its image if you win"
) if pte else ""
lb = Controles.LB(self, mensaje)
pbExit = Controles.PB(self, _("Close"), self.quit,
plano=False).ponIcono(Iconos.MainMenu())
lyP = Colocacion.H().relleno().control(lb).relleno().control(pbExit)
if not pte:
pbRebuild = Controles.PB(self,
_("Rebuild this album"),
self.rebuild,
plano=False).ponIcono(Iconos.Delete())
lyP.control(pbRebuild)
lyT = Colocacion.V().otro(layout).otro(lyP)
self.setLayout(lyT)
self.recuperarVideo(siTam=False)
self.resultado = None, None
def __init__(self, procesador):
self.procesador = procesador
self.configuracion = procesador.configuracion
self.resultado = None
self.listaOpenings = OpeningLines.ListaOpenings(self.configuracion)
QTVarios.WDialogo.__init__(self, procesador.pantalla, self.getTitulo(), Iconos.OpeningLines(), "openingLines")
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("TITLE", _("Name"), 240)
oColumnas.nueva("BASEPV", _("First moves"), 280)
oColumnas.nueva("NUMLINES", _("Lines"), 80, siCentrado=True)
oColumnas.nueva("FILE", _("File"), 200)
self.glista = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True)
sp = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
liAcciones = (
(_("Close"), Iconos.MainMenu(), self.terminar), None,
(_("Edit"), Iconos.Modificar(), self.modificar), None,
(_("New"), Iconos.Nuevo(), self.new), None,
(_("Copy"), Iconos.Copiar(), self.copy), None,
(_("Rename"), Iconos.Modificar(), self.renombrar), None,
(_("Up"), Iconos.Arriba(), self.arriba),
(_("Down"), Iconos.Abajo(), self.abajo), None,
(_("Remove"), Iconos.Borrar(), self.borrar), None,
(_("Reinit"), Iconos.Reiniciar(), self.reiniciar), None,
(_("Folder"), Iconos.File(), self.changeFolder), None,
)
tb = QTVarios.LCTB(self, liAcciones)
tb.setSizePolicy(sp)
liAcciones = (
(_("Sequential"), Iconos.TrainSequential(), self.tr_sequential), None,
(_("Static"), Iconos.TrainStatic(), self.tr_static), None,
(_("Positions"), Iconos.TrainPositions(), self.tr_positions), None,
(_("With engines"), Iconos.TrainEngines(), self.tr_engines),
)
self.tbtrain = tbtrain = Controles.TBrutina(self, liAcciones, siTexto=False)
lbtrain = Controles.LB(self, _("Trainings")).alinCentrado().ponFondoN("lightgray")
lytrain = Colocacion.V().control(lbtrain).control(tbtrain).margen(0)
self.wtrain = QtGui.QWidget()
self.wtrain.setLayout(lytrain)
lytb = Colocacion.H().control(tb).control(self.wtrain).margen(0)
wtb = QtGui.QWidget()
wtb.setFixedHeight(62)
wtb.setLayout(lytb)
# Colocamos
ly = Colocacion.V().control(wtb).control(self.glista).margen(4)
self.setLayout(ly)
self.registrarGrid(self.glista)
self.recuperarVideo(anchoDefecto=self.glista.anchoColumnas()+20)
self.wtrain.setVisible(False)
self.glista.gotop()
def __init__(self, cpu):
QtGui.QDialog.__init__(self)
self.cpu = cpu
self.ficheroVideo = cpu.ficheroVideo
dicVideo = self.dicVideo()
self.siTop = dicVideo.get("SITOP", True)
self.siShowTablero = dicVideo.get("SHOW_TABLERO", True)
self.nArrows = dicVideo.get("NARROWS", 7)
self.fen = ""
self.liData = []
self.dicLineasDepth = {}
self.setWindowTitle(cpu.titulo)
self.setWindowIcon(Iconos.Motor())
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowMinimizeButtonHint)
self.setBackgroundRole(QtGui.QPalette.Light)
VarGen.configuracion = cpu.configuracion
VarGen.todasPiezas = Piezas.TodasPiezas()
confTablero = cpu.configuracion.confTablero("moscas" + cpu.titulo, 24)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("BESTMOVE", _("Alternatives"), 80, siCentrado=True)
oColumnas.nueva("EVALUATION", _("Evaluation"), 85, siCentrado=True)
oColumnas.nueva("MAINLINE", _("Main line"), 300)
self.grid = Grid.Grid(self, oColumnas, dicVideo=dicVideo)
self.lbDepth = Controles.LB(self)
liAcciones = (
(_("Quit"), Iconos.Kibitzer_Terminar(), self.terminar),
(_("Continue"), Iconos.Kibitzer_Continuar(), self.play),
(_("Pause"), Iconos.Kibitzer_Pausa(), self.pause),
(_("The best solution found by the engine is saved to the clipboard"), Iconos.MoverGrabar(), self.portapapelesUltJug),
(_("Analyze only color"), Iconos.P_16c(), self.color),
(_("Board"), Iconos.Tablero(), self.confTablero),
("%s: %s" % (_("Enable"), _("window on top")), Iconos.Top(), self.windowTop),
("%s: %s" % (_("Disable"), _("window on top")), Iconos.Bottom(), self.windowBottom),
)
self.tb = Controles.TBrutina(self, liAcciones, siTexto=False, tamIcon=16)
self.tb.setAccionVisible(self.play, False)
ly1 = Colocacion.H().control(self.tb).relleno().control(self.lbDepth)
ly2 = Colocacion.V().otro(ly1).control(self.grid)
layout = Colocacion.H().control(self.tablero).otro(ly2)
self.setLayout(layout)
self.siPlay = True
self.siBlancas = True
self.siNegras = True
self.timer = QtCore.QTimer(self)
self.connect(self.timer, QtCore.SIGNAL("timeout()"), cpu.compruebaInput)
self.timer.start(200)
if not self.siShowTablero:
self.tablero.hide()
self.recuperarVideo(dicVideo)
self.ponFlags()
self.motor = None
self.lanzaMotor()
def __init__(self, cpu, siWidgets=True, flags=None):
QtGui.QDialog.__init__(self)
self.cpu = cpu
self.ficheroVideo = cpu.ficheroVideo
self.motor = None
self.liData = []
self.almFEN = {}
self.fen = ""
self.setWindowTitle(cpu.titulo)
self.setWindowIcon(Iconos.Motor())
if not flags:
flags = QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.WindowStaysOnTopHint
self.setWindowFlags(flags)
self.setBackgroundRole(QtGui.QPalette.Light)
self.setStyleSheet("QTextEdit { background-color: rgb( 250,250,250); }")
VarGen.configuracion = cpu.configuracion
VarGen.todasPiezas = Piezas.TodasPiezas()
confTablero = cpu.configuracion.confTablero("moscas" + cpu.titulo, 24)
self.siWidgets = siWidgets
if siWidgets:
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.siShowTablero = siWidgets
self.nArrows = 7
self.siTop = True
if siWidgets:
self.em = Controles.EM(self).soloLectura()
liAcciones = (
(_("Quit"), Iconos.Kibitzer_Terminar(), self.terminar),
(_("Continue"), Iconos.Kibitzer_Continuar(), self.play),
(_("Pause"), Iconos.Kibitzer_Pausa(), self.pause),
(_("The best solution found by the engine is saved to the clipboard"), Iconos.MoverGrabar(), self.portapapelesUltJug),
(_("Analyze only color"), Iconos.P_16c(), self.color),
(_("Board"), Iconos.Tablero(), self.confTablero),
("%s: %s" % (_("Enable"), _("window on top")), Iconos.Top(), self.windowTop),
("%s: %s" % (_("Disable"), _("window on top")), Iconos.Bottom(), self.windowBottom),
)
self.tb = Controles.TBrutina(self, liAcciones, siTexto=False, tamIcon=16)
self.layoutDT = Colocacion.H().control(self.tablero).control(self.em)
self.siPlay = True
self.siBlancas = True
self.siNegras = True
self.creaRestoControles()
self.timer = QtCore.QTimer(self)
self.connect(self.timer, QtCore.SIGNAL("timeout()"), cpu.compruebaInput)
self.timer.start(200)
self.recuperarVideo()
self.ponFlags()
def __init__(self, procesador):
self.procesador = procesador
self.configuracion = procesador.configuracion
self.db = EndingsGTB.DBendings(self.configuracion)
self.t4 = LibChess.T4(self.configuracion)
QTVarios.WDialogo.__init__(
self, procesador.main_window, _("Endings with Gaviota Tablebases"), Iconos.Finales(), "endings_gtb"
)
self.game = Game.Game()
self.act_recno = -1
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Config"), Iconos.Configurar(), self.configurar),
None,
(_("Utilities"), Iconos.Utilidades(), self.utilidades),
None,
)
tb = QTVarios.LCTB(self, li_acciones)
ly_bt, self.bt_movs = QTVarios.lyBotonesMovimiento(
self, "", siTiempo=True, siLibre=False, rutina=self.run_botones, tamIcon=24
)
self.chb_help = Controles.CHB(self, _("Help mode"), False)
ly_bt.espacio(20).control(self.chb_help)
self.wpzs = QtWidgets.QWidget(self)
self.wpzs.li_labels = []
ly_wpzs = Colocacion.H()
for x in range(6):
lbl = Controles.LB(self.wpzs)
self.wpzs.li_labels.append(lbl)
ly_wpzs.control(lbl)
self.wpzs.setLayout(ly_wpzs)
self.wpzs.mousePressEvent = self.change
self.color_done = QTUtil.qtColorRGB(213, 233, 250)
li_acciones = (
None,
(" " + _("Play"), Iconos.Play1(), self.play),
None,
(" " + _("New"), Iconos.New1(), self.nuevo),
None,
(" " + _("Remove"), Iconos.Remove1(), self.remove),
None,
)
self.tb_run = Controles.TBrutina(self, li_acciones, tamIcon=32, puntos=self.configuracion.x_tb_fontpoints)
ly_top = Colocacion.H().control(tb).relleno().control(self.wpzs).relleno().control(self.tb_run)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("XFEN", _("Position"), 140, centered=True)
o_columns.nueva("MATE", _("Mate"), 60, centered=True)
o_columns.nueva("TRIES", _("Tries"), 50, centered=True)
o_columns.nueva("MOVES", _("Minimum moves"), 120, centered=True)
o_columns.nueva("TIMEMS", _("Minimum time"), 120, centered=True)
self.grid = Grid.Grid(self, o_columns, siSelecFilas=True)
self.grid.tipoLetra(puntos=self.configuracion.x_pgn_fontpoints)
self.grid.ponAltoFila(self.configuracion.x_pgn_rowheight)
self.grid.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding))
ly_pos = Colocacion.V().control(self.grid)
config_board = self.configuracion.config_board("ENDINGSGTB", 64)
self.tablero = TableroEndings(self, config_board)
self.tablero.set_startup_control(self.startup_control)
self.tablero.crea()
self.tablero.ponerPiezasAbajo(True)
self.tablero.set_dispatcher(self.mueve_humano)
self.pzs = self.tablero.piezas
self.playing = False
ly_left_bottom = Colocacion.V().control(self.tablero).otro(ly_bt).relleno().margen(0)
w = QtWidgets.QWidget(self)
w.setLayout(ly_left_bottom)
w.setFixedWidth(self.tablero.ancho + 16)
ly_bottom = Colocacion.H().control(w).otro(ly_pos)
layout = Colocacion.V().otro(ly_top).otro(ly_bottom).margen(6)
self.setLayout(layout)
self.restore_video()
dic = self.configuracion.leeVariables("endingsGTB")
self.key = key = dic.get("KEY")
if (not key) or len(key) > self.configuracion.piezas_gaviota():
key = "KPk"
self.db.set_examples_auto(dic.get("EXAMPLES_AUTO", True))
self.set_key(key)
self.play_next_type = dic.get("PLAY_NEXT", PLAY_STOP)
self.grid.gotop()
self.play()
def __init__(self, owner, db_mate15, mate15):
QTVarios.WDialogo.__init__(self, owner, _("Mate in 1½"), Iconos.Mate15(), "runmate15")
self.configuration = Code.configuration
self.mate15 = mate15
self.db_mate15 = db_mate15
conf_board = self.configuration.config_board("RUNMATE15", 64)
self.board = Board.BoardEstatico(self, conf_board)
self.board.crea()
# Rotulo informacion
self.lb_info = Controles.LB(self, "[%d] %s" % (self.mate15.pos + 1, self.mate15.info))
self.lb_info.ponTipoLetra(puntos=self.configuration.x_pgn_fontpoints).align_center().set_wrap()
self.lb_info.setStyleSheet("QWidget { background-color: #1f497d; color: #FFFFFF;padding: 16px; }")
self.lb_first_move = Controles.LB(self).ponTipoLetra(puntos=12, peso=500)
self.bt_check = Controles.PB(self, _("Check"), self.check, False).ponIcono(Iconos.Check(), icon_size=20)
self.lb_result = Controles.LB(self).ponTipoLetra(puntos=12, peso=500)
# Movimientos
self.li_lb_wm = []
ly = Colocacion.G().margen(4)
for row in range(10):
lb = Controles.LB(self).ponTipoLetra(puntos=12, peso=500)
wm = WRunCommon.WEdMove(self)
self.li_lb_wm.append((lb, wm))
ly.controld(lb, row, 0)
ly.columnaVacia(1, 20)
ly.control(wm, row, 2)
lb.hide()
wm.hide()
ly.filaVacia(10, 20)
ly.controlc(self.bt_check, 11, 0, numColumnas=3)
ly.controlc(self.lb_result, 12, 0, numColumnas=3)
self.gb = Controles.GB(self, _("Next moves and their solutions"), ly).ponFuente(Controles.TipoLetra(puntos=10, peso=75))
self.gb.hide()
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Begin"), Iconos.Empezar(), self.begin),
(_("Restart"), Iconos.Reset(), self.restart),
(_("Continue"), Iconos.Pelicula_Seguir(), self.seguir),
)
self.tb = QTVarios.LCTB(self, li_acciones, style=QtCore.Qt.ToolButtonTextBesideIcon, icon_size=32)
self.show_tb(self.terminar, self.begin)
ly_left = Colocacion.V().control(self.tb).control(self.board)
ly_right = Colocacion.V().controlc(self.lb_info).espacio(40).controlc(self.lb_first_move).espacio(20).control(self.gb).relleno()
ly_center = Colocacion.H().otro(ly_left).otro(ly_right).margen(3)
self.setLayout(ly_center)
self.restore_video()
self.adjustSize()
self.gb.setDisabled(True)
self.li_lb_wm[0][1].activa()
self.ultimaCelda = None
def __init__(self, wParent):
QtWidgets.QWidget.__init__(self, wParent)
self.wParent = wParent
self.jg = None
self.partida = None
configuracion = VarGen.configuracion
puntos = configuracion.puntosPGN
f = Controles.TipoLetra(puntos=puntos, peso=75)
f9 = Controles.TipoLetra(puntos=puntos)
ftxt = f9
# Apertura
self.lbApertura = Controles.LB(
self, "").ponFuente(f).alinCentrado().ponColorFondoN(
"#eeeeee", "#474d59").ponWrap()
self.lbApertura.hide()
# Valoracion
liOpciones = [("-", "-")]
dicNAGs = TrListas.dicNAGs()
carpNAGs = "./IntFiles/NAGs"
for x in dicNAGs:
if x:
fsvg = "%s/$%d.svg" % (carpNAGs, x)
if os.path.isfile(fsvg):
liOpciones.append(("$%d : %s" % (x, dicNAGs[x]), str(x),
QTVarios.fsvg2ico(fsvg, 16)))
else:
liOpciones.append(("$%d : %s" % (x, dicNAGs[x]), str(x)))
self.maxNAGs = 10
self.liNAGs = []
for x in range(self.maxNAGs):
cb = Controles.CB(self, liOpciones,
"").ponAnchoMinimo().capturaCambiado(
self.valoracionCambiada).ponFuente(f9)
if x:
cb.hide()
self.liNAGs.append(cb)
btNAGS = Controles.PB(self, "", self.masNAGs).ponIcono(
Iconos.Mas()).anchoFijo(22)
liOpciones = [(x, x) for x in ("-", "!", "!!", "?", "??", "!?", "?!")]
self.valoracionDirecta = Controles.CB(
self, liOpciones, "-").ponAnchoFijo(42).capturaCambiado(
self.valoracionDirectaCambiada)
lyH = Colocacion.H().control(self.valoracionDirecta).control(
self.liNAGs[0]).control(btNAGS)
ly = Colocacion.V().otro(lyH)
for x in range(1, self.maxNAGs):
ly.control(self.liNAGs[x])
self.gbValoracion = Controles.GB(self, _("Rating"), ly).ponFuente(f)
# Comentarios
self.comentario = Controles.EM(self, siHTML=False).capturaCambios(
self.comentarioCambiado).ponFuente(ftxt).anchoMinimo(200)
ly = Colocacion.H().control(self.comentario).margen(3)
self.gbComentario = Controles.GB(self, _("Comments"), ly).ponFuente(f)
# Variantes
self.variantes = Variantes(self)
self.splitter = splitter = QtWidgets.QSplitter(self)
self.splitter.setOrientation(QtCore.Qt.Vertical)
splitter.addWidget(self.gbComentario)
splitter.addWidget(self.variantes)
layout = Colocacion.V()
layout.control(self.lbApertura)
layout.control(self.gbValoracion)
layout.control(self.splitter)
layout.margen(1)
self.setLayout(layout)
def __init__(self, owner, name, title, icono, folder, li_tam_blocks):
self.tol = TurnOnLights.read_tol(name, title, folder, li_tam_blocks)
self.reinit = False
titulo = _("Turn on the lights") + ": " + title
if self.tol.is_calculation_mode():
tipo = _("Calculation mode")
background = "#88AA3A"
else:
tipo = _("Memory mode")
background = "#BDDBE8"
extparam = "tol%s-%d" % (name, self.tol.work_level)
super().__init__(parent=owner,
titulo=titulo,
icono=icono,
extparam=extparam)
self.colorTheme = QTUtil.qtColor("#F0F0F0")
lb = Controles.LB(self, tipo)
lb.ponFondoN(background).alinCentrado().ponTipoLetra(puntos=14)
# Toolbar
tb = Controles.TBrutina(self)
tb.new(_("Close"), Iconos.MainMenu(), self.terminar)
anterior, siguiente = self.tol.prev_next()
if anterior:
tb.new(_("Previous"), Iconos.Anterior(), self.goto_previous)
if siguiente:
tb.new(_("Next"), Iconos.Siguiente(), self.goto_next)
tb.new(_("Config"), Iconos.Configurar(), self.config)
tb.new(_("Information"), Iconos.Informacion(), self.colors)
# Lista
oColumnas = Columnas.ListaColumnas()
work_level = self.tol.work_level + 1
oColumnas.nueva("THEME",
_("Level %d/%d") % (work_level, self.tol.num_levels),
175)
for x in range(self.tol.num_blocks):
oColumnas.nueva("BLOCK%d" % x,
"%d" % (x + 1, ),
42,
siCentrado=True,
edicion=Delegados.PmIconosColor())
self.grid = grid = Grid.Grid(self,
oColumnas,
altoFila=42,
background="white")
self.grid.setAlternatingRowColors(False)
self.grid.tipoLetra(puntos=10, peso=500)
nAnchoPgn = self.grid.anchoColumnas() + 20
self.grid.setMinimumWidth(nAnchoPgn)
self.registrarGrid(grid)
# Colocamos ---------------------------------------------------------------
ly = Colocacion.V().control(lb).control(tb).control(self.grid)
self.setLayout(ly)
alto = self.tol.num_themes * 42 + 146
self.recuperarVideo(siTam=True,
altoDefecto=alto,
anchoDefecto=nAnchoPgn)
def __init__(self, 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, cpu):
QtWidgets.QDialog.__init__(self)
self.cpu = cpu
dicVideo = self.cpu.dic_video
if not dicVideo:
dicVideo = {}
self.siTop = dicVideo.get("SITOP", True)
self.show_board = dicVideo.get("SHOW_BOARD", True)
self.position = Position.Position()
self.game = None
self.siPlay = True
self.li_moves = []
self.history = []
self.setWindowTitle(cpu.titulo)
self.setWindowIcon(Iconos.Book())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint
| QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowMinimizeButtonHint)
self.setBackgroundRole(QtGui.QPalette.Light)
Code.configuration = cpu.configuration
Code.todasPiezas = Piezas.TodasPiezas()
config_board = cpu.configuration.config_board(
"kib" + cpu.kibitzer.huella, 24)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.mensajero)
Delegados.generaPM(self.board.piezas)
self.book = Books.Book("P", cpu.kibitzer.name, cpu.kibitzer.path_exe,
True)
self.book.polyglot()
self.with_figurines = cpu.configuration.x_pgn_withfigurines
o_columns = Columnas.ListaColumnas()
delegado = Delegados.EtiquetaPOS(
True, siLineas=False) if self.with_figurines else None
o_columns.nueva("MOVE", _("Move"), 80, centered=True, edicion=delegado)
o_columns.nueva("PORC", "%", 60, centered=True)
o_columns.nueva("WEIGHT", _("Weight"), 80, siDerecha=True)
self.grid_moves = Grid.Grid(self,
o_columns,
dicVideo=dicVideo,
siSelecFilas=True)
li_acciones = (
(_("Quit"), Iconos.Kibitzer_Close(), self.terminar),
(_("Continue"), Iconos.Kibitzer_Play(), self.play),
(_("Pause"), Iconos.Kibitzer_Pause(), self.pause),
(_("Takeback"), Iconos.pmKibitzer_Back(), self.takeback),
(_("Manual position"), Iconos.Kibitzer_Voyager(),
self.set_position),
(_("Show/hide board"), Iconos.Kibitzer_Board(), self.config_board),
("%s: %s" % (_("Enable"), _("window on top")), Iconos.Top(),
self.windowTop),
("%s: %s" % (_("Disable"), _("window on top")), Iconos.Bottom(),
self.windowBottom),
)
self.tb = Controles.TBrutina(self,
li_acciones,
with_text=False,
icon_size=24)
self.tb.setAccionVisible(self.play, False)
ly1 = Colocacion.H().control(self.board).control(self.grid_moves)
layout = Colocacion.V().control(
self.tb).espacio(-8).otro(ly1).margen(3)
self.setLayout(layout)
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.cpu.compruebaInput)
self.timer.start(500)
if not self.show_board:
self.board.hide()
self.restore_video(dicVideo)
self.ponFlags()
def __init__(self, cpu):
QtWidgets.QDialog.__init__(self)
self.cpu = cpu
dicVideo = self.cpu.dic_video
if not dicVideo:
dicVideo = {}
self.siTop = dicVideo.get("SITOP", True)
self.siShowTablero = dicVideo.get("SHOW_TABLERO", True)
self.position = Position.Position()
self.fen = ""
self.almFEN = {}
self.siPlay = True
self.is_white = True
self.siNegras = True
self.setWindowTitle(cpu.titulo)
self.setWindowIcon(Iconos.Book())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint
| QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowMinimizeButtonHint)
self.setBackgroundRole(QtGui.QPalette.Light)
Code.configuracion = cpu.configuracion
Code.todasPiezas = Piezas.TodasPiezas()
config_board = cpu.configuracion.config_board(
"kib" + cpu.kibitzer.huella, 24)
self.tablero = Tablero.Tablero(self, config_board)
self.tablero.crea()
Delegados.generaPM(self.tablero.piezas)
self.em = Controles.EM(self, siHTML=False).soloLectura()
f = Controles.TipoLetra(name="Courier New", puntos=10)
self.em.ponFuente(f)
li_acciones = (
(_("Quit"), Iconos.Kibitzer_Terminar(), self.terminar),
(_("Continue"), Iconos.Kibitzer_Continuar(), self.play),
(_("Pause"), Iconos.Kibitzer_Pausa(), self.pause),
(_("Board"), Iconos.Tablero(), self.config_board),
("%s: %s" % (_("Enable"), _("window on top")), Iconos.Top(),
self.windowTop),
("%s: %s" % (_("Disable"), _("window on top")), Iconos.Bottom(),
self.windowBottom),
)
self.tb = Controles.TBrutina(self,
li_acciones,
siTexto=False,
tamIcon=16)
self.tb.setAccionVisible(self.play, False)
ly1 = Colocacion.H().control(self.tb)
ly2 = Colocacion.V().otro(ly1).control(self.em)
layout = Colocacion.H().control(self.tablero).otro(ly2)
self.setLayout(layout)
self.engine = self.lanzaMotor()
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.cpu.compruebaInput)
self.timer.start(200)
if not self.siShowTablero:
self.tablero.hide()
self.restore_video(dicVideo)
self.ponFlags()
def menu(self, parent):
menu = Controles.Menu(parent)
rp = QTVarios.rondoPuntos()
submenu = menu.submenu(_("Internal engines"), self.dicIconos[INTERNO])
for cm in self.liMotoresInternos:
clave = INTERNO, cm
texto = cm.nombre
icono = rp.otro()
elo = cm.elo
submenu.opcion(clave, "%s (%d)" % (texto, elo), icono)
menu.separador()
submenu = menu.submenu(_("External engines"), self.dicIconos[EXTERNO])
for cm in self.liMotoresExternos:
clave = EXTERNO, cm
texto = cm.clave
icono = rp.otro()
submenu.opcion(clave, texto, icono)
submenu.separador()
clave = EXTERNO, None
texto = _("Edition")
icono = Iconos.Mas()
submenu.opcion(clave, texto, icono)
menu.separador()
submenu = menu.submenu(_("GM engines"), self.dicIconos[MICGM])
for cm in self.liMotoresGM:
icono = rp.otro()
clave = MICGM, cm
texto = cm.nombre
submenu.opcion(clave, texto, icono)
submenu.separador()
menu.separador()
menu.opcion((MICPER, None), _("Tourney engines"),
self.dicIconos[MICPER])
menu.separador()
submenu = menu.submenu(_("Engines with fixed elo"),
self.dicIconos[FIXED])
li = self.dicMotoresFixedElo.keys()
li.sort()
for elo in li:
icono = rp.otro()
submenuElo = submenu.submenu(str(elo), icono)
lien = self.dicMotoresFixedElo[elo]
lien.sort(key=lambda x: x.nombre)
for cm in lien:
clave = FIXED, cm
texto = cm.nombre
submenuElo.opcion(clave, texto, icono)
submenuElo.separador()
menu.separador()
menu1 = menu.submenu(_("Opponents for young players"),
Iconos.RivalesMP())
for cm in self.liIrina:
menu1.opcion((IRINA, cm), cm.nombre, cm.icono)
menu.separador()
menu1 = menu.submenu(_("Lucas-Elo"), Iconos.Elo())
ico = QTVarios.rondoPuntos()
limenus = []
for x in range(1000, 2250, 250):
limenus.append(menu1.submenu("%d - %d" % (x, x + 250), ico.otro()))
for cm in self.liElo:
submenu = limenus[cm.elo / 250 - 4]
submenu.opcion((ELO, cm), cm.nombre, ico.otro())
return menu.lanza()
def creaMenu(self):
dicMenu = {}
menu = QTVarios.LCMenu(self.parent)
tpirat = Controles.TipoLetra("Chess Diagramm Pirat",
self.configuracion.puntosMenu + 4)
def xopcion(menu, clave, texto, icono, siDeshabilitado=False):
if "KP" in texto:
d = {"K": "r", "P": "w", "k": chr(126), "p": chr(134)}
k2 = texto.index("K", 2)
texto = texto[:k2] + texto[k2:].lower()
texton = ""
for c in texto:
texton += d[c]
menu.opcion(clave,
texton,
icono,
siDeshabilitado,
tipoLetra=tpirat)
else:
menu.opcion(clave, texto, icono, siDeshabilitado)
dicMenu[clave] = (clave, texto, icono, siDeshabilitado)
# Posiciones de entrenamiento --------------------------------------------------------------------------
self.menuFNS(menu, _("Training positions"), xopcion)
menu.separador()
# GM ---------------------------------------------------------------------------------------------------
xopcion(menu, "gm", _("Play like a Grandmaster"), Iconos.GranMaestro())
menu.separador()
xopcion(menu, "wgm", _("Play like a Woman Grandmaster"),
Iconos.WGranMaestro())
menu.separador()
# Mate --------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Training mates"), Iconos.Mate())
for mate in range(1, 5):
xopcion(menu1, "mate%d" % mate, _X(_("Mate in %1"), str(mate)),
Iconos.PuntoAzul())
menu1.separador()
menu.separador()
# BMT -------------------------------------------------------------------------------------------
xopcion(menu, "bmt", _("Find best move"), Iconos.BMT())
menu.separador()
# Resistencia ------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Resistance Test"), Iconos.Resistencia())
nico = Util.Rondo(Iconos.Verde(), Iconos.Azul(), Iconos.Amarillo(),
Iconos.Naranja())
xopcion(menu1, "resistance", _("Normal"), nico.otro())
xopcion(menu1, "resistancec", _("Blindfold chess"), nico.otro())
xopcion(menu1, "resistancep1", _("Hide only our pieces"), nico.otro())
xopcion(menu1, "resistancep2", _("Hide only opponent pieces"),
nico.otro())
menu.separador()
# DailyTest ------------------------------------------------------------------------------------------------
xopcion(menu, "dailytest", _("Your daily test"), Iconos.DailyTest())
menu.separador()
# Tacticas ---------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Learn tactics by repetition"),
Iconos.Tacticas())
nico = Util.Rondo(Iconos.Amarillo(), Iconos.Naranja(), Iconos.Verde(),
Iconos.Azul(), Iconos.Magenta())
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
def menuTacticas(submenu, tipo, carpetaBase, lista):
if os.path.isdir(carpetaBase):
for entry in scandir.scandir(carpetaBase):
if entry.is_dir():
carpeta = entry.path
ini = os.path.join(carpeta, "Config.ini")
if os.path.isfile(ini):
nombre = entry.name
xopcion(
submenu, "tactica|%s|%s|%s|%s" %
(tipo, nombre, carpeta, ini),
trTraining(nombre), nico.otro())
menu1.separador()
lista.append((carpeta, nombre))
else:
submenu1 = submenu.submenu(entry.name, nico.otro())
menuTacticas(submenu1, tipo, carpeta, lista)
return lista
menuTacticas(menu1, "B", "Tactics", [])
lista = []
carpetaTacticasP = os.path.join(self.configuracion.dirPersonalTraining,
"Tactics")
if os.path.isdir(carpetaTacticasP):
submenu1 = menu1.submenu(_("Personal tactics"), nico.otro())
lista = menuTacticas(submenu1, "P", carpetaTacticasP, lista)
if lista:
ico = Iconos.Delete()
menub = menu1.submenu(_("Remove"), ico)
for carpeta, nombre in lista:
xopcion(menub, "remtactica|%s|%s" % (carpeta, nombre),
trTraining(nombre), ico)
menu.separador()
# Openings ------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
# # Aperturas --------------------------------------------------------------------------------------------
xopcion(menu1, "aperturas", _("Learn openings by repetition"),
Iconos.Apertura())
menu1.separador()
# Books ------------------------------------------------------------------------------------------------
xopcion(menu1, "polyglot", _("Training with a book"), Iconos.Libros())
# Ratings
menu.separador()
menu1 = menu.submenu(_("Training ratings"), Iconos.Elo())
xopcion(menu1, "lucaselo",
"%s (%d)" % (_("Lucas-Elo"), self.configuracion.eloNC),
Iconos.Elo())
menu1.separador()
xopcion(menu1, "micelo",
"%s (%d)" % (_("Tourney-Elo"), self.configuracion.micheloNC),
Iconos.EloTimed())
menu1.separador()
fics = self.configuracion.ficsNC
menuf = menu1.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <=
(fics - elo) <= 400):
xopcion(menuf, "fics%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
menu1.separador()
fide = self.configuracion.fideNC
menuf = menu1.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
rp = QTVarios.rondoPuntos()
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <=
(fide - elo) <= 400):
xopcion(menuf, "fide%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
lichess = self.configuracion.lichessNC
menuf = menu1.submenu("%s (%d)" % (_("Lichess-Elo"), fide),
Iconos.Lichess())
rp = QTVarios.rondoPuntos()
for elo in range(800, 2700, 100):
if (elo == 800) or (0 <= (elo + 99 - lichess) <= 400 or 0 <=
(lichess - elo) <= 400):
xopcion(menuf, "fide%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
menu.separador()
# Longs ----------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Long-term trainings"), Iconos.Longhaul())
# Maps
menu2 = menu1.submenu(_("Training on a map"), Iconos.Maps())
xopcion(menu2, "map_Africa", _("Africa map"), Iconos.Africa())
menu2.separador()
xopcion(menu2, "map_WorldMap", _("World map"), Iconos.WorldMap())
# Rail
menu1.separador()
xopcion(menu1, "transsiberian", _("Transsiberian Railway"),
Iconos.Train())
# Everest
menu1.separador()
xopcion(menu1, "everest", _("Expeditions to the Everest"),
Iconos.Trekking())
# TOL
menu1.separador()
menu2 = menu1.submenu(_("Turn on the lights"), Iconos.TOL())
menu3 = menu2.submenu(_("Memory mode"), Iconos.TOL())
xopcion(menu3, "tol_uned_easy",
"%s (%s)" % (_("UNED chess school"), _("Initial")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uned",
"%s (%s)" % (_("UNED chess school"), _("Complete")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uwe_easy",
"%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe())
menu3.separador()
xopcion(menu3, "tol_uwe",
"%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe())
menu2.separador()
menu3 = menu2.submenu(_("Calculation mode"), Iconos.Calculo())
xopcion(menu3, "tol_uned_easy_calc",
"%s (%s)" % (_("UNED chess school"), _("Initial")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uned_calc",
"%s (%s)" % (_("UNED chess school"), _("Complete")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uwe_easy_calc",
"%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe())
menu3.separador()
xopcion(menu3, "tol_uwe_calc",
"%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe())
# Washing
menu1.separador()
xopcion(menu1, "washing_machine", _("The Washing Machine"),
Iconos.WashingMachine())
# Cebras ---------------------------------------------------------------------------------------------------
menu.separador()
menu1 = menu.submenu(_("Resources for zebras"), Iconos.Cebra())
menu2 = menu1.submenu(_("Check your memory on a chessboard"),
Iconos.Memoria())
rival = self.configuracion.rival
mem = Memoria.Memoria(self.procesador)
for x in range(6):
cat = rival.categorias.numero(x)
txt = cat.nombre()
nm = mem.nivel(x)
if nm >= 0:
txt += " %s %d" % (_("Level"), nm + 1)
xopcion(menu2,
-100 - x,
txt,
cat.icono(),
siDeshabilitado=not mem.siActiva(x))
menu1.separador()
menu2 = menu1.submenu(_("Find all moves"), Iconos.J60())
xopcion(menu2, "j60_rival", _("Opponent"), Iconos.PuntoNaranja())
xopcion(menu2, "j60_jugador", _("Player"), Iconos.PuntoAzul())
menu1.separador()
self.horsesDef = hd = {
1: ("N", "Alpha", _("Basic test")),
2: ("p", "Fantasy", _("Four pawns test")),
3: ("Q", "Pirat", _("Jonathan Levitt test")),
4: ("n", "Spatial", _("Basic test") + ": a1"),
5: ("N", "Cburnett", _("Basic test") + ": e4")
}
menu2 = menu1.submenu(_("Becoming a knight tamer"),
self.procesador.tablero.piezas.icono("N"))
vicon = VarGen.todasPiezas.icono
icl, icn, tit = hd[1]
menu3 = menu2.submenu(tit, vicon(icl, icn))
xopcion(menu3, "horses_1", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[4]
xopcion(menu3, "horses_4", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[5]
xopcion(menu3, "horses_5", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[2]
xopcion(menu2, "horses_2", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[3]
xopcion(menu2, "horses_3", tit, vicon(icl, icn))
menu1.separador()
menu2 = menu1.submenu(_("Moves between two positions"),
Iconos.Puente())
rp = QTVarios.rondoPuntos()
for x in range(1, 11):
xopcion(menu2, "puente_%d" % x, "%s %d" % (_("Level"), x),
rp.otro())
menu1.separador()
xopcion(menu1, "potencia", _("Determine your calculating power"),
Iconos.Potencia())
menu1.separador()
menu2 = menu1.submenu(_("Learn a game"), Iconos.School())
xopcion(menu2, "learnPGN", _("Memorizing their moves"),
Iconos.LearnGame())
menu2.separador()
xopcion(menu2, "playPGN", _("Playing against"), Iconos.Law())
menu1.separador()
xopcion(menu1, "visualiza", _("The board at a glance"), Iconos.Gafas())
# menu2 = menu1.submenu(_("Endings with 3/4 pieces"), Iconos.Puente())
# xopcion(menu2, "end_t4-1", "%s %d"%(_("Level"), 1), Iconos.PuntoAzul())
# xopcion(menu2, "end_t4-2", "%s %d"%(_("Level"), 2), Iconos.PuntoMagenta())
return menu, dicMenu
def __init__(self, wParent):
QtWidgets.QDialog.__init__(self, wParent)
self.wParent = wParent
self.fichero = ""
self.setWindowTitle(_("Create a new book"))
self.setWindowIcon(Iconos.Libros())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint)
f = Controles.TipoLetra(puntos=9, peso=75)
self.configuracion = Code.configuracion
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
lbFichero = Controles.LB(self, _("Book to create") + ":").ponFuente(f)
self.btFichero = Controles.PB(self, "", self.buscaFichero,
False).anchoMinimo(450).ponFuente(f)
lbMaxPly = Controles.LB(self,
_("Maximum no. half moves (ply)") +
":").ponFuente(f)
self.sbMaxPly = Controles.SB(self, 0, 0, 999).tamMaximo(50)
lbMinGame = Controles.LB(self,
_("Minimum number of games") +
":").ponFuente(f)
self.sbMinGame = Controles.SB(self, 3, 1, 999).tamMaximo(50)
lbMinScore = Controles.LB(self, _("Minimum score") + ":").ponFuente(f)
self.sbMinScore = Controles.SB(self, 0, 0, 100).tamMaximo(50)
self.chbOnlyWhite = Controles.CHB(self, _("White only"),
False).ponFuente(f)
self.chbOnlyBlack = Controles.CHB(self, _("Black only"),
False).ponFuente(f)
self.chbUniform = Controles.CHB(self, _("Uniform distribution"),
False).ponFuente(f)
lyf = Colocacion.H().control(lbFichero).control(self.btFichero)
ly = Colocacion.G().margen(15)
ly.otroc(lyf, 0, 0, 1, 2)
ly.controld(lbMaxPly, 1, 0).control(self.sbMaxPly, 1, 1)
ly.controld(lbMinGame, 2, 0).control(self.sbMinGame, 2, 1)
ly.controld(lbMinScore, 3, 0).control(self.sbMinScore, 3, 1)
ly.controlc(self.chbOnlyWhite, 4, 0, 1, 2)
ly.controlc(self.chbOnlyBlack, 5, 0, 1, 2)
ly.controlc(self.chbUniform, 6, 0, 1, 2)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), "aceptar"),
None,
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
None,
]
tb = Controles.TB(self, li_acciones)
# Layout
layout = Colocacion.V().control(tb).otro(ly).margen(3)
self.setLayout(layout)
def __init__(self, owner, configuration, opening_block):
icono = Iconos.Opening()
titulo = _("Select an opening")
extparam = "selectOpening"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
# Variables--------------------------------------------------------------------------
self.apStd = OpeningsStd.apTrain
self.configuration = configuration
self.game = Game.Game()
self.opening_block = opening_block
self.liActivas = []
# Board
config_board = configuration.config_board("APERTURAS", 32)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.player_has_moved)
# Current pgn
self.lbPGN = Controles.LB(self, "").set_wrap().ponTipoLetra(puntos=10, peso=75)
# Movimiento
self.is_moving_time = False
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self, "", siLibre=False, icon_size=24)
self.tbBM = tbBM
# Tool bar
tb = Controles.TBrutina(self)
tb.new(_("Accept"), Iconos.Aceptar(), self.aceptar)
tb.new(_("Cancel"), Iconos.Cancelar(), self.cancelar)
tb.new(_("Reinit"), Iconos.Reiniciar(), self.resetPartida)
tb.new(_("Takeback"), Iconos.Atras(), self.atras)
tb.new(_("Remove"), Iconos.Borrar(), self.borrar)
# Lista Openings
o_columns = Columnas.ListaColumnas()
dicTipos = {"b": Iconos.pmSun(), "n": Iconos.pmPuntoAzul(), "l": Iconos.pmNaranja()}
o_columns.nueva("TYPE", "", 24, edicion=Delegados.PmIconosBMT(dicIconos=dicTipos))
o_columns.nueva("OPENING", _("Possible continuation"), 480)
self.grid = Grid.Grid(self, o_columns, siSelecFilas=True, altoFila=32)
self.register_grid(self.grid)
# # Derecha
lyD = Colocacion.V().control(tb).control(self.grid)
gbDerecha = Controles.GB(self, "", lyD)
# # Izquierda
lyI = Colocacion.V().control(self.board).otro(lyBM).control(self.lbPGN)
gbIzquierda = Controles.GB(self, "", lyI)
splitter = QtWidgets.QSplitter(self)
splitter.addWidget(gbIzquierda)
splitter.addWidget(gbDerecha)
self.register_splitter(splitter, "splitter")
# Completo
ly = Colocacion.H().control(splitter).margen(3)
self.setLayout(ly)
self.ponActivas()
self.resetPartida()
self.actualizaPosicion()
dic = {"_SIZE_": "916,444", "SP_splitter": [356, 548]}
self.restore_video(dicDef=dic)
def __init__(self, owner, regFlecha, siNombre):
QtGui.QDialog.__init__(self, owner)
self.setWindowTitle(_("Arrow"))
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
self.siNombre = siNombre
if not regFlecha:
regFlecha = TabVisual.PFlecha()
liAcciones = [(_("Save"), Iconos.Aceptar(), "grabar"), None,
(_("Cancel"), Iconos.Cancelar(), "reject"), None,
]
tb = Controles.TB(self, liAcciones)
# Tablero
confTablero = owner.tablero.confTablero.copia(owner.tablero.confTablero.id())
confTablero.anchoPieza(32)
self.tablero = Tablero.TableroVisual(self, confTablero)
self.tablero.crea()
self.tablero.copiaPosicionDe(owner.tablero)
# Datos generales
liGen = []
if siNombre:
# nombre de la flecha que se usara en los menus del tutorial
config = FormLayout.Editbox(_("Name"), ancho=120)
liGen.append((config, regFlecha.nombre))
# ( "forma", "t", "a" ), # a = abierta -> , c = cerrada la cabeza, p = poligono cuadrado,
liFormas = (
(_("Opened"), "a"),
(_("Head closed"), "c"),
(_("Polygon 1"), "1"),
(_("Polygon 2"), "2"),
(_("Polygon 3"), "3"),
)
config = FormLayout.Combobox(_("Form"), liFormas)
liGen.append((config, regFlecha.forma))
# ( "tipo", "n", Qt.SolidLine ), #1=SolidLine, 2=DashLine, 3=DotLine, 4=DashDotLine, 5=DashDotDotLine
config = FormLayout.Combobox(_("Line Type"), QTUtil2.tiposDeLineas())
liGen.append((config, regFlecha.tipo))
# liGen.append( (None,None) )
# ( "color", "n", 0 ),
config = FormLayout.Colorbox(_("Color"), 80, 20)
liGen.append((config, regFlecha.color))
# ( "colorinterior", "n", -1 ), # si es cerrada
config = FormLayout.Colorbox(_("Internal color"), 80, 20, siChecked=True)
liGen.append((config, regFlecha.colorinterior))
# ( "opacidad", "n", 1.0 ),
config = FormLayout.Dial(_("Degree of transparency"), 0, 99)
liGen.append((config, 100 - int(regFlecha.opacidad * 100)))
# liGen.append( (None,None) )
# ( "redondeos", "l", False ),
liGen.append((_("Rounded edges"), regFlecha.redondeos))
# ( "grosor", "n", 1 ), # ancho del trazo
config = FormLayout.Spinbox(_("Thickness"), 1, 20, 50)
liGen.append((config, regFlecha.grosor))
# liGen.append( (None,None) )
# ( "altocabeza", "n", 1 ), # altura de la cabeza
config = FormLayout.Spinbox(_("Head height"), 0, 100, 50)
liGen.append((config, regFlecha.altocabeza))
# ( "ancho", "n", 10 ), # ancho de la base de la flecha si es un poligono
config = FormLayout.Spinbox(_("Base width"), 1, 100, 50)
liGen.append((config, regFlecha.ancho))
# ( "vuelo", "n", 5 ), # vuelo de la flecha respecto al ancho de la base
config = FormLayout.Spinbox(_("Additional width of the base of the head"), 1, 100, 50)
liGen.append((config, regFlecha.vuelo))
# ( "descuelgue", "n", 2 ), # vuelo hacia arriba
config = FormLayout.Spinbox(_("Height of the base angle of the head"), -100, 100, 50)
liGen.append((config, regFlecha.descuelgue))
# liGen.append( (None,None) )
# ( "destino", "t", "c" ), # c = centro, m = minimo
config = FormLayout.Combobox(_("Target position"), tiposDestino())
liGen.append((config, regFlecha.destino))
# liGen.append( (None,None) )
# orden
config = FormLayout.Combobox(_("Order concerning other items"), QTUtil2.listaOrdenes())
liGen.append((config, regFlecha.posicion.orden))
self.form = FormLayout.FormWidget(liGen, dispatch=self.cambios)
# Layout
layout = Colocacion.H().control(self.form).relleno().control(self.tablero)
layout1 = Colocacion.V().control(tb).otro(layout)
self.setLayout(layout1)
# Ejemplos
liMovs = ["d2d6", "a8h8", "h5b7"]
self.liEjemplos = []
for a1h8 in liMovs:
regFlecha.a1h8 = a1h8
regFlecha.siMovible = True
flecha = self.tablero.creaFlecha(regFlecha)
self.liEjemplos.append(flecha)
def __init__(self,
gestor,
xengine,
nombreOP,
position,
mrm,
rmOP,
rmUsu,
analisis,
siCompetitivo=None):
self.siCompetitivo = gestor.siCompetitivo if siCompetitivo is None else siCompetitivo
self.nombreOP = nombreOP
self.position = position
self.rmOP = rmOP
self.rmUsu = rmUsu
self.mrm = mrm
self.analysis = analisis
self.siAnalisisCambiado = False
self.xengine = xengine
self.gestor = gestor
self.list_rm, self.posOP = self.do_lirm()
titulo = _("Analysis")
icono = Iconos.Analizar()
extparam = "jzgm"
QTVarios.WDialogo.__init__(self, gestor.main_window, titulo, icono,
extparam)
self.colorNegativo = QTUtil.qtColorRGB(255, 0, 0)
self.colorImpares = QTUtil.qtColorRGB(231, 244, 254)
self.lbComentario = Controles.LB(
self, "").ponTipoLetra(puntos=10).alinCentrado()
config_board = gestor.configuracion.config_board("JUICIO", 32)
self.tablero = Tablero.Tablero(self, config_board)
self.tablero.crea()
self.tablero.ponerPiezasAbajo(position.is_white)
self.lbMotor = Controles.LB(self).alinCentrado()
self.lbTiempo = Controles.LB(self).alinCentrado()
liMas = ((_("Close"), "close", Iconos.AceptarPeque()), )
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self,
"",
siLibre=False,
tamIcon=24,
siMas=gestor.continueTt,
liMasAcciones=liMas)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("POSREAL", "#", 40, centered=True)
o_columns.nueva("JUGADAS",
"%d %s" % (len(self.list_rm), _("Moves")),
120,
centered=True)
o_columns.nueva("PLAYER", _("Player"), 120)
self.grid = Grid.Grid(self, o_columns, siSelecFilas=True)
lyT = Colocacion.V().control(self.tablero).otro(lyBM).control(
self.lbComentario)
# Layout
layout = Colocacion.H().otro(lyT).control(self.grid)
self.setLayout(layout)
self.grid.setFocus()
self.grid.goto(self.posOP, 0)
self.is_moving_time = False
self.ponPuntos()
def __init__(self, gestor, xmotor, nombreOP, posicion, mrm, rmOP, rmUsu,
analisis):
self.siCompetitivo = gestor.siCompetitivo
self.nombreOP = nombreOP
self.posicion = posicion
self.rmOP = rmOP
self.rmUsu = rmUsu
self.mrm = mrm
self.analisis = analisis
self.xmotor = xmotor
self.gestor = gestor
self.listaRM, self.posOP = self.hazListaRM()
self.posicion = posicion
titulo = _("Analysis")
icono = Iconos.Analizar()
extparam = "jzgm"
QTVarios.WDialogo.__init__(self, gestor.pantalla, titulo, icono,
extparam)
self.colorNegativo = QTUtil.qtColorRGB(255, 0, 0)
self.colorImpares = QTUtil.qtColorRGB(231, 244, 254)
self.lbComentario = Controles.LB(
self, "").ponTipoLetra(puntos=10).alinCentrado()
confTablero = VarGen.configuracion.confTablero("JUICIO", 32)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponerPiezasAbajo(posicion.siBlancas)
self.lbMotor = Controles.LB(self).alinCentrado()
self.lbTiempo = Controles.LB(self).alinCentrado()
liMas = ((_("Close"), "close", Iconos.Delete()), )
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self,
"",
siLibre=True,
tamIcon=24,
siMas=True,
liMasAcciones=liMas)
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("POSREAL", "#", 40, siCentrado=True)
oColumnas.nueva("JUGADAS",
"%d %s" % (len(self.listaRM), _("Moves")),
120,
siCentrado=True)
oColumnas.nueva("PLAYER", _("Player"), 120)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True)
lyT = Colocacion.V().control(self.tablero).otro(lyBM).control(
self.lbComentario)
# Layout
layout = Colocacion.H().otro(lyT).control(self.grid)
self.setLayout(layout)
self.grid.setFocus()
self.grid.goto(self.posOP, 0)
self.siMoviendoTiempo = False
self.ponPuntos()
def __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 = QTVarios.LCTB(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()
# # Color
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
lyG = nuevoG()
self.cbAtras = Controles.CHB(self, _("Takeback"), True)
self.chbSummary = Controles.CHB(self, _("Save a summary when the game is finished in the main comment"), False)
# # Tutor
lbAyudas = Controles.LB2P(self, _("Available hints"))
liAyudas = [(_("Maximum"), 99)]
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, 99)
self.chbChance = 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))
lbThoughtTt = Controles.LB(self, _("It is showed") + ":")
self.cbThoughtTt = Controles.CB(self, liThinks, -1)
self.chbContinueTt = 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)
lbArrows = Controles.LB2P(self, _("Arrows with the best moves"))
self.sbArrowsTt = Controles.SB(self, 3, 0, 999).tamMaximo(50)
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, _("Tutor"), ly)
self.gbTutor.setCheckable(True)
self.gbTutor.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)
ly = Colocacion.H().control(lb).control(self.cbThoughtOp).relleno()
ly.control(lbArrows).control(self.sbArrows).relleno()
gbThoughtOp = Controles.GB(self, _("Thought of the opponent"), ly)
gbThoughtOp.setStyleSheet(gbStyle)
ly = Colocacion.V().espacio(16).control(self.gbTutor).espacio(16).control(gbThoughtOp)
ly.espacio(16).control(self.cbAtras).control(self.chbSummary)
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)
gb = Controles.GB(self, "", lyG)
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 lanzaGUI(procesador):
"""
Lanzador del interfaz grafico de la aplicacion.
"""
# Comprobamos el lenguaje
app = QtWidgets.QApplication([])
liUsuarios = Usuarios.Usuarios().lista
usuario = None
if liUsuarios:
usuario = pideUsuario(liUsuarios)
if usuario is None:
return
user = str(usuario.numero) if usuario.numero else ""
else:
user = ""
activeFolder = Configuracion.activeFolder()
siPedirLenguaje = not os.path.isdir(activeFolder) or not os.listdir(
activeFolder)
procesador.iniciaConUsuario(user)
configuracion = procesador.configuracion
if usuario:
if not configuracion.jugador:
configuracion.jugador = usuario.nombre
configuracion.graba()
elif configuracion.jugador != usuario.nombre:
for usu in liUsuarios:
if usu.numero == usuario.numero:
usu.nombre = configuracion.jugador
Usuarios.Usuarios().guardaLista(liUsuarios)
# Comprobamos el lenguaje
if siPedirLenguaje and not configuracion.traductor:
if user:
confMain = Configuracion.Configuracion("")
ori = confMain.ficheroMExternos
confMain.lee()
confMain.limpia(usuario.nombre)
confMain.ponCarpetas(user)
confMain.graba()
procesador.configuracion = confMain
Util.copiaFichero(ori, confMain.carpeta)
else:
li = configuracion.listaTraducciones()
menu = QTVarios.LCMenu(None)
nico = QTVarios.rondoPuntos()
for k, nombre, porc, author in li:
rotulo = nombre
if porc != "100":
rotulo += " (%s%%)" % porc
menu.opcion(k, nombre, nico.otro())
resp = menu.lanza()
if resp:
configuracion.traductor = resp
configuracion.graba()
# Estilo
app.setStyle(QtWidgets.QStyleFactory.create(configuracion.estilo))
if configuracion.palette:
qpalette = QtGui.QPalette()
palette = configuracion.palette
def cl(tipo):
return QtGui.QColor(palette[tipo])
qpalette.setColor(QtGui.QPalette.Window, cl("Window"))
qpalette.setColor(QtGui.QPalette.WindowText, cl("WindowText"))
qpalette.setColor(QtGui.QPalette.Base, cl("Base"))
qpalette.setColor(QtGui.QPalette.Text, cl("Text"))
qpalette.setColor(QtGui.QPalette.AlternateBase, cl("AlternateBase"))
qpalette.setColor(QtGui.QPalette.ToolTipBase, cl("ToolTipBase"))
qpalette.setColor(QtGui.QPalette.ToolTipText, cl("ToolTipText"))
qpalette.setColor(QtGui.QPalette.Button, cl("Button"))
qpalette.setColor(QtGui.QPalette.ButtonText, cl("ButtonText"))
qpalette.setColor(QtGui.QPalette.BrightText, cl("BrightText"))
qpalette.setColor(QtGui.QPalette.Link, cl("Link"))
else:
qpalette = QtWidgets.QApplication.style().standardPalette()
app.setPalette(qpalette)
app.setEffectEnabled(QtCore.Qt.UI_AnimateMenu)
QtGui.QFontDatabase.addApplicationFont('IntFiles/PIRATDIA.TTF')
if configuracion.familia:
font = Controles.TipoLetra(configuracion.familia)
app.setFont(font)
VarGen.gc = QTUtil.GarbageCollector()
# Lanzamos la pantalla
procesador.iniciarGUI()
def cleanUp():
print("aboutToQuit cleanUp")
app.aboutToQuit.connect(cleanUp)
sys.exit(app.exec_())
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
liAcciones = [(_("Accept"), Iconos.Aceptar(), "aceptar"), None,
(_("Cancel"), Iconos.Cancelar(), "cancelar"), None,
]
tb = Controles.TB(self, liAcciones)
# Blancas o negras
self.rbBlancas = Controles.RB(self, _("White")).activa()
self.rbNegras = Controles.RB(self, _("Black"))
# Atras
self.cbAtras = Controles.CHB(self, "", True)
# Motores
self.motores = Motores.Motores(configuracion)
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
# # Rival
self.rival = 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, "", self.cambiaPersonalidades, plano=False).ponIcono(Iconos.Nuevo(),
tamIcon=16)
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)
# Atras
hbox = Colocacion.H().espacio(10).control(self.cbAtras)
gbAtras = Controles.GB(self, _("Takeback"), hbox).alinCentrado()
## Color + Atras
hAC = Colocacion.H().control(gbColor).control(gbAtras)
if siGestorSolo:
# gbColor.hide()
gbAtras.hide()
# 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(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, owner, db_coordinates, coordinates):
QTVarios.WDialogo.__init__(self, owner, _("Coordinates by blocks"), Iconos.Blocks(), "runcoordinatesblocks")
self.configuracion = Code.configuracion
self.coordinates = coordinates
self.db_coordinates = db_coordinates
self.current_score = 0
self.working = False
self.time_ini = None
conf_board = self.configuracion.config_board("RUNCOORDINATESBLOCKS", self.configuracion.size_base())
self.board = Tablero.TableroEstaticoMensaje(self, conf_board, None, 0.6)
self.board.crea()
self.board.bloqueaRotacion(True)
self.cp_initial = Position.Position()
self.cp_initial.set_pos_initial()
font = Controles.TipoLetra(puntos=self.configuracion.x_sizefont_infolabels)
lb_block_k = Controles.LB(self, _("Block") + ":").ponFuente(font)
self.lb_block = Controles.LB(self).ponFuente(font)
lb_try_k = Controles.LB(self, _("Tries in this block") + ":").ponFuente(font)
self.lb_try = Controles.LB(self).ponFuente(font)
lb_minimum_score_k = Controles.LB(self, _("Minimum score") + ":").ponFuente(font)
self.lb_minimum_score = Controles.LB(self).ponFuente(font)
lb_current_score_block_k = Controles.LB(self, _("Max score in block") + ":").ponFuente(font)
self.lb_current_score_block = Controles.LB(self).ponFuente(font)
self.lb_current_score_enough = Controles.LB(self).ponImagen(Iconos.pmCorrecto())
self.lb_current_score_enough.hide()
self.lb_active_score_k = Controles.LB(self, _("Active score") + ":").ponFuente(font)
self.lb_active_score = Controles.LB(self).ponFuente(font)
li_acciones = ((_("Close"), Iconos.MainMenu(), self.terminar), None, (_("Begin"), Iconos.Empezar(), self.begin), (_("Continue"), Iconos.Pelicula_Seguir(), self.seguir))
self.tb = QTVarios.LCTB(self, li_acciones)
self.show_tb(self.terminar, self.begin)
separacion = 20
ly_info = Colocacion.G()
ly_info.controld(lb_block_k, 0, 0).controld(self.lb_block, 0, 1)
ly_info.filaVacia(1, separacion)
ly_info.controld(lb_try_k, 2, 0).controld(self.lb_try, 2, 1)
ly_info.filaVacia(3, separacion)
ly_info.controld(lb_minimum_score_k, 4, 0).controld(self.lb_minimum_score, 4, 1)
ly_info.filaVacia(5, separacion)
ly_info.controld(lb_current_score_block_k, 6, 0).controld(self.lb_current_score_block, 6, 1)
ly_info.filaVacia(7, separacion)
ly_info.controld(self.lb_active_score_k, 8, 0).controld(self.lb_active_score, 8, 1)
ly_right = Colocacion.V().control(self.tb).relleno().otro(ly_info).relleno()
w = QtWidgets.QWidget(self)
w.setLayout(ly_right)
w.setMinimumWidth(240)
ly_center = Colocacion.H().control(self.board).control(w).margen(3)
self.setLayout(ly_center)
self.restore_video()
self.show_data()
self.adjustSize()
def __init__(self, gestor, tutor, siRival, siAperturas, siBlancas,
siPuntos):
titulo = _("Analyzing your move")
icono = Iconos.Tutor()
extparam = "tutor"
QTVarios.WDialogo.__init__(self, gestor.pantalla, titulo, icono,
extparam)
self.tutor = tutor
self.gestor0 = gestor.gestor
self.respLibro = None
self.siElegidaApertura = False
self.vistaTutor = gestor.procesador.configuracion.vistaTutor
# ~ self.setStyleSheet("QDialog,QGroupBox { background: #f0f0f0; }")
f = Controles.TipoLetra(puntos=12, peso=75)
flb = Controles.TipoLetra(puntos=10)
flba = Controles.TipoLetra(puntos=8)
ae = QTUtil.anchoEscritorio()
mx = 32 if ae > 1000 else 20
confTablero = VarGen.configuracion.confTablero("TUTOR", mx)
# Tableros
def creaTablero(nombre, si=True, siLibre=True, siMas=False):
if not si:
return None, None, None
tablero = Tablero.Tablero(self, confTablero)
tablero.crea()
tablero.ponerPiezasAbajo(siBlancas)
lytb, tb = QTVarios.lyBotonesMovimiento(self,
nombre,
siLibre,
siMas=siMas)
return tablero, lytb, tb
self.tableroTutor, lytbTutor, self.tbTutor = creaTablero("tutor")
self.tableroUsuario, lytbUsuario, self.tbUsuario = creaTablero(
"usuario")
self.tableroRival, lytbRival, self.tbRival = creaTablero(
"rival", siRival)
self.tableroApertura, lytbApertura, self.tbApertura = creaTablero(
"apertura", siAperturas, siLibre=False)
tutor.ponTablerosGUI(self.tableroTutor, self.tableroUsuario,
self.tableroRival, self.tableroApertura)
# Puntuaciones
self.lbTutorPuntuacion = Controles.LB(self).alinCentrado().ponFuente(
flb)
self.lbUsuarioPuntuacion = Controles.LB(self).alinCentrado().ponFuente(
flb)
if siRival:
self.lbRivalPuntuacion = Controles.LB(
self).alinCentrado().ponFuente(flb)
# Aperturas
if siAperturas:
liOpciones = self.tutor.opcionesAperturas()
self.cbAperturas = Controles.CB(self, liOpciones, 0)
self.cbAperturas.setFont(flba)
self.connect(self.cbAperturas,
QtCore.SIGNAL("currentIndexChanged(int)"),
self.tutor.cambiarApertura)
# RM
liRM = []
for n, uno in enumerate(tutor.listaRM):
liRM.append((uno[1], n))
self.cbRM, self.lbRM = QTUtil2.comboBoxLB(self, liRM, liRM[0][1],
_("Moves analyzed"))
self.connect(self.cbRM, QtCore.SIGNAL("currentIndexChanged (int)"),
tutor.cambiadoRM)
lyRM = Colocacion.H().control(self.lbRM).control(self.cbRM)
lyTutor = Colocacion.V().relleno().control(
self.lbTutorPuntuacion).relleno()
gbTutor = Controles.GB(self, _("Tutor's suggestion"),
lyTutor).ponFuente(f).alinCentrado()
if siPuntos:
gbTutor.conectar(self.elegirTutor)
self.lbTutorPuntuacion.setEnabled(True)
lyUsuario = Colocacion.V().relleno().control(
self.lbUsuarioPuntuacion).relleno()
gbUsuario = Controles.GB(
self, _("Your move"),
lyUsuario).ponFuente(f).alinCentrado().conectar(self.elegirUsuario)
self.lbUsuarioPuntuacion.setEnabled(True)
btLibros = Controles.PB(self, _("Consult a book"),
self.consultaLibro).ponPlano(False)
if siRival:
lyRival = Colocacion.V().relleno().control(
self.lbRivalPuntuacion).relleno()
gbRival = Controles.GB(self, _("Opponent's prediction"),
lyRival).ponFuente(f).alinCentrado()
if siAperturas:
lyAperturas = Colocacion.V().relleno().control(
self.cbAperturas).relleno()
gbAperturas = Controles.GB(self, _("Opening"),
lyAperturas).alinCentrado().ponFuente(f)
if siPuntos:
gbAperturas.conectar(self.elegirApertura)
self.cbAperturas.setEnabled(True)
self.tutor.cambiarApertura(0)
dicVista = {
kTutorH: ((0, 1), (0, 2)),
kTutorH2_1: ((0, 1), (4, 0)),
kTutorH1_2: ((4, 0), (4, 1)),
kTutorV: ((4, 0), (8, 0))
}
usu, riv = dicVista[self.vistaTutor]
fu, cu = usu
fr, cr = riv
layout = Colocacion.G()
layout.controlc(gbTutor, 0, 0).controlc(self.tableroTutor, 1,
0).otro(lytbTutor, 2,
0).otroc(lyRM, 3, 0)
layout.controlc(gbUsuario, fu,
cu).controlc(self.tableroUsuario, fu + 1, cu).otro(
lytbUsuario, fu + 2,
cu).controlc(btLibros, fu + 3, cu)
if siRival:
layout.controlc(gbRival, fr,
cr).controlc(self.tableroRival, fr + 1,
cr).otro(lytbRival, fr + 2, cr)
elif siAperturas:
layout.controlc(gbAperturas, fr,
cr).controlc(self.tableroApertura, fr + 1,
cr).otro(lytbApertura, fr + 2, cr)
layout.margen(8)
self.setLayout(layout)
self.recuperarVideo(siTam=False)
