def lee(self):
        dic = Util.restore_pickle(self.file)
        if dic:
            for x in dir(self):
                if x.startswith("x_"):
                    if x in dic:
                        setattr(self, x, dic[x])
            xperf = dic.get("PERFOMANCE")
            if xperf:
                self.perfomance.restore(xperf)
            palette = dic.get("PALETTE")
            if palette:
                self.palette = palette

        for x in os.listdir("../.."):
            if x.endswith(".pon"):
                os.remove("../%s" % x)
                self.x_translator = x[:2]
        self.releeTRA()

        TrListas.ponPiecesLNG(self.x_pgn_english or self.translator() == "en")

        self.tutor = self.buscaTutor(self.x_tutor_clave)
        if self.tutor.key != self.x_tutor_clave:
            self.x_tutor_clave = self.tutor.key

        self.x_style = "WindowsVista"
示例#2
0
 def pgnSP(self):
     dConv = TrListas.dConv()
     resp = self.pgnBase
     for k in dConv.keys():
         if k in resp:
             resp = resp.replace(k, dConv[k])
     return resp + self.resultadoSP()
示例#3
0
    def informacion(self):

        menu = QTVarios.LCMenu(self.pantalla)
        f = Controles.TipoLetra(puntos=10, peso=75)
        menu.ponFuente(f)

        siOpening = False
        for clave, valor in self.liPGN:
            siFecha = clave.upper().endswith("DATE")
            trad = TrListas.pgnLabel(clave)
            if trad != clave:
                clave = trad
                # else:
                # clave = clave[0].upper()+clave[1:].lower()
            if siFecha:
                valor = valor.replace(".??", "")
            menu.opcion(clave, "%s : %s" % (clave, valor), Iconos.PuntoAzul())
            if clave.upper() == "OPENING":
                siOpening = True

        if not siOpening:
            apertura = self.partida.apertura
            if apertura:
                menu.separador()
                nom = apertura.trNombre
                ape = _("Opening")
                rotulo = nom if ape.upper() in nom.upper() else ("%s : %s" % (ape, nom))
                menu.opcion(clave, rotulo, Iconos.PuntoNaranja())

        menu.separador()
        menu.opcion("pgn", _("Edit PGN labels"), Iconos.PGN())

        resp = menu.lanza()
        if resp:
            self.editarEtiquetasPGN()
示例#4
0
 def pgnSP(self):
     dConv = TrListas.dConv()
     resp = self.pgnBase
     for k in dConv.keys():
         if k in resp:
             resp = resp.replace(k, dConv[k])
     return resp + self.resultadoSP()
示例#5
0
    def informacion(self):
        menu = QTVarios.LCMenu(self.pantalla)
        f = Controles.TipoLetra(puntos=10, peso=75)
        menu.ponFuente(f)

        siOpening = False
        for clave, valor in self.partida.liTags:
            trad = TrListas.pgnLabel(clave)
            if trad != clave:
                clave = trad
            menu.opcion(clave, "%s : %s" % (clave, valor), Iconos.PuntoAzul())
            if clave.upper() == "OPENING":
                siOpening = True

        if not siOpening:
            apertura = self.partida.apertura
            if apertura:
                menu.separador()
                nom = apertura.trNombre
                ape = _("Opening")
                rotulo = nom if ape.upper() in nom.upper() else ("%s : %s" %
                                                                 (ape, nom))
                menu.opcion("opening", rotulo, Iconos.PuntoNaranja())

        menu.separador()
        menu.opcion("pgn", _("Edit PGN labels"), Iconos.PGN())

        resp = menu.lanza()
        if resp:
            self.editarEtiquetasPGN()
示例#6
0
 def pgnSP(self, desde, hasta, coronacion=None):
     dConv = TrListas.dConv()
     resp = self.pgn(desde, hasta, coronacion)
     for k in dConv.keys():
         if k in resp:
             resp = resp.replace(k, dConv[k])
     return resp
示例#7
0
 def read_svg(self, base):
     with open(base % "svg", "rb") as f:
         x = f.read()
         dic = TrListas.transsiberian()
         for k, v in dic.iteritems():
             x = x.replace(">%s<" % k, ">%s<" % v)
         return x
    def creaListaSonidos(self):

        self.liSonidos = [["MC", _("After rival move"), None]]

        # self.liSonidos.append( [ None, "", None ] )
        self.liSonidos.append([None, "- " + _("Results") + " -", None])

        d = collections.OrderedDict()
        d["GANAMOS"] = _("You win")
        d["GANARIVAL"] = _("Opponent wins")
        d["TABLAS"] = _("Stalemate")
        d["TABLASREPETICION"] = _("Draw due to three times repetition")
        d["TABLAS50"] = _("Draw according to the 50 move rule")
        d["TABLASFALTAMATERIAL"] = _("Draw, not enough material")
        d["GANAMOSTIEMPO"] = _("You win on time")
        d["GANARIVALTIEMPO"] = _("Opponent has won on time")

        for c, tr in d.items():
            self.liSonidos.append([c, tr, None])

        # self.liSonidos.append( [ None, "", None ] )
        self.liSonidos.append([None, "- " + _("Rival moves") + " -", None])

        for c in "abcdefgh12345678":
            self.liSonidos.append([c, c, None])

        for c in "KQRBNP":
            t = TrListas.letterPiece(c)
            self.liSonidos.append([c, t, None])

        for c in ("O-O", "O-O-O", "=", "x", "#", "+"):
            self.liSonidos.append([c, c, None])

        self.liSonidos.append([None, "", None])
        self.liSonidos.append(["ZEITNOT", _("Zeitnot"), None])
示例#9
0
    def muestraInformacion(self):
        li = []
        li.append("%s: %d" % (_("Errors"), self.errores))
        if self.siAyuda:
            li.append(_("Help activated"))
        self.ponRotulo1("\n".join(li))

        tgm = 0
        for tr in self.game["TRIES"]:
            tgm += tr["TIME"]

        mens = "\n" + "\n".join(self.liMensBasic)
        mens += "\n%s:\n    %s %s\n    %s %s" % (
            _("Working time"), time.strftime("%H:%M:%S", time.gmtime(tgm)),
            _("Current"), time.strftime("%H:%M:%S", time.gmtime(
                self.tm)), _("Total"))

        self.ponRotulo2(mens)

        if self.siAyuda:
            dicNAGs = TrListas.dicNAGs()
            mens3 = ""
            fenM2 = self.partida.ultPosicion.fenM2()
            reg = self.dbop.getfenvalue(fenM2)
            if reg:
                mens3 = reg.get("COMENTARIO", "")
                ventaja = reg.get("VENTAJA", 0)
                valoracion = reg.get("VALORACION", 0)
                if ventaja:
                    mens3 += "\n %s" % dicNAGs[ventaja]
                if valoracion:
                    mens3 += "\n %s" % dicNAGs[valoracion]
            self.ponRotulo3(mens3 if mens3 else None)
示例#10
0
    def rehaz_columnas(self):
        li_tags = self.dbGames.li_tags()
        o_columns = self.grid.o_columns
        si_cambios = False

        li_remove = []
        for n, col in enumerate(o_columns.liColumnas):
            clave = col.clave
            if not (clave in li_tags) and not (clave in ("__num__", "rowid")):
                li_remove.append(n)
        if li_remove:
            si_cambios = True
            li_remove.sort(reverse=True)
            for n in li_remove:
                del o_columns.liColumnas[n]

        dcabs = self.dbGames.recuperaConfig("dcabs", DBgames.drots.copy())
        st100 = {"Event", "Site", "White", "Black"}
        stActual = {col.clave for col in self.grid.o_columns.liColumnas}
        for tag in li_tags:
            if not (tag in stActual):
                rotulo = TrListas.pgnLabel(tag)
                if rotulo == tag:
                    rotulo = dcabs.get(rotulo, rotulo)
                o_columns.nueva(tag, rotulo, 100 if tag in st100 else 70, centered=not (tag in ("Event", "Site")))
                si_cambios = True

        if si_cambios:
            self.dbGames.reset_cache()
            self.grid.releerColumnas()
示例#11
0
    def informacion(self):
        menu = QTVarios.LCMenu(self.main_window)
        f = Controles.TipoLetra(puntos=10, peso=75)
        menu.ponFuente(f)

        siOpening = False
        for key, valor in self.game.li_tags:
            trad = TrListas.pgnLabel(key)
            if trad != key:
                key = trad
            menu.opcion(key, "%s : %s" % (key, valor), Iconos.PuntoAzul())
            if key.upper() == "OPENING":
                siOpening = True

        if not siOpening:
            opening = self.game.opening
            if opening:
                menu.separador()
                nom = opening.trNombre
                ape = _("Opening")
                label = nom if ape.upper() in nom.upper() else ("%s : %s" %
                                                                (ape, nom))
                menu.opcion("opening", label, Iconos.PuntoNaranja())

        menu.separador()
        menu.opcion("pgn", _("Edit PGN labels"), Iconos.PGN())

        resp = menu.lanza()
        if resp:
            self.editEtiquetasPGN()
示例#12
0
 def pgnSP(self, desde, hasta, coronacion=None):
     dConv = TrListas.dConv()
     resp = self.pgn(desde, hasta, coronacion)
     for k in dConv.keys():
         if k in resp:
             resp = resp.replace(k, dConv[k])
     return resp
示例#13
0
    def __init__(self, procesador, winBookGuide, dbGamesFEN):
        QtGui.QWidget.__init__(self)

        self.winBookGuide = winBookGuide
        self.dbGamesFEN = dbGamesFEN
        self.procesador = procesador
        self.configuracion = procesador.configuracion

        self.infoMove = None  # <-- setInfoMove
        self.numJugada = 0  # Se usa para indicarla al mostrar el pgn en infoMove

        self.terminado = False # singleShot

        self.liFiltro = []
        self.where = None

        # Grid
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva("numero", _("N."), 70, siCentrado=True)
        liBasic = dbGamesFEN.liCamposBase
        for clave in liBasic:
            if clave == "FEN":
                continue
            rotulo = TrListas.pgnLabel(clave)
            siCentrado = clave != "EVENT"

            ancho = 140 if clave == "FEN" else 70  # para que sirva con WBG_GamesFEN
            oColumnas.nueva(clave, rotulo, ancho, siCentrado=siCentrado)

        self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True, xid="wgamesfen")

        # Status bar
        self.status = QtGui.QStatusBar(self)
        self.status.setFixedHeight(22)

        # ToolBar
        liAccionesWork = [
            (_("Close"), Iconos.MainMenu(), self.tw_terminar), None,
            (_("Database"), Iconos.DatabaseC(), self.tg_file), None,
            (_("New"), Iconos.Nuevo(), self.tw_nuevo, _("Add a new game")), None,
            (_("Edit"), Iconos.Modificar(), self.tw_editar), None,
            (_("First"), Iconos.Inicio(), self.tw_gotop), None,
            (_("Last"), Iconos.Final(), self.tw_gobottom), None,
            (_("Filter"), Iconos.Filtrar(), self.tw_filtrar), None,
            (_("Remove"), Iconos.Borrar(), self.tw_borrar),None,
        ]

        self.tbWork = Controles.TBrutina(self, liAccionesWork, tamIcon=24)

        self.lbName = Controles.LB(self, "").ponWrap().alinCentrado().ponColorFondoN("white", "#4E5A65").ponTipoLetra(puntos=16)
        lyNT = Colocacion.H().control(self.lbName)

        lyTB = Colocacion.H().control(self.tbWork)

        layout = Colocacion.V().otro(lyNT).otro(lyTB).control(self.grid).control(self.status).margen(1)

        self.setLayout(layout)

        self.setNameToolBar()
示例#14
0
 def pgn_translated(self):
     dConv = TrListas.dConv()
     li = []
     for c in self.pgnBase:
         if c in dConv:
             c = dConv[c]
         li.append(c)
     return "".join(li)
示例#15
0
 def pgn_translated(self, from_sq, to_sq, promotion=None):
     dConv = TrListas.dConv()
     li = []
     for c in self.pgn(from_sq, to_sq, promotion):
         if c in dConv:
             c = dConv[c]
         li.append(c)
     return "".join(li)
示例#16
0
 def trPGN(self):
     p = ""
     pzs = "KQRBNPkqrbnp"
     pgn = self.pgn
     for n, c in enumerate(pgn):
         if c in pzs and not pgn[n + 1].isdigit():
             c = TrListas.letterPiece(c)
         p += c
     return p
示例#17
0
 def trPGN(self):
     p = ""
     pzs = "KQRBNPkqrbnp"
     pgn = self.pgn
     for n, c in enumerate(pgn):
         if c in pzs and not pgn[n + 1].isdigit():
             c = TrListas.letterPiece(c)
         p += c
     return p
示例#18
0
    def __init__(self, carpeta):
        dicTraining = TrListas.dicTraining()

        def trTraining(txt):
            return dicTraining.get(txt, txt)

        self.tr = trTraining

        self.name = trTraining(os.path.basename(carpeta))
        self.read(carpeta)
示例#19
0
    def leeEstandar(self, dic):
        listSTD = TrListas.listSTD()

        for name, eco, a1h8, pgn, siBasic in listSTD:
            bloque = AperturaStd(name)
            bloque.eco = eco
            bloque.a1h8 = a1h8
            bloque.pgn = pgn
            bloque.siBasic = siBasic
            dic[bloque.a1h8] = bloque
示例#20
0
    def lee(self):
        dic = Util.restore_pickle(self.fichero)
        if dic:
            for x in dir(self):
                if x.startswith("x_"):
                    if x in dic:
                        setattr(self, x, dic[x])

        for x in os.listdir(".."):
            if x.endswith(".pon"):
                os.remove("../%s" % x)
                self.x_translator = x[:2]
        self.releeTRA()

        TrListas.ponPiecesLNG(self.x_pgn_english or self.translator() == "en")

        self.tutor = self.buscaTutor(self.x_tutor_clave)
        if self.tutor.clave != self.x_tutor_clave:
            self.x_tutor_clave = self.tutor.clave
示例#21
0
    def leeEstandar(self, dic):
        listSTD = TrListas.listSTD()

        for name, eco, a1h8, pgn, siBasic in listSTD:
            bloque = AperturaStd(name)
            bloque.eco = eco
            bloque.a1h8 = a1h8
            bloque.pgn = pgn
            bloque.siBasic = siBasic
            dic[bloque.a1h8] = bloque
示例#22
0
    def read_standard(dic):
        list_std = TrListas.list_std()

        for name, eco, a1h8, pgn, siBasic in list_std:
            bloque = AperturaStd(name)
            bloque.eco = eco
            bloque.a1h8 = a1h8
            bloque.pgn = pgn
            bloque.siBasic = siBasic
            dic[bloque.a1h8] = bloque
示例#23
0
 def basadoEn(self):
     fich = self.configNivel.fichero[:-4]
     li = fich.split("/" if "/" in fich else "\\")
     d = TrListas.dicTraining()
     base = li[1]
     txt = d.get(base, _F(base))
     if len(li) == 3:
         fich = li[2]
         txt += ", " + d.get(fich, _F(fich))
     return txt
示例#24
0
    def __init__(self, carpeta):
        dicTraining = TrListas.dicTraining()

        def trTraining(txt):
            return dicTraining.get(txt, txt)

        self.tr = trTraining

        self.name = trTraining(os.path.basename(carpeta))
        self.read(carpeta)
    def mousePressEvent(self, event):
        siRight = event.button() == QtCore.Qt.RightButton
        p = event.pos()
        a1h8 = self.punto2a1h8(p)
        m = int(event.modifiers())
        is_ctrl = (m & QtCore.Qt.ControlModifier) > 0
        is_shift = (m & QtCore.Qt.ShiftModifier) > 0
        is_alt = (m & QtCore.Qt.AltModifier) > 0

        li_tareas = self.guion.tareasPosicion(p)

        if siRight and is_shift and is_alt:
            pz_borrar = self.board.dameNomPiezaEn(a1h8)
            menu = Controles.Menu(self.board)
            dicPieces = TrListas.dicNomPiezas()
            icoPiece = self.board.piezas.icono

            if pz_borrar or len(li_tareas):
                mrem = menu.submenu(_("Remove"), Iconos.Delete())
                if pz_borrar:
                    label = dicPieces[pz_borrar.upper()]
                    mrem.opcion(("rem_pz", None), label, icoPiece(pz_borrar))
                    mrem.separador()
                for pos_guion, tarea in li_tareas:
                    label = "%s - %s - %s" % (tarea.txt_tipo(), tarea.name(),
                                              tarea.info())
                    mrem.opcion(("rem_gr", pos_guion), label, Iconos.Delete())
                    mrem.separador()
                menu.separador()

            for pz in "KQRBNPkqrbnp":
                if pz != pz_borrar:
                    if pz == "k":
                        menu.separador()
                    menu.opcion(("create", pz), dicPieces[pz.upper()],
                                icoPiece(pz))
            resp = menu.lanza()
            if resp is not None:
                orden, arg = resp
                if orden == "rem_gr":
                    self.w.g_guion.goto(arg, 0)
                    self.w.borrar_lista()
                elif orden == "rem_pz":
                    self.w.creaTarea("B", pz_borrar, a1h8, -1)

                elif orden == "create":
                    self.w.creaTarea("C", arg, a1h8, -1)
            return True

        if self.director:
            return self.mousePressEvent_Drop(event)

        self.w.boardPress(event, a1h8, siRight, is_shift, is_alt, is_ctrl)

        return True
示例#26
0
    def __init__(self, procesador):

        titulo = _("Play against a game")
        super().__init__(parent=procesador.pantalla,
                         titulo=titulo,
                         icono=Iconos.Law(),
                         extparam="playgame")

        self.procesador = procesador
        self.configuracion = procesador.configuracion
        self.recno = None

        self.db = PlayPGNs(self.configuracion.ficheroPlayPGN)

        # Historico
        oColumnas = Columnas.ListaColumnas()

        def creaCol(clave, rotulo, siCentrado=True):
            oColumnas.nueva(clave, rotulo, 80, siCentrado=siCentrado)

        # # Claves segun orden estandar
        liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK",
                   "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO")
        for clave in liBasic:
            rotulo = TrListas.pgnLabel(clave)
            creaCol(clave, rotulo, clave != "EVENT")
        self.grid = Grid.Grid(self,
                              oColumnas,
                              siSelecFilas=True,
                              siSeleccionMultiple=True)
        self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)

        # Tool bar
        liAcciones = (
            (_("Close"), Iconos.MainMenu(), self.terminar),
            None,
            (_("Play"), Iconos.Empezar(), self.empezar),
            (_("New"), Iconos.Nuevo(), self.nuevo),
            None,
            (_("Remove"), Iconos.Borrar(), self.borrar),
            None,
        )
        self.tb = Controles.TBrutina(self, liAcciones)

        # Colocamos
        lyTB = Colocacion.H().control(self.tb).margen(0)
        ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)

        self.setLayout(ly)

        self.registrarGrid(self.grid)
        self.recuperarVideo(siTam=False)

        self.grid.gotop()
示例#27
0
 def pgn_translated(self, from_sq, to_sq, promotion=""):
     d_conv = TrListas.dConv()
     li = []
     cpgn = self.pgn(from_sq, to_sq, promotion)
     if not cpgn:
         return ""
     for c in cpgn:
         if c in d_conv:
             c = d_conv[c]
         li.append(c)
     return "".join(li)
示例#28
0
    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() )
示例#29
0
    def __init__(self, procesador):

        titulo = _("Play against a game")
        QTVarios.WDialogo.__init__(self, procesador.main_window, titulo,
                                   Iconos.Law(), "playgame")

        self.procesador = procesador
        self.configuracion = procesador.configuracion
        self.recno = None

        self.db = DBPlayGame(self.configuracion.file_play_game())

        # Historico
        o_columns = Columnas.ListaColumnas()

        def creaCol(key, rotulo, centered=True):
            o_columns.nueva(key, rotulo, 80, centered=centered)

        # # Claves segun orden estandar
        liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK",
                   "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO")
        for key in liBasic:
            rotulo = TrListas.pgnLabel(key)
            creaCol(key, rotulo, key != "EVENT")
        self.grid = Grid.Grid(self,
                              o_columns,
                              siSelecFilas=True,
                              siSeleccionMultiple=True)
        self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)

        # Tool bar
        li_acciones = (
            (_("Close"), Iconos.MainMenu(), self.terminar),
            None,
            (_("Play"), Iconos.Empezar(), self.play),
            (_("New"), Iconos.Nuevo(), self.new),
            None,
            (_("Remove"), Iconos.Borrar(), self.remove),
            None,
        )
        self.tb = QTVarios.LCTB(self, li_acciones)

        # Colocamos
        lyTB = Colocacion.H().control(self.tb).margen(0)
        ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)

        self.setLayout(ly)

        self.register_grid(self.grid)
        self.restore_video(siTam=False)

        self.grid.gotop()
    def __init__(self, wmoves):
        QtGui.QTreeWidget.__init__(self)
        self.wmoves = wmoves
        self.itemActivo = None
        self.setAlternatingRowColors(True)

        self.dicItems = {}

        self.posMoves = 0
        self.posTransposition = 1
        self.posBookmark = 2
        self.posAnalisis = 3
        self.posComment = 4
        self.setHeaderLabels((_("Moves"), "", "", _("Analysis"), _("Comments"), ""))
        self.setColumnHidden(5, True)
        self.setIndentation(14)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.menuContexto)

        self.setStyleSheet("selection-background-color: #F1D369; selection-color: #000000;")

        ftxt = Controles.TipoLetra(puntos=9)

        self.setFont(ftxt)

        self.connect(self, QtCore.SIGNAL("itemExpanded(QTreeWidgetItem *)"), self.expandido)
        self.connect(self, QtCore.SIGNAL("itemSelectionChanged()"), self.seleccionadoISC)
        self.connect(self, QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"), self.dobleClick)

        self.noIcon = QtGui.QIcon()
        self.iconBookmark = Iconos.Favoritos()
        self.iconTransposition = Iconos.Transposition()

        dicNAGs = TrListas.dicNAGs()
        self.dicValoracion = collections.OrderedDict()
        self.dicValoracion[BUENO] = (dicNAGs[1], PantallaColores.nag2ico(1, 16))
        self.dicValoracion[MALO] = (dicNAGs[2], PantallaColores.nag2ico(2, 16))
        self.dicValoracion[MUY_BUENO] = (dicNAGs[3], PantallaColores.nag2ico(3, 16))
        self.dicValoracion[MUY_MALO] = (dicNAGs[4], PantallaColores.nag2ico(4, 16))
        self.dicValoracion[INTERESANTE] = (dicNAGs[5], PantallaColores.nag2ico(5, 16))
        self.dicValoracion[DUDOSA] = (dicNAGs[6], PantallaColores.nag2ico(6, 16))
        self.dicValoracion[SIN_VALORACION] = (_("No rating"), self.noIcon)

        self.dicVentaja = collections.OrderedDict()
        self.dicVentaja[V_SIN] = (_("Undefined"), self.noIcon)
        self.dicVentaja[V_IGUAL] = (dicNAGs[11], Iconos.V_Blancas_Igual_Negras())
        self.dicVentaja[V_BLANCAS] = (dicNAGs[14], Iconos.V_Blancas())
        self.dicVentaja[V_BLANCAS_MAS] = (dicNAGs[16], Iconos.V_Blancas_Mas())
        self.dicVentaja[V_BLANCAS_MAS_MAS] = (dicNAGs[18], Iconos.V_Blancas_Mas_Mas())
        self.dicVentaja[V_NEGRAS] = (dicNAGs[15], Iconos.V_Negras())
        self.dicVentaja[V_NEGRAS_MAS] = (dicNAGs[17], Iconos.V_Negras_Mas())
        self.dicVentaja[V_NEGRAS_MAS_MAS] = (dicNAGs[19], Iconos.V_Negras_Mas_Mas())
示例#31
0
    def __init__(self, procesador):

        titulo = _("Learn a game")
        QTVarios.WDialogo.__init__(self, procesador.pantalla, titulo,
                                   Iconos.PGN(), "learngame")

        self.procesador = procesador
        self.configuracion = procesador.configuracion

        self.db = LearnPGNs(self.configuracion.ficheroLearnPGN)

        # Historico
        oColumnas = Columnas.ListaColumnas()

        def creaCol(clave, rotulo, siCentrado=True):
            oColumnas.nueva(clave, rotulo, 80, siCentrado=siCentrado)

        # # Claves segun orden estandar
        liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK",
                   "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO")
        for clave in liBasic:
            rotulo = TrListas.pgnLabel(clave)
            creaCol(clave, rotulo, clave != "EVENT")
        self.grid = Grid.Grid(self,
                              oColumnas,
                              siSelecFilas=True,
                              siSeleccionMultiple=True)
        self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)

        # Tool bar
        liAcciones = (
            (_("Quit"), Iconos.MainMenu(), "terminar"),
            None,
            (_("New"), Iconos.TutorialesCrear(), "nuevo"),
            None,
            (_("Remove"), Iconos.Borrar(), "borrar"),
            None,
            (_("Start"), Iconos.Empezar(), "empezar"),
        )
        self.tb = Controles.TB(self, liAcciones)

        # Colocamos
        lyTB = Colocacion.H().control(self.tb).margen(0)
        ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)

        self.setLayout(ly)

        self.registrarGrid(self.grid)
        self.recuperarVideo(siTam=False)

        self.grid.gotop()
示例#32
0
 def gridDato(self, grid, fila, oColumna):
     if oColumna.clave == "ETIQUETA":
         lb = self.liPGN[fila][0]
         ctra = lb.upper()
         trad = TrListas.pgnLabel(lb)
         if trad != ctra:
             clave = trad
         else:
             if lb:
                 clave = lb  # [0].upper()+lb[1:].lower()
             else:
                 clave = ""
         return clave
     return self.liPGN[fila][1]
示例#33
0
    def __init__(self, owner, procesador):
        QtGui.QTreeWidget.__init__(self)
        self.owner = owner
        self.dbCache = owner.dbCache
        self.setAlternatingRowColors(True)
        self.listaMoves = owner.listaMoves
        self.procesador = procesador
        # self.setSelectionMode(self.ExtendedSelection)
        # self.setDragDropMode(self.InternalMove)
        # self.setDragEnabled(True)
        # self.setDropIndicatorShown(True)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.menuContexto)

        self.setHeaderLabels(
            (_("Moves"), _("Points"), _("Comments"), _("Variants"), "", ""))
        self.setColumnHidden(4, True)

        dicNAGs = TrListas.dicNAGs()
        self.dicValoracion = collections.OrderedDict()
        self.dicValoracion["1"] = (MUY_BUENO, dicNAGs[3])
        self.dicValoracion["2"] = (BUENO, dicNAGs[1])
        self.dicValoracion["3"] = (MALO, dicNAGs[2])
        self.dicValoracion["4"] = (MUY_MALO, dicNAGs[4])
        self.dicValoracion["5"] = (INTERESANTE, dicNAGs[5])
        self.dicValoracion["6"] = (DUDOSA, dicNAGs[6])
        self.dicValoracion["0"] = (SIN_VALORACION, _("No rating"))

        ftxt = Controles.TipoLetra(puntos=9)

        self.setFont(ftxt)

        self.connect(
            self,
            QtCore.SIGNAL(
                "currentItemChanged(QTreeWidgetItem *,QTreeWidgetItem *)"),
            self.seleccionado)
        self.connect(self,
                     QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"),
                     self.editado)

        hitem = self.header()
        hitem.setClickable(True)
        self.connect(hitem, QtCore.SIGNAL("sectionDoubleClicked(int)"),
                     self.editadoH)

        self.dicItemMoves = {}
        self.ponMoves(self.listaMoves)

        self.sortItems(4, QtCore.Qt.AscendingOrder)
示例#34
0
 def grid_dato(self, grid, fila, oColumna):
     if oColumna.clave == "ETIQUETA":
         lb = self.li_labels[fila][0]
         ctra = lb.upper()
         trad = TrListas.pgnLabel(lb)
         if trad != ctra:
             key = trad
         else:
             if lb:
                 key = lb  # [0].upper()+lb[1:].lower()
             else:
                 key = ""
         return key
     return self.li_labels[fila][1]
示例#35
0
 def grid_dato(self, grid, row, o_column):
     if o_column.key == "ETIQUETA":
         lb, value = self.li_labels[row]
         ctra = lb.upper()
         trad = TrListas.pgnLabel(lb)
         if trad != ctra:
             key = trad
         else:
             if lb:
                 key = lb
             else:
                 key = ""
         return key
     return self.li_labels[row][1]
示例#36
0
 def gridDato(self, grid, fila, oColumna):
     if oColumna.clave == "ETIQUETA":
         lb = self.liPGN[fila][0]
         ctra = lb.upper()
         trad = TrListas.pgnLabel(lb)
         if trad != ctra:
             clave = trad
         else:
             if lb:
                 clave = lb  # [0].upper()+lb[1:].lower()
             else:
                 clave = ""
         return clave
     return self.liPGN[fila][1]
示例#37
0
 def lista_columnas(self):
     dcabs = self.dbGames.recuperaConfig("dcabs", DBgames.drots.copy())
     o_columns = Columnas.ListaColumnas()
     o_columns.nueva("__num__", _("N."), 60, centered=True)
     li_tags = self.dbGames.li_tags()
     st100 = {"Event", "Site", "White", "Black"}
     for tag in li_tags:
         rotulo = TrListas.pgnLabel(tag)
         if rotulo == tag:
             rotulo = dcabs.get(rotulo, rotulo)
         centered = not (tag in ("Event", "Site"))
         ancho = 100 if tag in st100 else 80
         o_columns.nueva(tag, rotulo, ancho, centered=centered)
     o_columns.nueva("rowid", _("Row ID"), 60, centered=True)
     return o_columns
示例#38
0
 def grid_dato(self, grid, row, o_column):
     if o_column.key == "ETIQUETA":
         lb = self.liPGN[row][0]
         ctra = lb.upper()
         trad = TrListas.pgnLabel(lb)
         if trad != ctra:
             key = trad
         else:
             if lb:
                 key = lb  # [0].upper()+lb[1:].lower()
             else:
                 key = ""
         return key
     if row < len(self.liPGN):
         return self.liPGN[row][1]
示例#39
0
    def __init__(self, procesador):

        titulo = _("Learn a game")
        QTVarios.WDialogo.__init__(self, procesador.pantalla, titulo, Iconos.PGN(), "learngame")

        self.procesador = procesador
        self.configuracion = procesador.configuracion

        self.db = LearnPGNs(self.configuracion.ficheroLearnPGN)

        # Historico
        oColumnas = Columnas.ListaColumnas()

        def creaCol(clave, rotulo, siCentrado=True):
            oColumnas.nueva(clave, rotulo, 80, siCentrado=siCentrado)

        # # Claves segun orden estandar
        liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK", "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO" )
        for clave in liBasic:
            rotulo = TrListas.pgnLabel(clave)
            creaCol(clave, rotulo, clave != "EVENT")
        self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True)
        self.grid.setMinimumWidth(self.grid.anchoColumnas() + 20)

        # Tool bar
        liAcciones = (
            ( _("Quit"), Iconos.MainMenu(), "terminar" ), None,
            ( _("New"), Iconos.TutorialesCrear(), "nuevo" ), None,
            ( _("Remove"), Iconos.Borrar(), "borrar" ), None,
            ( _("Start"), Iconos.Empezar(), "empezar" ),
        )
        self.tb = Controles.TB(self, liAcciones)

        # Colocamos
        lyTB = Colocacion.H().control(self.tb).margen(0)
        ly = Colocacion.V().otro(lyTB).control(self.grid).margen(3)

        self.setLayout(ly)

        self.registrarGrid(self.grid)
        self.recuperarVideo(siTam=False)

        self.grid.gotop()
示例#40
0
    def creaListaSonidos(self):

        self.liSonidos = [
            ["MC", _("After rival move"), None],
        ]

        # self.liSonidos.append( [ None, "", None ] )
        self.liSonidos.append([None, "- " + _("Results") + " -", None])

        d = collections.OrderedDict()
        d["GANAMOS"] = _("You win")
        d["GANARIVAL"] = _("Opponent wins")
        d["TABLAS"] = _("Stalemate")
        d["TABLASREPETICION"] = _("Draw due to three times repetition")
        d["TABLAS50"] = _("Draw according to the 50 move rule")
        d["TABLASFALTAMATERIAL"] = _("Draw, not enough material")
        d["GANAMOSTIEMPO"] = _("You win on time")
        d["GANARIVALTIEMPO"] = _("Opponent has won on time")

        for c, tr in d.iteritems():
            self.liSonidos.append([c, tr, None])

        # self.liSonidos.append( [ None, "", None ] )
        self.liSonidos.append([None, "- " + _("Rival moves") + " -", None])

        for c in "abcdefgh12345678":
            self.liSonidos.append([c, c, None])

        for c in "KQRBNP":
            t = TrListas.letterPiece(c)
            self.liSonidos.append([c, t, None])

        for c in ( "O-O", "O-O-O", "=", "x", "#", "+" ):
            self.liSonidos.append([c, c, None])

        self.liSonidos.append([None, "", None])
        self.liSonidos.append(["ZEITNOT", _("Zeitnot"), None])
示例#41
0
def cambiaColoresPGN(ventana, configuracion):
    liGen = [(None, None)]

    dicNAGs = TrListas.dicNAGs()
    config = FormLayout.Colorbox(dicNAGs[1], 80, 20, siSTR=True)
    liGen.append(( config, configuracion.color_nag1 ))

    config = FormLayout.Colorbox(dicNAGs[2], 80, 20, siSTR=True)
    liGen.append(( config, configuracion.color_nag2 ))

    config = FormLayout.Colorbox(dicNAGs[3], 80, 20, siSTR=True)
    liGen.append(( config, configuracion.color_nag3 ))

    config = FormLayout.Colorbox(dicNAGs[4], 80, 20, siSTR=True)
    liGen.append(( config, configuracion.color_nag4 ))

    config = FormLayout.Colorbox(dicNAGs[5], 80, 20, siSTR=True)
    liGen.append(( config, configuracion.color_nag5 ))

    config = FormLayout.Colorbox(dicNAGs[6], 80, 20, siSTR=True)
    liGen.append(( config, configuracion.color_nag6 ))

    resultado = FormLayout.fedit(liGen, title=_("PGN"), parent=ventana, icon=Iconos.Vista(), siDefecto=True)
    if resultado:
        accion, liResp = resultado
        if accion == "defecto":
            configuracion.coloresPGNdefecto()
            configuracion.graba()
            cambiaColoresPGN(ventana, configuracion)
        else:
            configuracion.color_nag1 = liResp[0]
            configuracion.color_nag2 = liResp[1]
            configuracion.color_nag3 = liResp[2]
            configuracion.color_nag4 = liResp[3]
            configuracion.color_nag5 = liResp[4]
            configuracion.color_nag6 = liResp[5]
            configuracion.graba()
示例#42
0
    def lee(self):
        self.siAplazada = False

        if not os.path.isfile(self.fichero):
            CajonDesastre.compruebaCambioVersion(self)

        else:
            fbak = self.fichero + ".CP.%d" % NIVELBAK
            if not Util.existeFichero(fbak):
                Util.copiaFichero(self.fichero, fbak)
            dic = Util.recuperaDIC(self.fichero)
            if dic:
                dg = dic.get
                self.id = dic["ID"]
                self.version = dic.get("VERSION", "")
                self.jugador = dic["JUGADOR"]
                self.estilo = dg("ESTILO", "Cleanlooks")
                self.tiempoTutor = dic["TIEMPOTUTOR"]
                if self.tiempoTutor == 0:
                    self.tiempoTutor = 3000

                self.siSuenaBeep = dic["SIBEEP"]
                self.siSuenaJugada = dg("SISUENAJUGADA", False)
                self.siSuenaResultados = dg("SISUENARESULTADOS", False)
                self.siSuenaNuestro = dg("SISUENANUESTRO", False)

                self.efectosVisuales = dg("EFECTOS_VISUALES", True)
                self.rapidezMovPiezas = dg("RAPIDEZMOVPIEZAS", self.rapidezMovPiezas)
                self.siAtajosRaton = dg("ATAJOS_RATON", False)
                self.showCandidates = dg("SHOW_CANDIDATES", False)
                self.siActivarCapturas = dg("ACTIVAR_CAPTURAS", self.siActivarCapturas)
                self.siActivarInformacion = dg("ACTIVAR_INFORMACION", self.siActivarInformacion)
                self.guardarVariantesTutor = dg("GUARDAR_VARIANTES", True)

                self.dirSalvados = dic["DIRSALVADOS"]
                self.dirPGN = dg("DIRPGN", "")
                self.dirJS = dg("DIRJS", "")
                self.traductor = dic["TRADUCTOR"].lower()
                self.salvarFichero = dic["SALVAR_FICHERO"]
                self.salvarGanados = dic["SALVAR_GANADOS"]
                self.salvarPerdidos = dic["SALVAR_PERDIDOS"]
                self.salvarAbandonados = dg("SALVAR_ABANDONADOS", False)
                self.salvarCSV = dg("SALVAR_CSV", "")
                self.vistaTutor = dg("VISTA_TUTOR", kTutorH)
                self.rival = self.buscaRival(dic["RIVAL"], self.rivalInicial)
                self.tutor = self.buscaTutor(dic["TUTOR"], self.tutorInicial)

                self.siNomPiezasEN = dg("SINOMPIEZASEN", self.siNomPiezasEN)

                self.tutorDifPts = dg("TUTOR_DIFPTS", 0)
                self.tutorDifPorc = dg("TUTOR_DIFPORC", 0)
                self.tutorActivoPorDefecto = dg("TUTORACTIVODEFECTO", True)
                self.tutorMultiPV = dg("TUTOR_MULTIPV", "MX")

                fich = dg("DBGAMES", self.ficheroDBgames)
                if os.path.isfile(fich):
                    self.ficheroDBgames = fich
                fich = dg("DBGAMESFEN", self.ficheroDBgamesFEN)
                if os.path.isfile(fich):
                    self.ficheroDBgamesFEN = fich
                self.ficheroBookGuide = dg("BOOKGUIDE", self.ficheroBookGuide)

                self.elo = dg("ELO", 0)
                self.eloNC = dg("ELONC", 1600)
                self.michelo = dg("MICHELO", self.michelo)
                self.micheloNC = dg("MICHELONC", self.micheloNC)
                self.fics = dg("FICS", self.fics)
                self.ficsNC = dg("FICSNC", self.ficsNC)
                self.fide = dg("FIDE", self.fide)
                self.fideNC = dg("FIDENC", self.fideNC)

                self.siDGT = dg("SIDGT", False)

                self.familia = dg("FAMILIA", self.familia)

                self.puntosMenu = dg("PUNTOSMENU", self.puntosMenu)
                self.boldMenu = dg("BOLDMENU", self.boldMenu)

                self.puntosTB = dg("PUNTOSTB", self.puntosTB)
                self.boldTB = dg("BOLDTB", self.boldTB)

                self.color_nag1 = dg("COLOR_NAG1", self.color_nag1)
                self.color_nag2 = dg("COLOR_NAG2", self.color_nag2)
                self.color_nag3 = dg("COLOR_NAG3", self.color_nag3)
                self.color_nag4 = dg("COLOR_NAG4", self.color_nag4)
                self.color_nag5 = dg("COLOR_NAG5", self.color_nag5)
                self.color_nag6 = dg("COLOR_NAG6", self.color_nag6)
                self.tamFontRotulos = dg("TAMFONTROTULOS", self.tamFontRotulos)
                self.anchoPGN = dg("ANCHOPGN", self.anchoPGN)
                self.puntosPGN = dg("PUNTOSPGN", self.puntosPGN)
                self.altoFilaPGN = dg("ALTOFILAPGN", self.altoFilaPGN)
                self.figurinesPGN = dg("FIGURINESPGN", False)
                self.showVariantes = dg("SHOW_VARIANTES", False)
                self.tipoMaterial = dg("TIPOMATERIAL", self.tipoMaterial)

                self.ficheroBMT = dg("FICHEROBMT", self.ficheroBMT)

                self.liTrasteros = dg("TRASTEROS", [])
                self.liFavoritos = dg("FAVORITOS", [])
                self.liPersonalidades = dg("PERSONALIDADES", [])

                self.centipawns = dg("CENTIPAWNS", self.centipawns)

                self.voice = dg("VOICE", self.voice)

                for k in dic.keys():
                    if k.startswith("RIVAL_"):
                        claveK = k[6:]
                        for clave, rival in self.dicRivales.iteritems():
                            if rival.clave == claveK:
                                rival.lee(dic[k])
                if "APLAZAMIENTO" in dic:
                    self.siAplazada = True
                    try:
                        self.aplazamiento = Util.txt2dic(dic["APLAZAMIENTO"])
                    except:
                        self.aplazamiento = None
                        self.siAplazada = False
                    self.graba()

        self.dicTrad = {'english': "en", 'español': "es", 'francais': "fr",
                        'deutsch': "de", 'portuguese': "pt", 'russian': "ru",
                        "italiano": "it", "azeri": "az", "català": "ca",
                        "vietnamese": "vi", "swedish": "sv"}

        # Si viene de la instalacion
        for k, v in self.dicTrad.iteritems():
            if os.path.isfile(v + '.pon'):
                self.traductor = v
                self.graba()
                os.remove(v + '.pon')
        # Versiones antiguas
        if self.traductor in self.dicTrad:
            self.traductor = self.dicTrad[self.traductor]

        self.releeTRA()

        TrListas.ponPiecesLNG(self.siNomPiezasEN or self.traductor == "en")

        self.setVoice()
示例#43
0
 def info(self):
     pz = TrListas.letterPiece(self._pieza)
     return (pz if pz.isupper() else pz.lower()) + " -> " + self._desde
示例#44
0
 def nombre(self):
     return TrListas.categoria(self.clave)
示例#45
0
    def __init__(self, owner, dbf, dClaves, gestor, estado, siElegir):
        titulo = _("Choose a game to view") if siElegir else _("PGN viewer")
        icono = Iconos.PGN()
        extparam = "pgnelegir"
        QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)

        self.siElegir = siElegir
        self.gestor = gestor
        self.dClaves = dClaves = copy.deepcopy(dClaves)
        self.seHaBorradoAlgo = False  # Para que se haga un touch antiguo al DB y lo regenere la proxima vez
        siRepite = estado is not None
        if siRepite:
            self.estado = estado
        else:
            self.estado = EstadoWpgn()
        self.dbf = dbf
        if siRepite:
            self.estado.recuperaDBF(dbf)
        else:
            self.dbf.leer()

        # Filtro
        self.liFiltro = self.estado.liFiltro if siRepite else []

        # Status bar-> antes que grid porque se actualiza en gridNumDatos
        self.status = QtGui.QStatusBar(self)
        self.status.setFixedHeight(22)

        # Lista
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva("numero", _("N."), 50, siCentrado=True)

        def creaCol(clave, rotulo, siCentrado=True):
            tam = max(dClaves[clave], len(rotulo), 11)
            oColumnas.nueva(clave, rotulo, tam * 6, siCentrado=siCentrado)

        # # Claves segun orden estandar
        liBasic = ("EVENT", "SITE", "DATE", "ROUND", "WHITE", "BLACK", "RESULT", "ECO", "FEN", "WHITEELO", "BLACKELO" )
        self.liOrdenClaves = []  # nos servira en el exterior, para paste pgn y para mostrar info
        for clave in liBasic:
            if clave in dClaves:
                rotulo = TrListas.pgnLabel(clave)
                creaCol(clave, rotulo, clave != "EVENT")
                self.liOrdenClaves.append(clave)
        for clave in dClaves:
            if clave.upper() not in liBasic:
                rotulo = TrListas.pgnLabel(clave)
                creaCol(clave.upper(), rotulo, clave != "EVENT")
                self.liOrdenClaves.append(clave.upper())

        dicVideoGrid = self.estado.dicVideoGrid if siRepite else None
        self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, dicVideo=dicVideoGrid, siSeleccionMultiple=True)

        if siRepite:
            self.grid.goto(self.estado.recno, 0)
        else:
            self.grid.gotop()

        if siRepite:
            self.estado.recuperaWindow(self)
        else:
            n = self.grid.anchoColumnas() + 20
            w, h = QTUtil.tamEscritorio()
            self.resize(min(w * 9 / 10, n), h * 8 / 10)

        # Toolbar
        if siElegir:
            liAcciones = [( _("Choose"), Iconos.Aceptar(), self.elegir ), None,
                          ( _("Cancel"), Iconos.Cancelar(), self.cancelar ), None,
                          ( _("First"), Iconos.Inicio(), self.grid.gotop ),
                          ( _("Last"), Iconos.Final(), self.grid.gobottom ), None,
                          ( _("Filter"), Iconos.Filtrar(), self.filtrar ), None,
            ]
        else:
            liAcciones = [
                ( _("Close"), Iconos.MainMenu(), self.cancelar ), None,
                ( _("View"), Iconos.Ver(), self.elegir ), None,
                ( _("Edit"), Iconos.Modificar(), self.editar ), None,
                ( _("Save"), Iconos.Grabar(), self.guardar ), None,
                ( _("First"), Iconos.Inicio(), self.grid.gotop ),
                ( _("Last"), Iconos.Final(), self.grid.gobottom ), None,
                ( _("Filter"), Iconos.Filtrar(), self.filtrar ), None,
                ( _("Remove"), Iconos.Borrar(), self.borrar ), None,
                ( _("Utilities"), Iconos.Utilidades(), self.utilidades ), None
            ]
        tb = Controles.TBrutina(self, liAcciones)

        # Layout
        layout = Colocacion.V().control(tb).control(self.grid).control(self.status).margen(3)
        self.setLayout(layout)

        self.recuperarVideo(siTam=False)
        self.ponStatus()
示例#46
0
    def inicio(self, posEntreno, numEntrenos, titEntreno, liEntrenos, siTutorActivado=None, jump=False):
        if hasattr(self, "reiniciando"):
            if self.reiniciando:
                return
        self.reiniciando = True

        if siTutorActivado is None:
            siTutorActivado = (VarGen.dgtDispatch is None) and self.configuracion.tutorActivoPorDefecto

        self.posEntreno = posEntreno
        self.guardaPosicion(posEntreno)
        self.numEntrenos = numEntrenos
        self.titEntreno = titEntreno
        self.liEntrenos = liEntrenos
        self.jump = jump

        self.liHistorico = [self.posEntreno]

        self.ayudas = 99999

        fenInicial = self.liEntrenos[self.posEntreno - 1].strip()
        self.fenInicial = fenInicial

        self.rivalPensando = False

        self.dicEtiquetasPGN = None

        # Dirigido
        etiDirigido = ""
        self.siDirigido = False
        self.siDirigidoSeguir = None
        self.siDirigidoVariantes = False
        siPartidaOriginal = False
        if "|" in fenInicial:
            li = fenInicial.split("|")

            fenInicial = li[0]
            if fenInicial.endswith(" 0"):
                fenInicial = fenInicial[:-1] + "1"

            nli = len(li)
            if nli >= 2:
                etiDirigido = li[1]

                # # Solucion
                if nli >= 3:
                    solucion = li[2]
                    if solucion:
                        self.dicDirigidoFen = PGN.leeEntDirigido(fenInicial, solucion)
                        self.siDirigido = self.dicDirigidoFen and len(self.dicDirigidoFen) > 0

                    ## Partida original
                    if nli >= 4:
                        if nli > 4:
                            txt = "|".join(li[3:])
                        else:
                            txt = li[3]
                        txt = txt.replace("]", "]\n").replace(" [", "[")
                        pgn = PGN.UnPGN()
                        pgn.leeTexto(txt)
                        partida = pgn.partida
                        siEstaFen = False
                        njug = partida.numJugadas()
                        for n in range(njug - 1, -1, -1):
                            jg = partida.jugada(n)
                            if jg.posicion.fen() == fenInicial:
                                siEstaFen = True
                                if n + 1 != njug:
                                    partida.liJugadas = partida.liJugadas[:n + 1]
                                    partida.ultPosicion = jg.posicion.copia()
                                break
                        if siEstaFen:
                            siPartidaOriginal = True
                            self.partida = partida
                            self.pgn.partida = partida
                            self.dicEtiquetasPGN = pgn.dic
                            # if etiDirigido:
                            # etiDirigido += "<br>"
                            # for k, v in pgn.dic.iteritems():
                            # if k.upper() != "FEN":
                            # if etiDirigido:
                            # etiDirigido += "<br>"
                            # etiDirigido += "%s: <b>%s</b>"%(k,v)

        cp = ControlPosicion.ControlPosicion()
        cp.leeFen(fenInicial)

        self.fen = fenInicial

        siBlancas = cp.siBlancas

        if not siPartidaOriginal:
            self.partida.reset(cp)

        self.partida.pendienteApertura = False

        self.tipoJuego = kJugEntPos

        self.siJuegaHumano = False
        self.estado = kJugando
        self.siJuegaPorMi = True

        self.siJugamosConBlancas = siBlancas
        self.siRivalConBlancas = not siBlancas

        self.liVariantes = []

        self.rmRival = None

        self.siTutorActivado = siTutorActivado
        self.pantalla.ponActivarTutor(self.siTutorActivado)

        self.ayudasPGN = 0

        liOpciones = [k_mainmenu, k_cambiar, k_reiniciar, k_atras]
        if self.dicEtiquetasPGN:
            liOpciones.append(k_pgnInformacion)
        if self.numEntrenos > 1:
            liOpciones.append(k_anterior)
            liOpciones.append(k_siguiente)
        liOpciones.extend((k_configurar, k_utilidades))
        self.liOpcionesToolBar = liOpciones
        self.pantalla.ponToolBar(liOpciones)

        self.pantalla.activaJuego(True, False, siAyudas=False)
        self.pantalla.quitaAyudas(False, False)
        self.ponMensajero(self.mueveHumano)
        self.ponPosicion(self.partida.ultPosicion)
        self.mostrarIndicador(True)
        self.ponPiezasAbajo(siBlancas)
        titulo = "<b>%s</b>" % TrListas.dicTraining().get(self.titEntreno, self.titEntreno)
        if etiDirigido:
            titulo += "<br>%s" % etiDirigido
        self.ponRotulo1(titulo)
        self.ponRotulo2("%d / %d" % (posEntreno, numEntrenos))
        self.pgnRefresh(True)
        QTUtil.xrefreshGUI()

        self.xrival = self.procesador.creaGestorMotor(self.configuracion.tutor, self.configuracion.tiempoTutor, None)

        self.siAnalizadoTutor = False

        self.ponPosicionDGT()

        if siPartidaOriginal:
            # self.ponteAlFinal()
            self.repiteUltimaJugada()

        self.reiniciando = False
        self.rivalPensando = False
        self.siguienteJugada()
示例#47
0
    def __init__(self, procesador, winBookGuide, dbGames, wsummary, siMoves=True, siFEN=False):
        QtGui.QWidget.__init__(self)

        self.winBookGuide = winBookGuide
        self.dbGames = dbGames  # <--setdbGames
        self.procesador = procesador
        self.configuracion = procesador.configuracion

        self.siMoves = siMoves

        self.wsummary = wsummary
        self.infoMove = None  # <-- setInfoMove
        self.summaryActivo = None  # movimiento activo en summary
        self.numJugada = 0  # Se usa para indicarla al mostrar el pgn en infoMove

        self.liFiltro = []
        self.siFiltro = False

        # Grid
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva("numero", _("N."), 70, siCentrado=True)
        liBasic = dbGames.liCamposBase
        ancho = 70
        for clave in liBasic:
            rotulo = TrListas.pgnLabel(clave)
            siCentrado = clave != "EVENT"
            if siFEN:
                ancho = 140 if clave == "FEN" else 70  # para que sirva con WBG_GamesFEN
            oColumnas.nueva(clave, rotulo, ancho, siCentrado=siCentrado)

        self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, siSeleccionMultiple=True, id="wgames")

        # Status bar
        self.status = QtGui.QStatusBar(self)
        self.btLeerMas = Controles.PB(self, _("Show more games"), rutina=self.leerMas, plano=False)
        self.btLeerMas.setFixedHeight(18)
        self.status.addPermanentWidget(self.btLeerMas)
        self.status.setFixedHeight(22)

        # ToolBar
        liAccionesWork = [
            ( _("Close"), Iconos.MainMenu(), self.tw_terminar ), None,
            ( _("New"), Iconos.Nuevo(), self.tw_nuevo ), None,
            ( _("Edit"), Iconos.Modificar(), self.tw_editar ), None,
            ( _("First"), Iconos.Inicio(), self.tw_gotop ), None,
            ( _("Last"), Iconos.Final(), self.tw_gobottom ), None,
            ( _("Filter"), Iconos.Filtrar(), self.tw_filtrar ), None,
            ( _("Remove"), Iconos.Borrar(), self.tw_borrar ), None, None,
            ( _("Change"), Iconos.DatabaseF() if siFEN else Iconos.DatabaseC(), self.tg_change ), None,
            ( _("Import"), Iconos.MasDoc(), self.tg_importar ), None,
            ( _("Export"), Iconos.Grabar(), self.tg_exportar ), None,
        ]
        if not siFEN:
            liAccionesWork.extend([( _("Utilities"), Iconos.Utilidades(), self.tw_utilidades ), None])

        self.tbWork = Controles.TBrutina(self, liAccionesWork, tamIcon=24)

        self.lbName = Controles.LB(self, "").ponWrap().alinCentrado().ponColorFondoN("white", "#4E5A65").ponTipoLetra(
            puntos=16)
        lyNT = Colocacion.H().control(self.lbName)
        if not siMoves:
            self.lbName.hide()

        lyTB = Colocacion.H().control(self.tbWork).relleno()  # .control(self.tbGen)

        layout = Colocacion.V().otro(lyNT).otro(lyTB).control(self.grid).control(self.status).margen(1)

        self.setLayout(layout)

        self.setNameToolBar()
示例#48
0
    def __init__(self, owner, nomPiezasOri):

        titulo = _("Blindfold") + " - " + _("Configuration")
        icono = Iconos.Ojo()
        extparam = "wblindfold"
        QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)

        self.config = BlindfoldConfig(nomPiezasOri)
        self.nomPiezasOri = nomPiezasOri

        lbWhite = Controles.LB(self, _("White")).ponTipoLetra(peso=75, puntos=10)
        lbBlack = Controles.LB(self, _("Black")).ponTipoLetra(peso=75, puntos=10)

        self.dicWidgets = collections.OrderedDict()
        self.dicImgs = {}

        liOpciones = (
            ( _("Hide"), HIDE ),
            ( _("Green"), GREY ),
            ( _("Checker"), CHECKER ),
            ( _("Show"), SHOW ),
        )
        dicNomPiezas = TrListas.dicNomPiezas()

        def haz(pz):
            tpW = self.config.dicPiezas[pz.upper()]
            tpB = self.config.dicPiezas[pz]
            lbPZw = Controles.LB(self)
            cbPZw = Controles.CB(self, liOpciones, tpW).capturaCambiado(self.reset)
            lbPZ = Controles.LB(self, dicNomPiezas[pz.upper()]).ponTipoLetra(peso=75, puntos=10)
            lbPZb = Controles.LB(self)
            cbPZb = Controles.CB(self, liOpciones, tpB).capturaCambiado(self.reset)
            self.dicWidgets[pz] = [lbPZw, cbPZw, lbPZ, lbPZb, cbPZb, None, None]

        for pz in "kqrbnp":
            haz(pz)

        btAllW = Controles.PB(self, _("All White"), self.allWhite, plano=False)
        self.cbAll = Controles.CB(self, liOpciones, HIDE)
        btAllB = Controles.PB(self, _("All Black"), self.allBlack, plano=False)

        btSwap = Controles.PB(self, _("Swap"), self.swap, plano=False)

        liAcciones = (  ( _("Save"), Iconos.Grabar(), "grabar" ), None,
                        ( _("Cancel"), Iconos.Cancelar(), "cancelar" ), None,
                        ( _("Configurations"), Iconos.Opciones(), "configurations" ), None,
        )
        tb = Controles.TB(self, liAcciones)

        ly = Colocacion.G()
        ly.controlc(lbWhite, 0, 1).controlc(lbBlack, 0, 3)
        fila = 1
        for pz in "kqrbnp":
            lbPZw, cbPZw, lbPZ, lbPZb, cbPZb, tipoW, tipoB = self.dicWidgets[pz]
            ly.control(cbPZw, fila, 0)
            ly.controlc(lbPZw, fila, 1)
            ly.controlc(lbPZ, fila, 2)
            ly.controlc(lbPZb, fila, 3)
            ly.control(cbPZb, fila, 4)
            fila += 1

        ly.filaVacia(fila, 20)
        fila += 1

        ly.controld(btAllW, fila, 0, 1, 2)
        ly.control(self.cbAll, fila, 2)
        ly.control(btAllB, fila, 3, 1, 2)
        ly.controlc(btSwap, fila + 1, 0, 1, 5)
        ly.margen(20)

        layout = Colocacion.V().control(tb).otro(ly)

        self.setLayout(layout)

        self.reset()
示例#49
0
    def lanza(self, siFavoritos=True):

        self.comprueba()

        liFavoritos = None
        if siFavoritos:
            liFav = self.procesador.configuracion.liFavoritos
            if liFav:
                li = []
                for elem in liFav:
                    if elem in self.dicMenu:
                        li.append(self.dicMenu[elem])
                liFavoritos = li

        if liFavoritos:
            menu = self.menuFavoritos(liFavoritos)
        else:
            menu = self.menu

        resp = menu.lanza()

        if resp:
            siStr = type(resp) == type("")
            if siStr:
                if resp == "menu_global":
                    self.lanza(False)

                elif resp == "gm":
                    self.entrenaGM()

                elif resp.startswith("mate"):
                    self.jugarMate(int(resp[-1]))

                elif resp == "bmt":
                    self.bmt()

                elif resp == "polyglot":
                    self.entrenaBooks()

                elif resp.startswith("boxing"):
                    self.boxing(resp[6:])

                elif resp in ["j60_rival", "j60_jugador"]:
                    self.jugar60(resp == "j60_jugador")

                elif resp == "aperturas":
                    self.aperturas()

                elif resp == "dailytest":
                    self.dailyTest()

                elif resp == "potencia":
                    self.potencia()

                elif resp == "visualiza":
                    self.visualiza()

                elif resp.startswith("tactica|"):
                    nada, tipo, nombre, carpeta, ini = resp.split("|")
                    self.tacticas(tipo, nombre, carpeta, ini)

                elif resp.startswith("remtactica|"):
                    nada, carpeta, nombre = resp.split("|")
                    self.tacticaRemove(carpeta, nombre)

                elif resp.startswith("puente_"):
                    self.puente(int(resp[7:]))

                elif resp.startswith("horses_"):
                    test = int(resp[7])
                    icl, icn, tit = self.horsesDef[test]
                    icon = VarGen.todasPiezas.icono(icl, icn)
                    self.horses(test, tit, icon)

                elif resp.startswith("ep_"):
                    um = self.procesador.unMomento()
                    entreno = resp[3:].replace("\\", "/")
                    if "/" in entreno:
                        dicTraining = TrListas.dicTraining()
                        titentreno = ""
                        for x in entreno[:-4].split("/")[1:]:
                            titentreno += dicTraining.get(x, x) + "/"
                        titentreno = titentreno[:-1]
                    f = PGNreader.openCodec(entreno)
                    todo = f.read().strip()
                    f.close()
                    liEntrenamientos = todo.split("\n")
                    nPosiciones = len(liEntrenamientos)
                    um.final()
                    if nPosiciones == 0:
                        return
                    elif nPosiciones == 1:
                        pos = 1
                        jump = False
                    else:
                        db = Util.DicSQL(self.configuracion.ficheroTrainings)
                        posUltimo = db[entreno]
                        if posUltimo is None:
                            posUltimo = 1
                        resp = DatosNueva.numPosicion(self.procesador.pantalla,
                                                     titentreno, nPosiciones, posUltimo)
                        if resp is None:
                            return
                        pos, tipo, jump = resp
                        db.close()
                        if tipo.startswith( "r" ):
                            if tipo == "rk":
                                random.seed(pos)
                            random.shuffle(liEntrenamientos)
                    self.procesador.entrenaPos(pos, nPosiciones, titentreno, liEntrenamientos, entreno, jump)

                elif resp == "learnPGN":
                    self.learnPGN()

                elif resp == "lucaselo":
                    self.procesador.lucaselo(False)

                elif resp == "micelo":
                    self.procesador.micelo(False)

                elif resp.startswith("fics"):
                    self.procesador.ficselo(False, int(resp[4:]))

                elif resp.startswith("fide"):
                    self.procesador.fideelo(False, int(resp[4:]))

                elif resp.startswith("map_"):
                    nada, mapa = resp.split("_")
                    self.procesador.trainingMap(mapa)

            else:
                if resp <= -100:
                    self.menu = None  # ya que puede cambiar y la etiqueta es diferente
                    mem = Memoria.Memoria(self.procesador)
                    mem.lanza(abs(resp) - 100)
示例#50
0
    def __init__(self, wParent):
        QtGui.QWidget.__init__(self, wParent)

        self.wParent = wParent

        self.jg = None
        self.partida = None

        puntos = VarGen.configuracion.puntosPGN

        f = Controles.TipoLetra(puntos=puntos, peso=75)
        # ftxt = Controles.TipoLetra( nombre="Courier New", puntos=puntos )
        f9 = Controles.TipoLetra(puntos=puntos)
        ftxt = f9

        # Apertura
        self.lbApertura = Controles.LB(self, "").ponFuente(f).alinCentrado().ponColorFondoN("#eeeeee", "#474d59").ponWrap()
        self.lbApertura.hide()

        # Valoracion
        liOpciones = [("-", "-")]
        dicNAGs = TrListas.dicNAGs()

        carpNAGs = "./IntFiles/NAGs"

        for x in dicNAGs:
            if x:
                fsvg = "%s/$%d.svg" % (carpNAGs, x)
                if os.path.isfile(fsvg):
                    liOpciones.append(("$%d : %s" % ( x, dicNAGs[x]), str(x), QTVarios.fsvg2ico(fsvg, 16)))
                else:
                    liOpciones.append(("$%d : %s" % ( x, dicNAGs[x]), str(x)))
        self.maxNAGs = 10
        self.liNAGs = []
        for x in range(self.maxNAGs):
            cb = Controles.CB(self, liOpciones, "").ponAnchoMinimo().capturaCambiado(self.valoracionCambiada).ponFuente(
                f9)
            if x:
                cb.hide()
            self.liNAGs.append(cb)

        liOpciones = [(x, x) for x in ("-", "!", "!!", "?", "??", "!?", "?!" )]
        self.valoracionDirecta = Controles.CB(self, liOpciones, "-").ponAnchoFijo(42).capturaCambiado(self.valoracionDirectaCambiada)

        lyH = Colocacion.H().control(self.valoracionDirecta).control(self.liNAGs[0])
        ly = Colocacion.V().otro(lyH)
        for x in range(1, self.maxNAGs):
            ly.control(self.liNAGs[x])

        self.gbValoracion = Controles.GB(self, _("Rating"), ly).ponFuente(f)

        # Comentarios
        self.comentario = Controles.EM(self, siHTML=False).capturaCambios(self.comentarioCambiado).ponFuente(
            ftxt).anchoMinimo(200)

        ly = Colocacion.H().control(self.comentario)
        self.gbComentario = Controles.GB(self, _("Comments"), ly).ponFuente(f)

        # Variantes
        liAcciones = (
            ( _("Append"), Iconos.Mas(), "tbMasVariante" ), None,
            ( "%s+%s" % (_("Append"), _("Engine")), Iconos.MasR(), "tbMasVarianteR" ), None,
            ( _("Edit"), Iconos.ComentarioEditar(), "tbEditarVariante" ), None,
            ( _("Remove"), Iconos.Borrar(), "tbBorrarVariante" ), None,
        )
        tbVariantes = Controles.TB(self, liAcciones, siTexto=False, tamIcon=16)

        self.variantes = Controles.EM(self, siHTML=False).capturaCambios(self.variantesCambiado).ponFuente(ftxt)
        self.variantes.capturaDobleClick(self.variantesDobleClick)

        ly = Colocacion.V().control(tbVariantes).control(self.variantes)
        self.gbVariantes = Controles.GB(self, _("Variants"), ly).ponFuente(f)

        layout = Colocacion.V()
        layout.control(self.lbApertura)
        layout.control(self.gbValoracion)
        layout.control(self.gbComentario)
        layout.control(self.gbVariantes)
        layout.margen(5)

        self.setLayout(layout)
示例#51
0
    def creaMenu(self):
        dicMenu = {}
        menu = QTVarios.LCMenu(self.parent)

        def xopcion(menu, clave, texto, icono, siDeshabilitado=False):
            menu.opcion(clave, texto, icono, siDeshabilitado)
            dicMenu[clave] = (clave, texto, icono, siDeshabilitado )

        # Posiciones de entrenamiento --------------------------------------------------------------------------
        self.menuFNS(menu, _("Training positions"), xopcion)
        menu.separador()

        # GM ---------------------------------------------------------------------------------------------------
        xopcion(menu, "gm", _("Play like a grandmaster"), Iconos.GranMaestro())
        menu.separador()

        # Mate --------------------------------------------------------------------------------------------------
        menu1 = menu.submenu(_("Training mates"), Iconos.Mate())
        for mate in range(1, 5):
            xopcion(menu1, "mate%d" % mate, _X(_("Mate in %1"), str(mate)), Iconos.PuntoAzul())
            menu1.separador()
        menu.separador()

        # BMT -------------------------------------------------------------------------------------------
        xopcion(menu, "bmt", _("Find best move"), Iconos.BMT())
        menu.separador()

        # Openings ------------------------------------------------------------------------------------------------
        menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
        # # Aperturas --------------------------------------------------------------------------------------------
        xopcion(menu1, "aperturas", _("Learn openings by repetition"), Iconos.Apertura())
        menu1.separador()
        ## Books ------------------------------------------------------------------------------------------------
        xopcion(menu1, "polyglot", _("Training with a book"), Iconos.Libros())

        menu.separador()

        # DailyTest ------------------------------------------------------------------------------------------------
        xopcion(menu, "dailytest", _("Your daily test"), Iconos.DailyTest())
        menu.separador()

        # Resistencia ------------------------------------------------------------------------------------------
        menu1 = menu.submenu(_("Resistance Test"), Iconos.Resistencia())
        nico = Util.Rondo(Iconos.Verde(), Iconos.Azul(), Iconos.Amarillo(), Iconos.Naranja())
        xopcion(menu1, "boxing", _("Normal"), nico.otro())
        xopcion(menu1, "boxingc", _("Blindfold chess"), nico.otro())
        xopcion(menu1, "boxingp1", _("Hide only our pieces"), nico.otro())
        xopcion(menu1, "boxingp2", _("Hide only opponent pieces"), nico.otro())
        menu.separador()

        # Tacticas ---------------------------------------------------------------------------------------------
        menu1 = menu.submenu(_("Learn tactics by repetition"), Iconos.Tacticas())
        nico = Util.Rondo(Iconos.Amarillo(), Iconos.Naranja(), Iconos.Verde(), Iconos.Azul(), Iconos.Magenta())
        dicTraining = TrListas.dicTraining()

        def trTraining(txt):
            return dicTraining.get(txt, txt)

        def menuTacticas(tipo, carpetaBase):
            lista = []
            if os.path.isdir(carpetaBase):
                li = Util.listdir(carpetaBase)
                for nombre in li:
                    carpeta = os.path.join(carpetaBase, nombre)
                    ini = os.path.join(carpeta, "Config.ini")
                    if os.path.isdir(carpeta) and os.path.isfile(ini):
                        xopcion(menu1, "tactica|%s|%s|%s|%s" % (tipo, nombre, carpeta, ini), trTraining(nombre),
                                nico.otro())
                        menu1.separador()
                        lista.append((carpeta, nombre))
            return lista

        menuTacticas("B", "Tactics")
        carpetaTacticasP = os.path.join(self.configuracion.dirPersonalTraining, "Tactics")
        lista = menuTacticas("P", carpetaTacticasP)
        if lista:
            ico = Iconos.Delete()
            menub = menu1.submenu(_("Remove"), ico)
            for carpeta, nombre in lista:
                xopcion(menub, "remtactica|%s|%s" % (carpeta, nombre), trTraining(nombre), ico)

        menu.separador()

        # Maps ----------------------------------------------------------------------------------------
        menu1 = menu.submenu(_("Training on a map"), Iconos.Maps())
        xopcion(menu1, "map_Africa", _("Africa map"), Iconos.Africa())
        menu1.separador()
        xopcion(menu1, "map_WorldMap", _("World map"), Iconos.WorldMap())

        # Cebras ---------------------------------------------------------------------------------------------------
        menu.separador()
        menu1 = menu.submenu(_("Resources for zebras"), Iconos.Cebra())
        menu2 = menu1.submenu(_("Check your memory on a chessboard"), Iconos.Memoria())
        rival = self.configuracion.rival

        mem = Memoria.Memoria(self.procesador)

        for x in range(6):
            cat = rival.categorias.numero(x)
            txt = cat.nombre()

            nm = mem.nivel(x)
            if nm > -1:
                txt += " %s %d" % (_("Level"), nm + 1)

            xopcion(menu2, -100 - x, txt, cat.icono(), siDeshabilitado=not mem.siActiva(x))

        menu1.separador()

        menu2 = menu1.submenu(_("Find all moves"), Iconos.J60())
        xopcion(menu2, "j60_rival", _("Opponent"), Iconos.PuntoNaranja())
        xopcion(menu2, "j60_jugador", _("Player"), Iconos.PuntoAzul())

        menu1.separador()
        self.horsesDef = hd = {
            1: ( "N", "Alpha", _("Basic test") ),
            2: ( "p", "Fantasy", _("Four pawns test") ),
            3: ( "Q", "Pirat", _("Jonathan Levitt test") ),
            4: ( "n", "Spatial", _("Basic test") + ": a1" ),
            5: ( "N", "Cburnett", _("Basic test") + ": e4" )
        }
        menu2 = menu1.submenu(_("Becoming a knight tamer"), self.procesador.tablero.piezas.icono("N"))
        vicon = VarGen.todasPiezas.icono
        icl, icn, tit = hd[1]
        menu3 = menu2.submenu(tit, vicon(icl, icn))
        xopcion(menu3, "horses_1", tit, vicon(icl, icn))
        menu3.separador()
        icl, icn, tit = hd[4]
        xopcion(menu3, "horses_4", tit, vicon(icl, icn))
        menu3.separador()
        icl, icn, tit = hd[5]
        xopcion(menu3, "horses_5", tit, vicon(icl, icn))
        menu2.separador()
        icl, icn, tit = hd[2]
        xopcion(menu2, "horses_2", tit, vicon(icl, icn))
        menu2.separador()
        icl, icn, tit = hd[3]
        xopcion(menu2, "horses_3", tit, vicon(icl, icn))

        menu1.separador()
        menu2 = menu1.submenu(_("Moves between two positions"), Iconos.Puente())
        rp = QTVarios.rondoPuntos()
        for x in range(1, 11):
            xopcion(menu2, "puente_%d" % x, "%s %d" % (_("Level"), x), rp.otro())

        menu1.separador()
        xopcion(menu1, "potencia", _("Determine your calculating power"), Iconos.Potencia())

        menu1.separador()
        xopcion(menu1, "learnPGN", _("Learn a game"), Iconos.PGN())

        menu1.separador()
        xopcion(menu1, "visualiza", _("The board at a glance"), Iconos.Gafas())

        # Ratings
        menu.separador()
        menu1 = menu.submenu(_("Training ratings"), Iconos.Elo())
        xopcion(menu1, "lucaselo", "%s (%d)" % (_("Lucas-Elo"), self.configuracion.eloNC), Iconos.Elo())
        menu1.separador()
        xopcion(menu1, "micelo", "%s (%d)" % (_("Tourney-Elo"), self.configuracion.micheloNC), Iconos.EloTimed())
        menu1.separador()
        fics = self.configuracion.ficsNC
        menuf = menu1.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
        rp = QTVarios.rondoPuntos()
        for elo in range(900, 2800, 100):
            if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <= (fics - elo) <= 400):
                xopcion(menuf, "fics%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
        menu1.separador()
        fide = self.configuracion.fideNC
        menuf = menu1.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
        rp = QTVarios.rondoPuntos()
        for elo in range(1500, 2700, 100):
            if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <= (fide - elo) <= 400):
                xopcion(menuf, "fide%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())

        return menu, dicMenu