def __init__(self, is_white_bottom):
QtWidgets.QWidget.__init__(self)
config_board = Code.configuration.config_board("INFOMOVE", 32)
self.main_window = self
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.ponerPiezasAbajo(is_white_bottom)
btInicio = Controles.PB(self, "", self.start).ponIcono(Iconos.MoverInicio())
btAtras = Controles.PB(self, "", self.atras).ponIcono(Iconos.MoverAtras())
btAdelante = Controles.PB(self, "", self.adelante).ponIcono(Iconos.MoverAdelante())
btFinal = Controles.PB(self, "", self.final).ponIcono(Iconos.MoverFinal())
self.lbAnalisis = Controles.LB(self, "")
lybt = Colocacion.H().relleno()
for x in (btInicio, btAtras, btAdelante, btFinal):
lybt.control(x)
lybt.relleno()
lyt = Colocacion.H().relleno().control(self.board).relleno()
lya = Colocacion.H().relleno().control(self.lbAnalisis).relleno()
layout = Colocacion.V()
layout.otro(lyt)
layout.otro(lybt)
layout.otro(lya)
layout.relleno()
self.setLayout(layout)
self.movActual = None
def __init__(self, wowner, configuration, path_lcbin):
self.title = os.path.basename(path_lcbin)[:-6]
QTVarios.WDialogo.__init__(self, wowner, self.title, Iconos.Book(), "polyglot")
self.configuration = configuration
self.path_lcbin = path_lcbin
self.owner = wowner
self.db_entries = DBPolyglot.DBPolyglot(path_lcbin)
self.pol_import = PolyglotImportExports.PolyglotImport(self)
self.pol_export = PolyglotImportExports.PolyglotExport(self)
self.li_moves = []
self.history = []
conf_board = configuration.config_board("WPOLYGLOT", 48)
self.board = Board.Board(self, conf_board)
self.board.crea()
self.board.set_dispatcher(self.mensajero)
self.with_figurines = configuration.x_pgn_withfigurines
o_columnas = Columnas.ListaColumnas()
delegado = Delegados.EtiquetaPOS(True, siLineas=False) if self.configuration.x_pgn_withfigurines else None
o_columnas.nueva("move", _("Move"), 80, centered=True, edicion=delegado, siEditable=False)
o_columnas.nueva("%", "%", 60, siDerecha=True, siEditable=False)
o_columnas.nueva("weight", _("Weight"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
o_columnas.nueva("score", _("Score"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
o_columnas.nueva("depth", _("Depth"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
o_columnas.nueva("learn", _("Learn"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
self.grid_moves = Grid.Grid(self, o_columnas, siEditable=True)
self.grid_moves.setMinimumWidth(self.grid_moves.anchoColumnas() + 20)
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Takeback"), Iconos.Atras(), self.takeback),
None,
(_("Voyager"), Iconos.Voyager32(), self.voyager),
None,
(_("Import"), Iconos.Import8(), self.pol_import.importar),
None,
(_("Create book"), Iconos.BinBook(), self.pol_export.exportar),
None,
)
self.tb = Controles.TBrutina(self, li_acciones)
ly2 = Colocacion.V().control(self.tb).control(self.grid_moves)
layout = Colocacion.H().control(self.board).otro(ly2)
self.setLayout(layout)
self.restore_video()
self.position = None
position = Position.Position()
position.set_pos_initial()
self.set_position(position, True)
def create_board(name, si=True, siLibre=True, siMas=False):
if not si:
return None, None, None
board = Board.Board(self, config_board)
board.crea()
board.ponerPiezasAbajo(is_white)
lytb, tb = QTVarios.lyBotonesMovimiento(self, name, siLibre, siMas=siMas)
return board, lytb, tb
def __init__(self, owner, liFens, engine, segundos, fns):
super(WDailyTest, self).__init__(owner, _("Your daily test"),
Iconos.DailyTest(), "nivel")
self.procesador = owner.procesador
self.configuration = self.procesador.configuration
if engine.startswith("*"):
engine = engine[1:]
confMotor = self.configuration.buscaTutor(engine)
self.xtutor = self.procesador.creaManagerMotor(confMotor,
segundos * 1000, None)
self.xtutor.maximizaMultiPV()
self.historico = owner.historico
# Board
config_board = self.configuration.config_board("LEVEL", 48)
self.liFens = liFens
self.nFens = len(self.liFens)
self.juego = 0
self.liPuntos = []
self.li_pv = []
self.li_tiempos = []
self.fns = fns
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.player_has_moved)
# Rotulos informacion
self.lbColor = Controles.LB(self, "").set_wrap().anchoMinimo(200)
self.lbJuego = Controles.LB(self, "").align_center()
# Tool bar
li_acciones = (
# ( _( "Start" ), Iconos.Empezar(), "empezar" ),
(_("Analysis"), Iconos.Tutor(), "analizar"),
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
(_("Continue"), Iconos.Pelicula_Seguir(), "seguir"),
(_("Resign"), Iconos.Abandonar(), "abandonar"),
)
self.tb = Controles.TB(self, li_acciones)
lyT = Colocacion.V().control(self.board).relleno()
lyV = Colocacion.V().control(self.lbJuego).relleno().control(
self.lbColor).relleno(2)
lyTV = Colocacion.H().otro(lyT).otro(lyV)
ly = Colocacion.V().control(self.tb).otro(lyTV)
self.setLayout(ly)
self.position = Position.Position()
self.restore_video()
self.play_next_move()
def __init__(self, wparent, game):
self.game = game
self.wparent = wparent
self.configuration = configuration = Code.configuration
QtWidgets.QWidget.__init__(self, wparent)
li_acciones = (
(_("Save"), Iconos.Grabar(), self.save),
None,
(_("Cancel"), Iconos.Cancelar(), self.wparent.cancelar),
None,
(_("Start position"), Iconos.Datos(), self.inicial),
None,
(_("Clear"), Iconos.Borrar(), self.limpia),
None,
(_("Take back"), Iconos.Atras(), self.atras),
None,
)
self.tb = Controles.TBrutina(self,
li_acciones,
with_text=False,
icon_size=20)
config_board = configuration.config_board("VOYAGERPGN", 24)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.player_has_moved)
Delegados.generaPM(self.board.piezas)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUMBER", _("N."), 35, centered=True)
self.si_figurines_pgn = configuration.x_pgn_withfigurines
nAnchoColor = (self.board.ancho - 35 - 20) // 2
o_columns.nueva("WHITE",
_("White"),
nAnchoColor,
edicion=Delegados.EtiquetaPGN(
True if self.si_figurines_pgn else None))
o_columns.nueva("BLACK",
_("Black"),
nAnchoColor,
edicion=Delegados.EtiquetaPGN(
False if self.si_figurines_pgn else None))
self.pgn = Grid.Grid(self,
o_columns,
siCabeceraMovible=False,
siSelecFilas=True)
self.pgn.setMinimumWidth(self.board.ancho)
ly = Colocacion.V().control(self.tb).control(self.board)
ly.control(self.pgn)
ly.margen(1)
self.setLayout(ly)
self.board.set_position(self.game.last_position)
self.play_next_move()
def __init__(self, owner, regSVG, xml=None, name=None):
QtWidgets.QDialog.__init__(self, owner)
self.setWindowTitle(_("Image"))
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
self.configuration = Code.configuration
if not regSVG:
regSVG = TabVisual.PSVG()
regSVG.xml = xml
if name:
regSVG.name = name
li_acciones = [(_("Save"), Iconos.Aceptar(), "grabar"), None, (_("Cancel"), Iconos.Cancelar(), "reject"), None]
tb = Controles.TB(self, li_acciones)
# Board
config_board = owner.board.config_board
self.board = Board.Board(self, config_board, siDirector=False)
self.board.crea()
self.board.copiaPosicionDe(owner.board)
# Datos generales
liGen = []
# name del svg que se usara en los menus del tutorial
config = FormLayout.Editbox(_("Name"), ancho=120)
liGen.append((config, regSVG.name))
# ( "opacity", "n", 1.0 ),
config = FormLayout.Dial(_("Degree of transparency"), 0, 99)
liGen.append((config, 100 - int(regSVG.opacity * 100)))
# ( "psize", "n", 100 ),
config = FormLayout.Spinbox(_("Size") + " %", 1, 1600, 50)
liGen.append((config, regSVG.psize))
# orden
config = FormLayout.Combobox(_("Order concerning other items"), QTUtil2.listaOrdenes())
liGen.append((config, regSVG.physical_pos.orden))
self.form = FormLayout.FormWidget(liGen, dispatch=self.cambios)
# Layout
layout = Colocacion.H().control(self.form).relleno().control(self.board)
layout1 = Colocacion.V().control(tb).otro(layout)
self.setLayout(layout1)
# Ejemplos
liMovs = ["b4c4", "e2e2", "e4g7"]
self.liEjemplos = []
for a1h8 in liMovs:
regSVG.a1h8 = a1h8
regSVG.siMovible = True
svg = self.board.creaSVG(regSVG, siEditando=True)
self.liEjemplos.append(svg)
def __init__(self, manager, xengine, nombreOP, position, mrm, rmOP, rmUsu, analysis, is_competitive=None):
self.is_competitive = manager.is_competitive if is_competitive is None else is_competitive
self.nombreOP = nombreOP
self.position = position
self.rmOP = rmOP
self.rmUsu = rmUsu
self.mrm = mrm
self.analysis = analysis
self.siAnalisisCambiado = False
self.xengine = xengine
self.manager = manager
self.list_rm, self.posOP = self.do_lirm()
titulo = _("Analysis")
icono = Iconos.Analizar()
extparam = "jzgm"
QTVarios.WDialogo.__init__(self, manager.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).align_center()
config_board = manager.configuration.config_board("JUICIO", 32)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.ponerPiezasAbajo(position.is_white)
self.lbMotor = Controles.LB(self).align_center()
self.lbTiempo = Controles.LB(self).align_center()
liMas = ((_("Close"), "close", Iconos.AceptarPeque()),)
lyBM, tbBM = QTVarios.lyBotonesMovimiento(
self, "", siLibre=False, icon_size=24, siMas=manager.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.board).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 create_board(self):
ae = QTUtil.altoEscritorio()
mx = int(ae * 0.08)
config_board = self.manager.configuration.config_board("BASE", mx)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.setFocus()
Delegados.generaPM(self.board.piezas)
def __init__(self, owner, list_markers, dbMarkers):
titulo = _("Markers")
icono = Iconos.Markers()
extparam = "markers"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.owner = owner
flb = Controles.TipoLetra(puntos=8)
self.configuration = Code.configuration
self.liPMarkers = list_markers
self.dbMarkers = dbMarkers
# Lista
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUMBER", _("N."), 60, centered=True)
o_columns.nueva("NOMBRE", _("Name"), 256)
self.grid = Grid.Grid(self, o_columns, xid="M", siSelecFilas=True)
li_acciones = [
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("New"), Iconos.Nuevo(), self.mas),
None,
(_("Remove"), Iconos.Borrar(), self.borrar),
None,
(_("Modify"), Iconos.Modificar(), self.modificar),
None,
(_("Copy"), Iconos.Copiar(), self.copiar),
None,
(_("Up"), Iconos.Arriba(), self.arriba),
None,
(_("Down"), Iconos.Abajo(), self.abajo),
None,
]
tb = Controles.TBrutina(self, li_acciones)
tb.setFont(flb)
ly = Colocacion.V().control(tb).control(self.grid)
# Board
config_board = self.configuration.config_board("EDIT_GRAPHICS", 48)
self.board = Board.Board(self, config_board, siDirector=False)
self.board.crea()
self.board.copiaPosicionDe(owner.board)
# Layout
layout = Colocacion.H().otro(ly).control(self.board)
self.setLayout(layout)
self.grid.gotop()
self.grid.setFocus()
def __init__(self, owner, db_coordinates, is_white):
QTVarios.WDialogo.__init__(self, owner, _("Coordinates"),
Iconos.Blocks(), "runcoordinatesbasic")
self.configuration = Code.configuration
self.is_white = is_white
self.db_coordinates = db_coordinates
self.coordinates = None
self.current_score = 0
self.working = False
self.time_ini = None
conf_board = self.configuration.config_board(
"RUNCOORDINATESBASIC", self.configuration.size_base())
self.board = Board.BoardEstaticoMensaje(self, conf_board, None, 0.6)
self.board.crea()
self.board.bloqueaRotacion(True)
self.cp_initial = Position.Position()
self.cp_initial.set_pos_initial()
self.board.ponerPiezasAbajo(self.is_white)
self.board.set_position(self.cp_initial)
font = Controles.TipoLetra(puntos=26, peso=500)
lb_score_k = Controles.LB(self, _("Score")).ponFuente(font)
self.lb_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)
ly_info = Colocacion.G()
ly_info.controlc(lb_score_k, 0, 0).controlc(self.lb_score, 1, 0)
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.adjustSize()
def __init__(self, owner, test, procesador, titulo, icono):
QTVarios.WDialogo.__init__(self, owner, titulo, icono, "horses")
self.historico = owner.historico
self.procesador = owner.procesador
self.configuration = self.procesador.configuration
self.test = test
# Board
config_board = self.configuration.config_board("HORSES", 48)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.player_has_moved)
# Rotulo vtime
self.lbInformacion = Controles.LB(
self,
_("Goal: to capture the king up to the square a8")).align_center()
self.lbMoves = Controles.LB(self, "")
# Tool bar
li_acciones = (
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Reinit"), Iconos.Reiniciar(), self.reiniciar),
None,
(_("Help"), Iconos.AyudaGR(), self.ayuda),
)
self.tb = Controles.TBrutina(self, li_acciones)
# Layout
lyInfo = Colocacion.H().control(self.lbInformacion).relleno().control(
self.lbMoves)
lyT = Colocacion.V().relleno().control(
self.board).otro(lyInfo).relleno().margen(10)
ly = Colocacion.V().control(self.tb).otro(lyT).relleno().margen(0)
self.setLayout(ly)
self.restore_video()
self.adjustSize()
self.reset()
def __init__(self, file_tournament, file_work):
QtWidgets.QWidget.__init__(self)
Code.list_engine_managers = EngineManager.ListEngineManagers()
self.torneo = TournamentRun(
file_tournament) # Tournament.Tournament(file_tournament)
self.file_work = file_work
self.db_work = UtilSQL.ListSQL(file_work)
self.slow_pieces = self.torneo.slow_pieces()
self.setWindowTitle(
"%s - %s %d" %
(self.torneo.name(), _("Worker"), int(file_work[-5:])))
self.setWindowIcon(Iconos.Torneos())
# Toolbar
self.tb = Controles.TBrutina(self, icon_size=24)
# Board
conf_board = Code.configuration.config_board("TOURNEYPLAY", 36)
self.board = Board.Board(self, conf_board)
self.board.crea()
Delegados.generaPM(self.board.piezas)
# PGN
self.configuration = Code.configuration
self.game = Game.Game()
self.pgn = ControlPGN.ControlPGN(self)
ly_pgn = self.crea_bloque_informacion()
self.is_closed = False
self.state = None
self.current_side = WHITE
ly_tt = Colocacion.V().control(self.tb).control(self.board)
layout = Colocacion.H().otro(ly_tt).otro(ly_pgn).relleno().margen(3)
self.setLayout(layout)
self.cpu = CPU.CPU(self)
self.pon_estado(ST_WAITING)
def __init__(self, cpu, icon):
QtWidgets.QDialog.__init__(self)
self.setWindowTitle(cpu.titulo)
self.setWindowIcon(icon)
self.cpu = cpu
self.siPlay = True
self.kibitzer = cpu.kibitzer
self.type = cpu.tipo
self.dicVideo = self.cpu.dic_video
if not self.dicVideo:
self.dicVideo = {}
self.game = None
self.li_moves = []
self.is_black = True
self.is_white = True
self.siTop = self.dicVideo.get("SITOP", True)
self.show_board = self.dicVideo.get("SHOW_BOARD", True)
self.nArrows = self.dicVideo.get(
"NARROWS", 1 if cpu.tipo == Kibitzers.KIB_THREATS else 2)
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)
if not self.show_board:
self.board.hide()
self.with_figurines = cpu.configuration.x_pgn_withfigurines
def __init__(self, is_white_bottom, fenActivo):
QtWidgets.QWidget.__init__(self)
config_board = Code.configuration.config_board("INFOMOVE", 32)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.ponerPiezasAbajo(is_white_bottom)
self.cpDefecto = Position.Position()
self.cpDefecto.read_fen(fenActivo)
self.porDefecto()
btInicio = Controles.PB(self, "",
self.start).ponIcono(Iconos.MoverInicio())
btAtras = Controles.PB(self, "",
self.atras).ponIcono(Iconos.MoverAtras())
btAdelante = Controles.PB(self, "", self.adelante).ponIcono(
Iconos.MoverAdelante())
btFinal = Controles.PB(self, "",
self.final).ponIcono(Iconos.MoverFinal())
self.lbTituloLibro = Controles.LB(self, "")
lybt = Colocacion.H().relleno()
for x in (btInicio, btAtras, btAdelante, btFinal):
lybt.control(x)
lybt.relleno()
lyt = Colocacion.H().relleno().control(self.board).relleno()
lya = Colocacion.H().relleno().control(self.lbTituloLibro).relleno()
layout = Colocacion.V()
layout.otro(lyt)
layout.otro(lybt)
layout.otro(lya)
layout.relleno()
self.setLayout(layout)
self.movActual = None
def __init__(self, owner):
self.workmap = owner.workmap
self.procesador = owner.procesador
self.configuration = self.procesador.configuration
self.alm = self.workmap.getAim()
QTVarios.WDialogo.__init__(self, owner, _("STS: Strategic Test Suite"),
Iconos.STS(), "stsmap")
# Board
config_board = self.configuration.config_board("STSMAP", 48)
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.player_has_moved)
# Rotulos informacion
self.lbJuego = Controles.LB(self).set_wrap().anchoMinimo(200)
# Tool bar
self.li_acciones = (
(_("Continue"), Iconos.Pelicula_Seguir(), self.seguir),
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
(_("Analysis"), Iconos.Tutor(), self.analizar),
)
self.tb = QTVarios.LCTB(self, self.li_acciones)
lyT = Colocacion.V().control(self.board).relleno()
lyV = Colocacion.V().relleno().control(self.lbJuego).relleno(2)
lyTV = Colocacion.H().otro(lyT).otro(lyV)
ly = Colocacion.V().control(self.tb).otro(lyTV)
self.setLayout(ly)
self.restore_video()
self.pon_toolbar(self.cancelar)
self.ponJuego()
def __init__(self, owner, engine, segundos, min_min, min_max, linea=None, ref=None):
super(WPotencia, self).__init__(owner, _("Determine your calculating power"), Iconos.Potencia(), "potencia")
self.game, self.dicPGN, info, self.jugadaInicial, self.linea = (
lee_1_linea_mfn(linea) if linea else lee_linea_mfn()
)
self.fen = self.game.move(self.jugadaInicial).position.fen()
self.ref = ref
self.historico = owner.historico
self.procesador = owner.procesador
self.configuration = self.procesador.configuration
if engine.startswith("*"):
engine = engine[1:]
confMotor = self.configuration.buscaTutor(engine)
self.xtutor = self.procesador.creaManagerMotor(confMotor, segundos * 1000, None)
self.xtutor.maximizaMultiPV()
# Board
config_board = self.configuration.config_board("POTENCIA", 48)
self.min_min = min_min
self.min_max = min_max
cp = self.game.move(self.jugadaInicial).position
self.board = Board.BoardEstatico(self, config_board)
self.board.crea()
self.board.ponerPiezasAbajo(cp.is_white)
self.board.set_position(cp)
# Rotulo informacion
self.lbInformacion = self.creaLBInformacion(info, cp)
# Consultar la game
self.btConsultar = Controles.PB(self, _("Show game"), self.consultar, plano=False)
# Rotulo vtime
self.lbTiempo = Controles.LB(self, "").align_center()
self.liwm = []
conj_piezas = self.board.piezas
is_white = cp.is_white
for i in range(12):
wm = WBlqMove(self, conj_piezas, is_white, i)
self.liwm.append(wm)
is_white = not is_white
# Tool bar
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
(_("Check"), Iconos.Check(), self.comprobar),
)
self.tb = Controles.TBrutina(self, li_acciones)
# Layout
lyInfo = Colocacion.H().relleno().control(self.lbInformacion).control(self.btConsultar).relleno()
lyT = Colocacion.V().relleno().control(self.board).otro(lyInfo).controlc(self.lbTiempo).relleno()
lyV = Colocacion.V()
for wm in self.liwm:
lyV.control(wm)
lyV.relleno()
f = Controles.TipoLetra(puntos=10, peso=75)
self.gbMovs = Controles.GB(self, _("Next moves"), lyV).ponFuente(f)
lyTV = Colocacion.H().otro(lyT).control(self.gbMovs).relleno()
ly = Colocacion.V().control(self.tb).otro(lyTV).relleno()
self.setLayout(ly)
self.restore_video()
self.adjustSize()
liTB = [self.cancelar]
# Tiempo
self.timer = None
if min_min or min_max:
self.time_base = time.time()
if min_min:
self.gbMovs.hide()
self.start_clock(self.pensandoHastaMin)
else:
liTB.insert(0, self.comprobar)
self.start_clock(self.pensandoHastaMax)
self.pon_toolbar(liTB)
self.liwm[0].activa()
self.btConsultar.hide()
self.ultimaCelda = None
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, 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, 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.position = 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.configuration = self.procesador.configuration
# Tiempo en board
intervaloMax = self.intervalo
if self.intervaloPorPieza:
intervaloMax *= 32
# Board
config_board = self.configuration.config_board("VISUALPLAY", 48)
self.board = Board.Board(self, config_board)
self.board.crea()
lyT = Colocacion.V().control(self.board)
self.gbBoard = Controles.GB(self, "", lyT)
# entradas
ly = Colocacion.G()
self.posPosicion = None
self.posColor = None
self.posIsAttacked = None
self.posIsAttacking = None
lista = [_("Piece")]
if self.position:
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.board.piezas.icono(c)))
self.pmBien = Iconos.pmAceptarPeque()
self.pmMal = Iconos.pmCancelarPeque()
self.pmNada = Iconos.pmPuntoAmarillo()
self.liBloques = []
for x in range(32):
row = 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, row, 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, row, colPos)
unBloque.append(cb)
if self.position:
ec = Controles.ED(self, "").caracteres(2).controlrx("(|[a-h][1-8])").anchoFijo(24).align_center()
colPos += 1
ly.controlc(ec, row, colPos)
unBloque.append(ec)
if self.color:
cl = QTVarios.TwoImages(Iconos.pmBlancas(), Iconos.pmNegras())
colPos += 1
ly.controlc(cl, row, colPos)
unBloque.append(cl)
if self.esatacada:
isat = QTVarios.TwoImages(Iconos.pmAtacada().scaledToWidth(24), Iconos.pmPuntoNegro())
colPos += 1
ly.controlc(isat, row, colPos)
unBloque.append(isat)
if self.esatacante:
at = QTVarios.TwoImages(Iconos.pmAtacante().scaledToWidth(24), Iconos.pmPuntoNegro())
colPos += 1
ly.controlc(at, row, 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, _("Close"), self.terminar, plano=False).ponIcono(Iconos.MainMenu()).ponFuente(f)
self.btBoard = Controles.PB(self, _("Go to board"), self.activaBoard, plano=False).ponIcono(Iconos.Board()).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.btBoard).control(self.btComprueba).control(self.btGotoNextLevel)
lyBase = Colocacion.H().control(self.gbBoard).control(self.gbSolucion)
layout = Colocacion.V().otro(ly0).otro(lyBase)
self.setLayout(layout)
self.restore_video()
self.gotoNextLevel()
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, owner, list_svgs, dbSVGs):
titulo = _("Images")
icono = Iconos.SVGs()
extparam = "svgs"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
self.owner = owner
flb = Controles.TipoLetra(puntos=8)
self.configuration = Code.configuration
self.liPSVGs = list_svgs
self.dbSVGs = dbSVGs
# Lista
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUMBER", _("N."), 60, centered=True)
o_columns.nueva("NOMBRE", _("Name"), 256)
self.grid = Grid.Grid(self, o_columns, xid="M", siSelecFilas=True)
li_acciones = [
(_("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, li_acciones)
tb.setFont(flb)
ly = Colocacion.V().control(tb).control(self.grid)
# Board
config_board = Code.configuration.config_board("EDIT_GRAPHICS", 48)
self.board = Board.Board(self, config_board, siDirector=False)
self.board.crea()
self.board.copiaPosicionDe(owner.board)
# Layout
layout = Colocacion.H().otro(ly).control(self.board)
self.setLayout(layout)
# Ejemplos
liMovs = ["g4h3", "e2e2", "d6f4"]
self.liEjemplos = []
regSVG = BoardTypes.SVG()
for a1h8 in liMovs:
regSVG.a1h8 = a1h8
regSVG.xml = estrellaSVG
regSVG.siMovible = True
svg = self.board.creaSVG(regSVG, siEditando=True)
self.liEjemplos.append(svg)
self.grid.gotop()
self.grid.setFocus()
def __init__(self, owner, db_coordinates, coordinates):
QTVarios.WDialogo.__init__(self, owner, _("Coordinates by blocks"),
Iconos.Blocks(), "runcoordinatesblocks")
self.configuration = Code.configuration
self.coordinates = coordinates
self.db_coordinates = db_coordinates
self.current_score = 0
self.working = False
self.time_ini = None
conf_board = self.configuration.config_board(
"RUNCOORDINATESBLOCKS", self.configuration.size_base())
self.board = Board.BoardEstaticoMensaje(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.configuration.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, w_parent, sts, work, procesador):
titulo = "%s - %s - %s" % (sts.name, work.ref, work.pathToExe())
icono = Iconos.STS()
extparam = "runsts2"
QTVarios.WDialogo.__init__(self, w_parent, titulo, icono, extparam)
self.work = work
self.sts = sts
self.ngroup = -1
self.xengine = procesador.creaManagerMotor(work.configEngine(),
work.seconds * 1000,
work.depth)
self.xengine.set_direct()
self.playing = False
self.configuration = procesador.configuration
# Toolbar
li_acciones = [
(_("Close"), Iconos.MainMenu(), self.cerrar),
None,
(_("Run"), Iconos.Run(), self.run),
(_("Pause"), Iconos.Pelicula_Pausa(), self.pause),
None,
]
self.tb = tb = Controles.TBrutina(self, li_acciones, icon_size=24)
# Board
config_board = self.configuration.config_board("STS", 32)
self.board = Board.Board(self, config_board)
self.board.crea()
# Area resultados
o_columns = Columnas.ListaColumnas()
o_columns.nueva("GROUP", _("Group"), 180)
o_columns.nueva("DONE", _("Done"), 100, centered=True)
o_columns.nueva("WORK", _("Result"), 120, centered=True)
self.dworks = self.read_works()
self.calc_max()
for x in range(len(self.sts.works) - 1, -1, -1):
work = self.sts.works.getWork(x)
if work != self.work:
key = "OTHER%d" % x
reg = self.dworks[key]
o_columns.nueva(key, reg.title, 120, centered=True)
self.grid = Grid.Grid(self, o_columns, siSelecFilas=True)
self.colorMax = QTUtil.qtColor("#840C24")
self.colorOth = QTUtil.qtColor("#4668A6")
layout = Colocacion.H()
layout.control(self.board)
layout.control(self.grid)
layout.margen(3)
ly = Colocacion.V().control(tb).otro(layout)
self.setLayout(ly)
self.restore_video(siTam=True, anchoDefecto=800, altoDefecto=430)
resp = self.sts.siguientePosicion(self.work)
if resp:
self.tb.setAccionVisible(self.pause, False)
self.tb.setAccionVisible(self.run, True)
else:
self.tb.setAccionVisible(self.pause, False)
self.tb.setAccionVisible(self.run, False)
def __init__(self, owner, db_captures, capture):
QTVarios.WDialogo.__init__(self, owner,
_("Captures and threats in a game"),
Iconos.Captures(), "runcaptures")
self.configuration = Code.configuration
self.capture = capture
self.db_captures = db_captures
conf_board = self.configuration.config_board("RUNCAPTURES", 64)
self.board = Board.BoardEstaticoMensaje(self, conf_board, None)
self.board.crea()
# Rotulo informacion
self.lb_info_game = Controles.LB(
self,
self.capture.game.titulo(
"DATE", "EVENT", "WHITE", "BLACK", "RESULT")).ponTipoLetra(
puntos=self.configuration.x_pgn_fontpoints)
# Movimientos
self.liwm_captures = []
ly = Colocacion.G().margen(4)
for i in range(16):
f = i // 2
c = i % 2
wm = WRunCommon.WEdMove(self)
self.liwm_captures.append(wm)
ly.control(wm, f, c)
self.gb_captures = Controles.GB(self, _("Captures"), ly).ponFuente(
Controles.TipoLetra(puntos=10, peso=750))
self.liwm_threats = []
ly = Colocacion.G().margen(4)
for i in range(16):
f = i // 2
c = i % 2
wm = WRunCommon.WEdMove(self)
self.liwm_threats.append(wm)
ly.control(wm, f, c)
self.gb_threats = Controles.GB(self, _("Threats"), ly).ponFuente(
Controles.TipoLetra(puntos=10, peso=750))
self.lb_result = Controles.LB(self).ponTipoLetra(
puntos=10, peso=500).anchoFijo(254).altoFijo(32).set_wrap()
self.lb_info = (
Controles.LB(self).anchoFijo(254).set_foreground_backgound(
"white", "#496075").align_center().ponTipoLetra(
puntos=self.configuration.x_menu_points))
# 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,
icon_size=32)
self.show_tb(self.terminar, self.begin)
ly_right = (Colocacion.V().control(self.tb).controlc(
self.lb_info).relleno().control(
self.gb_captures).relleno().control(self.gb_threats).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_captures.setDisabled(True)
self.gb_threats.setDisabled(True)
self.liwm_captures[0].activa()
self.ultimaCelda = None
self.pon_info_posic()
self.set_position()
def __init__(self, cpu):
QtWidgets.QDialog.__init__(self)
self.cpu = cpu
self.kibitzer = cpu.kibitzer
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.is_white = True
self.is_black = 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.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()
Delegados.generaPM(self.board.piezas)
self.em = Controles.EM(self, siHTML=False).read_only()
f = Controles.TipoLetra(name="Courier New", puntos=10)
self.em.ponFuente(f)
li_acciones = (
(_("Quit"), Iconos.Kibitzer_Close(), self.terminar),
(_("Continue"), Iconos.Kibitzer_Play(), self.play),
(_("Pause"), Iconos.Kibitzer_Pause(), self.pause),
(_("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.em).margen(3)
layout = Colocacion.V().control(
self.tb).espacio(-10).otro(ly1).margen(3)
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.show_board:
self.board.hide()
self.restore_video(dicVideo)
self.ponFlags()
def __init__(self, boardOriginal):
main_window = boardOriginal.parent()
titulo = _("Colors")
icono = Iconos.EditarColores()
extparam = "WColores"
QTVarios.WDialogo.__init__(self, main_window, titulo, icono, extparam)
self.boardOriginal = boardOriginal
self.configuration = Code.configuration
self.config_board = boardOriginal.config_board.copia(boardOriginal.config_board._id)
self.is_base = boardOriginal.config_board._id == "BASE"
# Temas #######################################################################################################
li_options = [(_("Your themes"), self.configuration.ficheroTemas)]
for entry in Util.listdir(Code.path_resource("Themes")):
filename = entry.name
if filename.endswith("lktheme3"):
ctema = filename[:-9]
li_options.append((ctema, Code.path_resource("Themes", filename)))
self.cbTemas = Controles.CB(self, li_options, li_options[0][1]).capture_changes(self.cambiadoTema)
self.lbSecciones = Controles.LB(self, _("Section") + ":")
self.cbSecciones = Controles.CB(self, [], None).capture_changes(self.cambiadoSeccion)
self.lb_help = Controles.LB(self, _("Left button to select, Right to show menu"))
ly_temas = Colocacion.V()
self.lista_bt_temas = []
for i in range(12):
ly = Colocacion.H()
for j in range(6):
bt = BotonTema(self, self.cambia_tema)
ly.control(bt)
bt.pon_tema(None)
self.lista_bt_temas.append(bt)
ly.relleno(1)
ly_temas.otro(ly)
ly_temas.relleno(1)
def crea_lb(txt):
return Controles.LB(self, txt + ": ").align_right()
# Casillas
lbTrans = Controles.LB(self, _("Degree of transparency"))
lbPNG = Controles.LB(self, _("Image"))
# # Blancas
lbBlancas = crea_lb(_("White squares"))
self.btBlancas = BotonColor(self, self.config_board.colorBlancas, self.actualizaBoard)
self.btBlancasPNG = BotonImagen(self, self.config_board.png64Blancas, self.actualizaBoard, self.btBlancas)
self.dialBlancasTrans = DialNum(self, self.config_board.transBlancas, self.actualizaBoard)
# # Negras
lbNegras = crea_lb(_("Black squares"))
self.btNegras = BotonColor(self, self.config_board.colorNegras, self.actualizaBoard)
self.btNegrasPNG = BotonImagen(self, self.config_board.png64Negras, self.actualizaBoard, self.btNegras)
self.dialNegrasTrans = DialNum(self, self.config_board.transNegras, self.actualizaBoard)
# Background
lbFondo = crea_lb(_("Background"))
self.btFondo = BotonColor(self, self.config_board.colorFondo, self.actualizaBoard)
self.btFondoPNG = BotonImagen(self, self.config_board.png64Fondo, self.actualizaBoard, self.btFondo)
self.chbExtended = Controles.CHB(self, _("Extended to outer border"), self.config_board.extendedColor()).capture_changes(self, self.extendedColor)
# Actual
self.chbTemas = Controles.CHB(self, _("Default"), self.config_board.siDefTema()).capture_changes(self, self.defectoTemas)
if self.is_base:
self.chbTemas.ponValor(False)
self.chbTemas.setVisible(False)
# Exterior
lbExterior = crea_lb(_("Outer Border"))
self.btExterior = BotonColor(self, self.config_board.colorExterior, self.actualizaBoard)
self.btExteriorPNG = BotonImagen(self, self.config_board.png64Exterior, self.actualizaBoard, self.btExterior)
# Texto
lbTexto = crea_lb(_("Coordinates"))
self.btTexto = BotonColor(self, self.config_board.colorTexto, self.actualizaBoard)
# Frontera
lbFrontera = crea_lb(_("Inner Border"))
self.btFrontera = BotonColor(self, self.config_board.colorFrontera, self.actualizaBoard)
# Flechas
lbFlecha = crea_lb(_("Move indicator"))
self.lyF = BotonFlecha(self, self.config_board.fTransicion, self.config_board.flechaDefecto, self.actualizaBoard)
lbFlechaAlternativa = crea_lb(_("Arrow alternative"))
self.lyFAlternativa = BotonFlecha(self, self.config_board.fAlternativa, self.config_board.flechaAlternativaDefecto, self.actualizaBoard)
lbFlechaActivo = crea_lb(_("Active moves"))
self.lyFActual = BotonFlecha(self, self.config_board.fActivo, self.config_board.flechaActivoDefecto, self.actualizaBoard)
lbFlechaRival = crea_lb(_("Opponent moves"))
self.lyFRival = BotonFlecha(self, self.config_board.fRival, self.config_board.flechaRivalDefecto, self.actualizaBoard)
lyActual = Colocacion.G()
lyActual.control(self.chbTemas, 0, 0)
lyActual.controlc(lbPNG, 0, 2).controlc(lbTrans, 0, 3)
lyActual.controld(lbBlancas, 1, 0).control(self.btBlancas, 1, 1).otroc(self.btBlancasPNG, 1, 2).otroc(self.dialBlancasTrans, 1, 3)
lyActual.controld(lbNegras, 2, 0).control(self.btNegras, 2, 1).otroc(self.btNegrasPNG, 2, 2).otroc(self.dialNegrasTrans, 2, 3)
lyActual.controld(lbFondo, 3, 0).control(self.btFondo, 3, 1).otroc(self.btFondoPNG, 3, 2).control(self.chbExtended, 3, 3)
lyActual.controld(lbExterior, 4, 0).control(self.btExterior, 4, 1).otroc(self.btExteriorPNG, 4, 2)
lyActual.controld(lbTexto, 5, 0).control(self.btTexto, 5, 1)
lyActual.controld(lbFrontera, 6, 0).control(self.btFrontera, 6, 1)
lyActual.controld(lbFlecha, 7, 0).otro(self.lyF, 7, 1, 1, 4)
lyActual.controld(lbFlechaAlternativa, 8, 0).otro(self.lyFAlternativa, 8, 1, 1, 4)
lyActual.controld(lbFlechaActivo, 9, 0).otro(self.lyFActual, 9, 1, 1, 4)
lyActual.controld(lbFlechaRival, 10, 0).otro(self.lyFRival, 10, 1, 1, 4)
gbActual = Controles.GB(self, _("Active theme"), lyActual)
lySecciones = Colocacion.H().control(self.lbSecciones).control(self.cbSecciones).control(self.lb_help).relleno()
ly = Colocacion.V().control(self.cbTemas).otro(lySecciones).otro(ly_temas).control(gbActual).relleno()
gbTemas = Controles.GB(self, "", ly)
gbTemas.setFlat(True)
# mas options ################################################################################################
def xDefecto(if_default):
if self.is_base:
if_default = False
chb = Controles.CHB(self, _("Default"), if_default).capture_changes(self, self.defectoBoardM)
if self.is_base:
chb.setVisible(False)
return chb
def l2mas1(lyG, row, a, b, c):
if a:
ly = Colocacion.H().controld(a).control(b)
else:
ly = Colocacion.H().control(b)
lyG.otro(ly, row, 0).control(c, row, 1)
# Coordenadas
lyG = Colocacion.G()
# _nCoordenadas
lbCoordenadas = crea_lb(_("Number"))
li_options = [("0", 0), ("4", 4), ("2a", 2), ("2b", 3), ("2c", 5), ("2d", 6)]
self.cbCoordenadas = Controles.CB(self, li_options, self.config_board.nCoordenadas()).capture_changes(self.actualizaBoardM)
self.chbDefCoordenadas = xDefecto(self.config_board.siDefCoordenadas())
l2mas1(lyG, 0, lbCoordenadas, self.cbCoordenadas, self.chbDefCoordenadas)
# _tipoLetra
lbTipoLetra = crea_lb(_("Font"))
self.cbTipoLetra = QtWidgets.QFontComboBox()
self.cbTipoLetra.setEditable(False)
self.cbTipoLetra.setFontFilters(self.cbTipoLetra.ScalableFonts)
self.cbTipoLetra.setCurrentFont(QtGui.QFont(self.config_board.tipoLetra()))
self.cbTipoLetra.currentIndexChanged.connect(self.actualizaBoardM)
self.chbDefTipoLetra = xDefecto(self.config_board.siDefTipoLetra())
l2mas1(lyG, 1, lbTipoLetra, self.cbTipoLetra, self.chbDefTipoLetra)
# _cBold
self.chbBold = Controles.CHB(self, _("Bold"), self.config_board.siBold()).capture_changes(self, self.actualizaBoardM)
self.chbDefBold = xDefecto(self.config_board.siDefBold())
l2mas1(lyG, 2, None, self.chbBold, self.chbDefBold)
# _tamLetra
lbTamLetra = crea_lb(_("Size") + " %")
self.sbTamLetra = Controles.SB(self, self.config_board.tamLetra(), 1, 200).tamMaximo(50).capture_changes(self.actualizaBoardM)
self.chbDefTamLetra = xDefecto(self.config_board.siDefTamLetra())
l2mas1(lyG, 3, lbTamLetra, self.sbTamLetra, self.chbDefTamLetra)
# _sepLetras
lbSepLetras = crea_lb(_("Separation") + " %")
self.sbSepLetras = Controles.SB(self, self.config_board.sepLetras(), -1000, 1000).tamMaximo(50).capture_changes(self.actualizaBoardM)
self.chbDefSepLetras = xDefecto(self.config_board.siDefSepLetras())
l2mas1(lyG, 4, lbSepLetras, self.sbSepLetras, self.chbDefSepLetras)
gbCoordenadas = Controles.GB(self, _("Coordinates"), lyG)
ly_otros = Colocacion.G()
# _nomPiezas
li = []
lbPiezas = crea_lb(_("Pieces"))
for entry in Util.listdir(Code.path_resource("Pieces")):
if entry.is_dir():
li.append((entry.name, entry.name))
li.sort(key=lambda x: x[0])
self.cbPiezas = Controles.CB(self, li, self.config_board.nomPiezas()).capture_changes(self.actualizaBoardM)
self.chbDefPiezas = xDefecto(self.config_board.siDefPiezas())
l2mas1(ly_otros, 0, lbPiezas, self.cbPiezas, self.chbDefPiezas)
# _tamRecuadro
lbTamRecuadro = crea_lb(_("Outer Border Size") + " %")
self.sbTamRecuadro = Controles.SB(self, self.config_board.tamRecuadro(), 0, 10000).tamMaximo(50).capture_changes(self.actualizaBoardM)
self.chbDefTamRecuadro = xDefecto(self.config_board.siDefTamRecuadro())
l2mas1(ly_otros, 1, lbTamRecuadro, self.sbTamRecuadro, self.chbDefTamRecuadro)
# _tamFrontera
lbTamFrontera = crea_lb(_("Inner Border Size") + " %")
self.sbTamFrontera = Controles.SB(self, self.config_board.tamFrontera(), 0, 10000).tamMaximo(50).capture_changes(self.actualizaBoardM)
self.chbDefTamFrontera = xDefecto(self.config_board.siDefTamFrontera())
l2mas1(ly_otros, 2, lbTamFrontera, self.sbTamFrontera, self.chbDefTamFrontera)
ly = Colocacion.V().control(gbCoordenadas).espacio(50).otro(ly_otros).relleno()
gbOtros = Controles.GB(self, "", ly)
gbOtros.setFlat(True)
# Board #####################################################################################################
cp = Position.Position().read_fen("2kr1b1r/2p1pppp/p7/3pPb2/1q3P2/2N1P3/PPP3PP/R1BQK2R w KQ - 0 1")
self.board = Board.Board(self, self.config_board, siMenuVisual=False)
self.board.crea()
self.board.set_position(cp)
self.rehazFlechas()
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
("%s/%s" % (_("Save"), _("Save as")), Iconos.Grabar(), self.menu_save),
None,
(_("Import"), Iconos.Import8(), self.importar),
None,
(_("Export"), Iconos.Export8(), self.exportar),
None,
]
tb = QTVarios.LCTB(self, li_acciones)
# tam board
self.lbTamBoard = Controles.LB(self, "%d px" % self.board.width())
# Juntamos
lyT = Colocacion.V().control(tb).espacio(15).control(self.board).controli(self.lbTamBoard).relleno(1).margen(3)
self.tab = Controles.Tab()
self.tab.nuevaTab(gbTemas, _("Themes"))
self.tab.nuevaTab(gbOtros, _("Other options"))
ly = Colocacion.H().otro(lyT).control(self.tab)
self.setLayout(ly)
self.elegido = None
self.li_themes = self.read_own_themes()
self.current_theme = {"NOMBRE": "", "SECCION": "", "CHANGE_PIECES": True, "o_tema": self.config_board.grabaTema(), "o_base": self.config_board.grabaBase()}
self.own_theme_selected = False
self.cambiadoTema()
self.defectoTemas()
self.extendedColor()
self.siActualizando = False
self.restore_video(siTam=False)
def __init__(self, cpu):
QtWidgets.QDialog.__init__(self)
self.cpu = cpu
self.kibitzer = cpu.kibitzer
dicVideo = self.cpu.dic_video
if not dicVideo:
dicVideo = {}
self.siTop = dicVideo.get("SITOP", True)
self.show_board = dicVideo.get("SHOW_BOARD", True)
self.history = []
self.fen = ""
self.liData = []
self.setWindowTitle(cpu.titulo)
self.setWindowIcon(Iconos.Motor())
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)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("titulo", "", 100, siDerecha=True)
o_columns.nueva("valor", "", 100, centered=True)
o_columns.nueva("info", "", 100)
self.grid = Grid.Grid(self, o_columns, dicVideo=dicVideo, siSelecFilas=True, siCabeceraVisible=False)
li_acciones = (
(_("Continue"), Iconos.Kibitzer_Play(), self.play),
(_("Pause"), Iconos.Kibitzer_Pause(), self.pause),
(_("Takeback"), Iconos.Atras(), self.takeback),
(_("Analyze only color"), Iconos.Kibitzer_Side(), self.color),
(_("Show/hide board"), Iconos.Kibitzer_Board(), self.config_board),
(_("Manual position"), Iconos.Voyager(), self.set_position),
("%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=16)
self.tb.setAccionVisible(self.play, False)
ly1 = Colocacion.H().control(self.tb).relleno()
ly2 = Colocacion.V().otro(ly1).control(self.grid)
layout = Colocacion.H().control(self.board).otro(ly2)
self.setLayout(layout)
self.siPlay = True
self.is_white = True
self.is_black = True
if not self.show_board:
self.board.hide()
self.restore_video(dicVideo)
self.ponFlags()
self.engine = self.lanzaMotor()
self.depth = 0
self.veces = 0
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.compruebaInput)
self.timer.start(200)
def __init__(self, owner, list_arrows, 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.configuration = Code.configuration
self.dbFlechas = dbFlechas
self.liPFlechas = owner.list_arrows()
# Lista
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUMBER", _("N."), 60, centered=True)
o_columns.nueva("NOMBRE", _("Name"), 256)
self.grid = Grid.Grid(self, o_columns, xid="F", siSelecFilas=True)
li_acciones = [
(_("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, li_acciones)
tb.setFont(flb)
ly = Colocacion.V().control(tb).control(self.grid)
# Board
config_board = Code.configuration.config_board("EDIT_GRAPHICS", 48)
self.board = Board.Board(self, config_board, siDirector=False)
self.board.crea()
self.board.copiaPosicionDe(owner.board)
# Layout
layout = Colocacion.H().otro(ly).control(self.board)
self.setLayout(layout)
self.register_grid(self.grid)
self.restore_video()
# Ejemplos
liMovs = ["d2d6", "a8h8", "h5b7"]
self.liEjemplos = []
regFlecha = BoardTypes.Flecha()
for a1h8 in liMovs:
regFlecha.a1h8 = a1h8
regFlecha.siMovible = True
arrow = self.board.creaFlecha(regFlecha)
self.liEjemplos.append(arrow)
self.grid.gotop()
self.grid.setFocus()
def __init__(self, owner, regFlecha, siNombre):
QtWidgets.QDialog.__init__(self, owner)
self.setWindowTitle(_("Arrow"))
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint)
self.siNombre = siNombre
if regFlecha is None:
regFlecha = TabVisual.PFlecha()
li_acciones = [(_("Save"), Iconos.Aceptar(), "grabar"), None, (_("Cancel"), Iconos.Cancelar(), "reject"), None]
tb = Controles.TB(self, li_acciones)
# Board
config_board = owner.board.config_board.copia(owner.board.config_board.id())
config_board.anchoPieza(32)
self.board = Board.Board(self, config_board, siDirector=False)
self.board.crea()
self.board.copiaPosicionDe(owner.board)
# Datos generales
liGen = []
if siNombre:
# name de la arrow que se usara en los menus del tutorial
config = FormLayout.Editbox(_("Name"), ancho=120)
liGen.append((config, regFlecha.name))
# ( "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))
# ( "opacity", "n", 1.0 ),
config = FormLayout.Dial(_("Degree of transparency"), 0, 99)
liGen.append((config, 100 - int(regFlecha.opacity * 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 arrow si es un poligono
config = FormLayout.Spinbox(_("Base width"), 1, 100, 50)
liGen.append((config, regFlecha.ancho))
# ( "vuelo", "n", 5 ), # vuelo de la arrow 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.physical_pos.orden))
self.form = FormLayout.FormWidget(liGen, dispatch=self.cambios)
# Layout
layout = Colocacion.H().control(self.form).relleno().control(self.board)
layout1 = Colocacion.V().control(tb).otro(layout)
self.setLayout(layout1)
# Ejemplos
self.board.borraMovibles()
liMovs = ["d2d6", "a8h8", "h5b7"]
self.liEjemplos = []
for a1h8 in liMovs:
regFlecha.a1h8 = a1h8
regFlecha.siMovible = True
arrow = self.board.creaFlecha(regFlecha)
self.liEjemplos.append(arrow)
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
