def handleArgs(self, chess_file): if chess_file: def do(discoverer): newGameDialog.LoadFileExtension.run(chess_file) glock.glock_connect_after(discoverer, "all_engines_discovered", do)
def __init__ (self): #GObject.GObject.__init__(self,0,0,0,0) GObject.GObject.__init__(self) self.widgets = widgets = uistuff.GladeWidgets("taskers.glade") tasker = widgets["newGameTasker"] tasker.unparent() self.add(tasker) combo = ToggleComboBox() combo.addItem(_("White"), GdkPixbuf.Pixbuf.new_from_file(addDataPrefix("glade/white.png"))) combo.addItem(_("Black"), GdkPixbuf.Pixbuf.new_from_file(addDataPrefix("glade/black.png"))) combo.addItem(_("Random"), GdkPixbuf.Pixbuf.new_from_file(addDataPrefix("glade/random.png"))) combo.setMarkup("<b>", "</b>") widgets["colorDock"].add(combo) uistuff.keep(combo, "newgametasker_colorcombo") widgets['yourColorLabel'].set_mnemonic_widget(combo) # We need to wait until after engines have been discovered, to init the # playerCombos. We use connect_after to make sure, that newGameDialog # has also had time to init the constants we share with them. self.playerCombo = ToggleComboBox() widgets["opponentDock"].add(self.playerCombo) glock_connect_after(discoverer, "all_engines_discovered", self.__initPlayerCombo, widgets) widgets['opponentLabel'].set_mnemonic_widget(self.playerCombo) def on_skill_changed (scale): pix = newGameDialog.skillToIconLarge[int(scale.get_value())] widgets["skillImage"].set_from_pixbuf(pix) widgets["skillSlider"].connect("value-changed", on_skill_changed) on_skill_changed(widgets["skillSlider"]) widgets["startButton"].connect("clicked", self.startClicked) self.widgets["opendialog1"].connect("clicked", self.openDialogClicked)
def __init__ (self): gtk.Alignment.__init__(self,0,0,0,0) self.widgets = widgets = uistuff.GladeWidgets("taskers.glade") tasker = widgets["newGameTasker"] tasker.unparent() self.add(tasker) combo = ToggleComboBox() combo.addItem(_("White"), pixbuf_new_from_file(addDataPrefix("glade/white.png"))) combo.addItem(_("Black"), pixbuf_new_from_file(addDataPrefix("glade/black.png"))) combo.addItem(_("Random"), pixbuf_new_from_file(addDataPrefix("glade/random.png"))) combo.setMarkup("<b>", "</b>") widgets["colorDock"].add(combo) uistuff.keep(combo, "newgametasker_colorcombo") widgets['yourColorLabel'].set_mnemonic_widget(combo) # We need to wait until after engines have been discovered, to init the # playerCombos. We use connect_after to make sure, that newGameDialog # has also had time to init the constants we share with them. self.playerCombo = ToggleComboBox() widgets["opponentDock"].add(self.playerCombo) glock_connect_after(discoverer, "all_engines_discovered", self.__initPlayerCombo, widgets) widgets['opponentLabel'].set_mnemonic_widget(self.playerCombo) def on_skill_changed (scale): pix = newGameDialog.skillToIconLarge[int(scale.get_value())] widgets["skillImage"].set_from_pixbuf(pix) widgets["skillSlider"].connect("value-changed", on_skill_changed) on_skill_changed(widgets["skillSlider"]) widgets["startButton"].connect("clicked", self.startClicked) self.widgets["opendialog1"].connect("clicked", self.openDialogClicked)
def add(button): self.add = True response = engine_chooser_dialog.run() if response == Gtk.ResponseType.OK: new_engine = engine_chooser_dialog.get_filename() if new_engine: try: uci = is_uci(new_engine) if not uci: if not is_cecp(new_engine): # restore the original engine = discoverer.getEngineByName( self.cur_engine) engine_chooser_dialog.set_filename( engine["command"]) print("Maybe not a chess engine") return path, binname = os.path.split(new_engine) for e in discoverer.getEngines(): if e["name"] == binname: binname = e["name"] + "(1)" break self.widgets["engine_command_entry"].set_text( new_engine) self.widgets["engine_protocol_combo"].set_active( 0 if uci else 1) self.widgets["engine_args_entry"].set_text("") active = self.widgets[ "engine_protocol_combo"].get_active() protocol = "uci" if active == 0 else "xboard" discoverer.addEngine(binname, new_engine, protocol) self.cur_engine = binname glock_connect_after(discoverer, "engine_discovered", update_store) self.add = False discoverer.discover() except: print("There is something wrong with this executable") else: # restore the original engine = discoverer.getEngineByName(self.cur_engine) engine_chooser_dialog.set_filename(engine["command"]) engine_chooser_dialog.hide()
def add(button): self.add = True response = engine_chooser_dialog.run() if response == gtk.RESPONSE_OK: new_engine = engine_chooser_dialog.get_filename() if new_engine: try: uci = is_uci(new_engine) if not uci: if not is_cecp(new_engine): # restore the original engine = discoverer.getEngineByName(self.cur_engine) engine_chooser_dialog.set_filename(engine["command"]) print "Maybe not a chess engine" return path, binname = os.path.split(new_engine) for e in discoverer.getEngines(): if e["name"] == binname: binname = e["name"] + "(1)" break self.widgets["engine_name_entry"].set_text(binname) self.widgets["engine_command_entry"].set_text(new_engine) self.widgets["engine_protocol_combo"].set_active(0 if uci else 1) self.widgets["engine_args_entry"].set_text("") name = self.widgets["engine_name_entry"].get_text().strip() active = self.widgets["engine_protocol_combo"].get_active() protocol = "uci" if active==0 else "xboard" discoverer.addEngine(name, new_engine, protocol) self.cur_engine = name glock_connect_after(discoverer, "engine_discovered", update_store) self.add = False discoverer.start() except: print "There is something wrong with this executable" else: # restore the original engine = discoverer.getEngineByName(self.cur_engine) engine_chooser_dialog.set_filename(engine["command"]) engine_chooser_dialog.hide()
def protocol_changed(widget): if self.cur_engine is not None and not self.add and not self.selection: active = self.widgets["engine_protocol_combo"].get_active() new_protocol = "uci" if active==0 else "xboard" engine = discoverer.getEngineByName(self.cur_engine) old_protocol = engine["protocol"] if new_protocol != old_protocol: engine_command = engine_chooser_dialog.get_filename() # is the new protocol supported by the engine? if new_protocol == "uci": ok = is_uci(engine_command) else: ok = is_cecp(engine_command) if ok: # discover engine options for new protocol engine["protocol"] = new_protocol engine["recheck"] = True glock_connect_after(discoverer, "engine_discovered", update_options) discoverer.start() else: # restore the original protocol widgets["engine_protocol_combo"].set_active(0 if old_protocol=="uci" else 1)
def protocol_changed(widget): if self.cur_engine is not None and not self.add and not self.selection: active = self.widgets["engine_protocol_combo"].get_active() new_protocol = "uci" if active == 0 else "xboard" engine = discoverer.getEngineByName(self.cur_engine) old_protocol = engine["protocol"] if new_protocol != old_protocol: engine_command = engine_chooser_dialog.get_filename() # is the new protocol supported by the engine? if new_protocol == "uci": ok = is_uci(engine_command) else: ok = is_cecp(engine_command) if ok: # discover engine options for new protocol engine["protocol"] = new_protocol engine["recheck"] = True glock_connect_after(discoverer, "engine_discovered", update_options) discoverer.discover() else: # restore the original protocol widgets["engine_protocol_combo"].set_active( 0 if old_protocol == "uci" else 1)
def _init(cls): cls.widgets = uistuff.GladeWidgets("newInOut.glade") uistuff.createCombo(cls.widgets["whitePlayerCombobox"]) uistuff.createCombo(cls.widgets["blackPlayerCombobox"]) cls.widgets["playersIcon"].set_from_pixbuf(big_people) cls.widgets["timeIcon"].set_from_pixbuf(big_time) def on_playerCombobox_changed(widget, skillHbox): skillHbox.props.visible = widget.get_active() > 0 cls.widgets["whitePlayerCombobox"].connect("changed", on_playerCombobox_changed, cls.widgets["skillHbox1"]) cls.widgets["blackPlayerCombobox"].connect("changed", on_playerCombobox_changed, cls.widgets["skillHbox2"]) cls.widgets["whitePlayerCombobox"].set_active(0) cls.widgets["blackPlayerCombobox"].set_active(1) def on_skill_changed(scale, image): image.set_from_pixbuf(skillToIcon[int(scale.get_value())]) cls.widgets["skillSlider1"].connect("value-changed", on_skill_changed, cls.widgets["skillIcon1"]) cls.widgets["skillSlider2"].connect("value-changed", on_skill_changed, cls.widgets["skillIcon2"]) cls.widgets["skillSlider1"].set_value(3) cls.widgets["skillSlider2"].set_value(3) cls.__initTimeRadio(_("Blitz"), "ngblitz", cls.widgets["blitzRadio"], cls.widgets["configImageBlitz"], 5, 0) cls.__initTimeRadio(_("Rapid"), "ngrapid", cls.widgets["rapidRadio"], cls.widgets["configImageRapid"], 15, 5) cls.__initTimeRadio(_("Normal"), "ngnormal", cls.widgets["normalRadio"], cls.widgets["configImageNormal"], 40, 15) cls.__initVariantRadio("ngvariant1", cls.widgets["playVariant1Radio"], cls.widgets["configImageVariant1"], FISCHERRANDOMCHESS) cls.__initVariantRadio("ngvariant2", cls.widgets["playVariant2Radio"], cls.widgets["configImageVariant2"], LOSERSCHESS) def updateCombos(*args): if cls.widgets["playNormalRadio"].get_active(): variant = NORMALCHESS elif cls.widgets["playVariant1Radio"].get_active(): variant = conf.get("ngvariant1", FISCHERRANDOMCHESS) else: variant = conf.get("ngvariant2", LOSERSCHESS) variant1 = conf.get("ngvariant1", FISCHERRANDOMCHESS) cls.widgets["playVariant1Radio"].set_tooltip_text( variants[variant1].__desc__) variant2 = conf.get("ngvariant2", LOSERSCHESS) cls.widgets["playVariant2Radio"].set_tooltip_text( variants[variant2].__desc__) data = [(item[0], item[1]) for item in playerItems[variant]] uistuff.updateCombo(cls.widgets["blackPlayerCombobox"], data) uistuff.updateCombo(cls.widgets["whitePlayerCombobox"], data) glock_connect_after(discoverer, "all_engines_discovered", updateCombos) updateCombos(discoverer) conf.notify_add("ngvariant1", updateCombos) conf.notify_add("ngvariant2", updateCombos) cls.widgets["playNormalRadio"].connect("toggled", updateCombos) cls.widgets["playNormalRadio"].set_tooltip_text( variants[NORMALCHESS].__desc__) cls.widgets["playVariant1Radio"].connect("toggled", updateCombos) variant1 = conf.get("ngvariant1", FISCHERRANDOMCHESS) cls.widgets["playVariant1Radio"].set_tooltip_text( variants[variant1].__desc__) cls.widgets["playVariant2Radio"].connect("toggled", updateCombos) variant2 = conf.get("ngvariant2", LOSERSCHESS) cls.widgets["playVariant2Radio"].set_tooltip_text( variants[variant2].__desc__) # The "variant" has to come before players, because the engine positions # in the user comboboxes can be different in different variants for key in ("whitePlayerCombobox", "blackPlayerCombobox", "skillSlider1", "skillSlider2", "notimeRadio", "blitzRadio", "rapidRadio", "normalRadio", "playNormalRadio", "playVariant1Radio", "playVariant2Radio"): uistuff.keep(cls.widgets[key], key) # We don't want the dialog to deallocate when closed. Rather we hide # it on respond cls.widgets["newgamedialog"].connect("delete_event", lambda *a: True)
def initialize(gameDic): uistuff.keep(widgets["showEval"], "showEval") uistuff.keep(widgets["showBlunder"], "showBlunder", first_value=True) uistuff.keep(widgets["max_analysis_spin"], "max_analysis_spin", first_value=3) uistuff.keep(widgets["variation_thresold_spin"], "variation_thresold_spin", first_value=50) # Analyzing engines uistuff.createCombo(widgets["ana_combobox"]) from pychess.widgets import newGameDialog def update_analyzers_store(discoverer): data = [(item[0], item[1]) for item in newGameDialog.analyzerItems] uistuff.updateCombo(widgets["ana_combobox"], data) glock_connect_after(discoverer, "all_engines_discovered", update_analyzers_store) update_analyzers_store(discoverer) uistuff.keep(widgets["ana_combobox"], "ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value(combobox, value, "hint_mode", "analyzer_check", HINT)) def hide_window(button, *args): stop_event.set() widgets["analyze_game"].hide() widgets["analyze_ok_button"].set_sensitive(True) return True def run_analyze(button, *args): old_check_value = conf.get("analyzer_check", True) conf.set("analyzer_check", True) widgets["analyze_ok_button"].set_sensitive(False) gmwidg = gamewidget.cur_gmwidg() gamemodel = gameDic[gmwidg] analyzer = gamemodel.spectators[HINT] def analyse_moves(): move_time = int(conf.get("max_analysis_spin", 3)) thresold = int(conf.get("variation_thresold_spin", 50)) for board in gamemodel.boards: if stop_event.is_set(): break glock.acquire() try: gmwidg.board.view.setShownBoard(board) finally: glock.release() analyzer.setBoard(board) time.sleep(move_time+0.1) ply = board.ply if ply-1 in gamemodel.scores: color = (ply-1) % 2 oldmoves, oldscore, olddepth = gamemodel.scores[ply-1] oldscore = oldscore * -1 if color == BLACK else oldscore moves, score, depth = gamemodel.scores[ply] score = score * -1 if color == WHITE else score diff = score-oldscore if (diff > thresold and color==BLACK) or (diff < -1*thresold and color==WHITE): gamemodel.add_variation(gamemodel.boards[ply-1], oldmoves) widgets["analyze_game"].hide() widgets["analyze_ok_button"].set_sensitive(True) conf.set("analyzer_check", old_check_value) t = threading.Thread(target=analyse_moves, name=fident(analyse_moves)) t.daemon = True t.start() return True widgets["analyze_game"].connect("delete-event", hide_window) widgets["analyze_cancel_button"].connect("clicked", hide_window) widgets["analyze_ok_button"].connect("clicked", run_analyze)
def __init__(self, widgets): self.widgets = widgets # Options on by default for key in ("opening_check", "endgame_check", "online_egtb_check", "analyzer_check", "inv_analyzer_check"): uistuff.keep(widgets[key], key, first_value=True) # Opening book default_path = os.path.join(addDataPrefix("pychess_book.bin")) path = conf.get("opening_file_entry", default_path) conf.set("opening_file_entry", path) book_chooser_dialog = Gtk.FileChooserDialog( _("Select book file"), None, Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK), ) book_chooser_button = Gtk.FileChooserButton(book_chooser_dialog) filter = Gtk.FileFilter() filter.set_name(_("Opening books")) filter.add_pattern("*.bin") book_chooser_dialog.add_filter(filter) book_chooser_button.set_filename(path) self.widgets["bookChooserDock"].add(book_chooser_button) book_chooser_button.show() def select_new_book(button): new_book = book_chooser_dialog.get_filename() if new_book: conf.set("opening_file_entry", new_book) else: # restore the original book_chooser_dialog.set_filename(path) book_chooser_button.connect("file-set", select_new_book) def on_opening_check_toggled(check): widgets["opening_hbox"].set_sensitive(check.get_active()) widgets["opening_check"].connect_after("toggled", on_opening_check_toggled) # Endgame default_path = os.path.join(getDataPrefix()) egtb_path = conf.get("egtb_path", default_path) conf.set("egtb_path", egtb_path) egtb_chooser_dialog = Gtk.FileChooserDialog( _("Select Gaviota TB path"), None, Gtk.FileChooserAction.SELECT_FOLDER, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK), ) egtb_chooser_button = Gtk.FileChooserButton.new_with_dialog(egtb_chooser_dialog) egtb_chooser_button.set_current_folder(egtb_path) self.widgets["egtbChooserDock"].add(egtb_chooser_button) egtb_chooser_button.show() def select_egtb(button): new_directory = egtb_chooser_dialog.get_filename() if new_directory != egtb_path: conf.set("egtb_path", new_directory) egtb_chooser_button.connect("current-folder-changed", select_egtb) def on_endgame_check_toggled(check): widgets["endgame_hbox"].set_sensitive(check.get_active()) widgets["endgame_check"].connect_after("toggled", on_endgame_check_toggled) # Analyzing engines uistuff.createCombo(widgets["ana_combobox"]) uistuff.createCombo(widgets["inv_ana_combobox"]) from pychess.widgets import newGameDialog def update_analyzers_store(discoverer): data = [(item[0], item[1]) for item in newGameDialog.analyzerItems] uistuff.updateCombo(widgets["ana_combobox"], data) uistuff.updateCombo(widgets["inv_ana_combobox"], data) glock_connect_after(discoverer, "all_engines_discovered", update_analyzers_store) update_analyzers_store(discoverer) # Save, load and make analyze combos active conf.set("ana_combobox", conf.get("ana_combobox", 0)) conf.set("inv_ana_combobox", conf.get("inv_ana_combobox", 0)) def on_analyzer_check_toggled(check): widgets["analyzers_vbox"].set_sensitive(check.get_active()) from pychess.Main import gameDic if gameDic: if check.get_active(): for gmwidg in gameDic.keys(): gmwidg.gamemodel.restart_analyzer(HINT) if not widgets["hint_mode"].get_active(): gmwidg.gamemodel.pause_analyzer(HINT) else: for gmwidg in gameDic.keys(): gmwidg.gamemodel.remove_analyzer(HINT) widgets["analyzers_vbox"].set_sensitive(widgets["analyzer_check"].get_active()) widgets["analyzer_check"].connect_after("toggled", on_analyzer_check_toggled) def on_invanalyzer_check_toggled(check): widgets["inv_analyzers_vbox"].set_sensitive(check.get_active()) from pychess.Main import gameDic if gameDic: if check.get_active(): for gmwidg in gameDic.keys(): gmwidg.gamemodel.restart_analyzer(SPY) if not widgets["spy_mode"].get_active(): gmwidg.gamemodel.pause_analyzer(SPY) else: for gmwidg in gameDic.keys(): gmwidg.gamemodel.remove_analyzer(SPY) widgets["inv_analyzers_vbox"].set_sensitive(widgets["inv_analyzer_check"].get_active()) widgets["inv_analyzer_check"].connect_after("toggled", on_invanalyzer_check_toggled) # Give widgets to keeper uistuff.keep( widgets["ana_combobox"], "ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value(combobox, value, "hint_mode", "analyzer_check", HINT), ) uistuff.keep( widgets["inv_ana_combobox"], "inv_ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value(combobox, value, "spy_mode", "inv_analyzer_check", SPY), ) uistuff.keep(widgets["max_analysis_spin"], "max_analysis_spin", first_value=3)
def initialize(gameDic): uistuff.keep(widgets["fromCurrent"], "fromCurrent", first_value=True) uistuff.keep(widgets["threatPV"], "threatPV") uistuff.keep(widgets["showEval"], "showEval") uistuff.keep(widgets["showBlunder"], "showBlunder", first_value=True) uistuff.keep(widgets["max_analysis_spin"], "max_analysis_spin", first_value=3) uistuff.keep(widgets["variation_thresold_spin"], "variation_thresold_spin", first_value=50) # Analyzing engines uistuff.createCombo(widgets["ana_combobox"]) from pychess.widgets import newGameDialog def update_analyzers_store(discoverer): data = [(item[0], item[1]) for item in newGameDialog.analyzerItems] uistuff.updateCombo(widgets["ana_combobox"], data) glock_connect_after(discoverer, "all_engines_discovered", update_analyzers_store) update_analyzers_store(discoverer) uistuff.keep(widgets["ana_combobox"], "ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value(combobox, value, "hint_mode", "analyzer_check", HINT)) def hide_window(button, *args): widgets["analyze_game"].hide() return True def abort (): stop_event.set() widgets["analyze_game"].hide() def run_analyze(button, *args): gmwidg = gamewidget.cur_gmwidg() gamemodel = gameDic[gmwidg] old_check_value = conf.get("analyzer_check", True) conf.set("analyzer_check", True) analyzer = gamemodel.spectators[HINT] gmwidg.menuitems["hint_mode"].active = True threat_PV = conf.get("ThreatPV", False) if threat_PV: old_inv_check_value = conf.get("inv_analyzer_check", True) conf.set("inv_analyzer_check", True) inv_analyzer = gamemodel.spectators[SPY] gmwidg.menuitems["spy_mode"].active = True title = _("Game analyzing in progress...") text = _("Do you want to abort it?") content = InfoBar.get_message_content(title, text, Gtk.STOCK_DIALOG_QUESTION) def response_cb (infobar, response, message): message.dismiss() abort() message = InfoBarMessage(Gtk.MessageType.QUESTION, content, response_cb) message.add_button(InfoBarMessageButton(_("Abort"), Gtk.ResponseType.CANCEL)) gmwidg.showMessage(message) def analyse_moves(): from_current = conf.get("fromCurrent", True) start_ply = gmwidg.board.view.shown if from_current else 0 move_time = int(conf.get("max_analysis_spin", 3)) thresold = int(conf.get("variation_thresold_spin", 50)) for board in gamemodel.boards[start_ply:]: if stop_event.is_set(): break glock.acquire() try: gmwidg.board.view.setShownBoard(board) finally: glock.release() analyzer.setBoard(board) inv_analyzer.setBoard(board) time.sleep(move_time+0.1) ply = board.ply if ply-1 in gamemodel.scores and ply in gamemodel.scores: color = (ply-1) % 2 oldmoves, oldscore, olddepth = gamemodel.scores[ply-1] score_str = prettyPrintScore(oldscore, olddepth) oldscore = oldscore * -1 if color == BLACK else oldscore moves, score, depth = gamemodel.scores[ply] score = score * -1 if color == WHITE else score diff = score-oldscore if (diff > thresold and color==BLACK) or (diff < -1*thresold and color==WHITE): if threat_PV: try: oldmoves0, oldscore0, olddepth0 = gamemodel.spy_scores[ply-1] score_str0 = prettyPrintScore(oldscore0, olddepth0) pv0 = listToMoves(gamemodel.boards[ply-1], ["--"] + oldmoves0, validate=True) gamemodel.add_variation(gamemodel.boards[ply-1], pv0, comment="Treatening", score=score_str0) except ParsingError as e: # ParsingErrors may happen when parsing "old" lines from # analyzing engines, which haven't yet noticed their new tasks log.debug("__parseLine: Ignored (%s) from analyzer: ParsingError%s" % \ (' '.join(oldmoves),e)) try: pv = listToMoves(gamemodel.boards[ply-1], oldmoves, validate=True) gamemodel.add_variation(gamemodel.boards[ply-1], pv, comment="Better is", score=score_str) except ParsingError as e: # ParsingErrors may happen when parsing "old" lines from # analyzing engines, which haven't yet noticed their new tasks log.debug("__parseLine: Ignored (%s) from analyzer: ParsingError%s" % \ (' '.join(oldmoves),e)) widgets["analyze_game"].hide() widgets["analyze_ok_button"].set_sensitive(True) conf.set("analyzer_check", old_check_value) if threat_PV: conf.set("inv_analyzer_check", old_inv_check_value) message.dismiss() t = threading.Thread(target=analyse_moves, name=fident(analyse_moves)) t.daemon = True t.start() hide_window(None) return True widgets["analyze_game"].connect("delete-event", hide_window) widgets["analyze_cancel_button"].connect("clicked", hide_window) widgets["analyze_ok_button"].connect("clicked", run_analyze)
def __init__(self, gamemodel=None): gtk.DrawingArea.__init__(self) if gamemodel == None: gamemodel = GameModel() self.model = gamemodel glock_connect(self.model, "game_started", self.game_started) glock_connect_after(self.model, "game_started", self.game_started_after) glock_connect_after(self.model, "game_changed", self.game_changed) glock_connect_after(self.model, "moves_undoing", self.moves_undoing) glock_connect_after(self.model, "game_loading", self.game_loading) glock_connect_after(self.model, "game_loaded", self.game_loaded) glock_connect_after(self.model, "game_ended", self.game_ended) self.connect("expose_event", self.expose) self.connect_after("realize", self.on_realized) conf.notify_add("showCords", self.on_show_cords) conf.notify_add("faceToFace", self.on_face_to_face) self.set_size_request(350,350) self.animationStart = time() self.lastShown = None self.deadlist = [] self.autoUpdateShown = True self.padding = 0 # Set to self.pad when setcords is active self.square = 0, 0, 8, 1 # An object global variable with the current # board size self.pad = 0.13 # Padding applied only when setcords is active self._selected = None self._hover = None self._active = None self._redarrow = None self._greenarrow = None self._bluearrow = None self._shown = self.model.ply self._showCords = False self.showCords = conf.get("showCords", False) self._showEnpassant = False self.lastMove = None self.matrix = cairo.Matrix() self.matrixPi = cairo.Matrix.init_rotate(pi) self.cordMatricesState = (0, 0) self._rotation = 0 self.drawcount = 0 self.drawtime = 0 self.gotStarted = False self.animationLock = RLock() self.rotationLock = Lock() self.draggedPiece = None # a piece being dragged by the user
def __init__(self, widgets): self.widgets = widgets # Options on by default for key in ("opening_check", "endgame_check", "online_egtb_check", "analyzer_check", "inv_analyzer_check"): uistuff.keep(widgets[key], key, first_value=True) # Opening book default_path = os.path.join(addDataPrefix("pychess_book.bin")) path = conf.get("opening_file_entry", default_path) conf.set("opening_file_entry", path) book_chooser_dialog = Gtk.FileChooserDialog( _("Select book file"), None, Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)) book_chooser_button = Gtk.FileChooserButton(book_chooser_dialog) filter = Gtk.FileFilter() filter.set_name(_("Opening books")) filter.add_pattern("*.bin") book_chooser_dialog.add_filter(filter) book_chooser_button.set_filename(path) self.widgets["bookChooserDock"].add(book_chooser_button) book_chooser_button.show() def select_new_book(button): new_book = book_chooser_dialog.get_filename() if new_book: conf.set("opening_file_entry", new_book) else: # restore the original book_chooser_dialog.set_filename(path) book_chooser_button.connect("file-set", select_new_book) def on_opening_check_toggled(check): widgets["opening_hbox"].set_sensitive(check.get_active()) widgets["opening_check"].connect_after("toggled", on_opening_check_toggled) # Endgame default_path = os.path.join(getDataPrefix()) egtb_path = conf.get("egtb_path", default_path) conf.set("egtb_path", egtb_path) egtb_chooser_dialog = Gtk.FileChooserDialog( _("Select Gaviota TB path"), None, Gtk.FileChooserAction.SELECT_FOLDER, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)) egtb_chooser_button = Gtk.FileChooserButton.new_with_dialog( egtb_chooser_dialog) egtb_chooser_button.set_current_folder(egtb_path) self.widgets["egtbChooserDock"].add(egtb_chooser_button) egtb_chooser_button.show() def select_egtb(button): new_directory = egtb_chooser_dialog.get_filename() if new_directory != egtb_path: conf.set("egtb_path", new_directory) egtb_chooser_button.connect("current-folder-changed", select_egtb) def on_endgame_check_toggled(check): widgets["endgame_hbox"].set_sensitive(check.get_active()) widgets["endgame_check"].connect_after("toggled", on_endgame_check_toggled) # Analyzing engines uistuff.createCombo(widgets["ana_combobox"]) uistuff.createCombo(widgets["inv_ana_combobox"]) from pychess.widgets import newGameDialog def update_analyzers_store(discoverer): data = [(item[0], item[1]) for item in newGameDialog.analyzerItems] uistuff.updateCombo(widgets["ana_combobox"], data) uistuff.updateCombo(widgets["inv_ana_combobox"], data) glock_connect_after(discoverer, "all_engines_discovered", update_analyzers_store) update_analyzers_store(discoverer) # Save, load and make analyze combos active conf.set("ana_combobox", conf.get("ana_combobox", 0)) conf.set("inv_ana_combobox", conf.get("inv_ana_combobox", 0)) def on_analyzer_check_toggled(check): widgets["analyzers_vbox"].set_sensitive(check.get_active()) from pychess.Main import gameDic if gameDic: if check.get_active(): for gmwidg in gameDic.keys(): gmwidg.gamemodel.restart_analyzer(HINT) if not widgets["hint_mode"].get_active(): gmwidg.gamemodel.pause_analyzer(HINT) else: for gmwidg in gameDic.keys(): gmwidg.gamemodel.remove_analyzer(HINT) widgets["analyzers_vbox"].set_sensitive( widgets["analyzer_check"].get_active()) widgets["analyzer_check"].connect_after("toggled", on_analyzer_check_toggled) def on_invanalyzer_check_toggled(check): widgets["inv_analyzers_vbox"].set_sensitive(check.get_active()) from pychess.Main import gameDic if gameDic: if check.get_active(): for gmwidg in gameDic.keys(): gmwidg.gamemodel.restart_analyzer(SPY) if not widgets["spy_mode"].get_active(): gmwidg.gamemodel.pause_analyzer(SPY) else: for gmwidg in gameDic.keys(): gmwidg.gamemodel.remove_analyzer(SPY) widgets["inv_analyzers_vbox"].set_sensitive( widgets["inv_analyzer_check"].get_active()) widgets["inv_analyzer_check"].connect_after( "toggled", on_invanalyzer_check_toggled) # Give widgets to keeper uistuff.keep( widgets["ana_combobox"], "ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value( combobox, value, "hint_mode", "analyzer_check", HINT)) uistuff.keep( widgets["inv_ana_combobox"], "inv_ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value( combobox, value, "spy_mode", "inv_analyzer_check", SPY)) uistuff.keep(widgets["max_analysis_spin"], "max_analysis_spin", first_value=3)
def __init__(self, gamemodel=None): gtk.DrawingArea.__init__(self) if gamemodel == None: gamemodel = GameModel() self.model = gamemodel glock_connect(self.model, "game_started", self.game_started) glock_connect_after(self.model, "game_started", self.game_started_after) glock_connect_after(self.model, "game_changed", self.game_changed) glock_connect_after(self.model, "moves_undoing", self.moves_undoing) glock_connect_after(self.model, "game_loading", self.game_loading) glock_connect_after(self.model, "game_loaded", self.game_loaded) glock_connect_after(self.model, "game_ended", self.game_ended) self.connect("expose_event", self.expose) self.connect_after("realize", self.on_realized) conf.notify_add("showCords", self.on_show_cords) conf.notify_add("faceToFace", self.on_face_to_face) self.set_size_request(350, 350) self.animationStart = time() self.lastShown = None self.deadlist = [] self.autoUpdateShown = True self.padding = 0 # Set to self.pad when setcords is active self.square = 0, 0, 8, 1 # An object global variable with the current # board size self.pad = 0.13 # Padding applied only when setcords is active self._selected = None self._hover = None self._active = None self._redarrow = None self._greenarrow = None self._bluearrow = None self._shown = self.model.ply self._showCords = False self.showCords = conf.get("showCords", False) self._showEnpassant = False self.lastMove = None self.matrix = cairo.Matrix() self.matrixPi = cairo.Matrix.init_rotate(pi) self.cordMatricesState = (0, 0) self._rotation = 0 self.drawcount = 0 self.drawtime = 0 self.gotStarted = False self.animationLock = RLock() self.rotationLock = Lock() self.draggedPiece = None # a piece being dragged by the user
def initialize(gameDic): uistuff.keep(widgets["showEval"], "showEval") uistuff.keep(widgets["showBlunder"], "showBlunder", first_value=True) uistuff.keep(widgets["max_analysis_spin"], "max_analysis_spin", first_value=3) uistuff.keep(widgets["variation_thresold_spin"], "variation_thresold_spin", first_value=50) # Analyzing engines uistuff.createCombo(widgets["ana_combobox"]) from pychess.widgets import newGameDialog def update_analyzers_store(discoverer): data = [(item[0], item[1]) for item in newGameDialog.analyzerItems] uistuff.updateCombo(widgets["ana_combobox"], data) glock_connect_after(discoverer, "all_engines_discovered", update_analyzers_store) update_analyzers_store(discoverer) uistuff.keep( widgets["ana_combobox"], "ana_combobox", anal_combo_get_value, lambda combobox, value: anal_combo_set_value(combobox, value, "hint_mode", "analyzer_check", HINT), ) def hide_window(button, *args): stop_event.set() widgets["analyze_game"].hide() widgets["analyze_ok_button"].set_sensitive(True) return True def run_analyze(button, *args): old_check_value = conf.get("analyzer_check", True) conf.set("analyzer_check", True) widgets["analyze_ok_button"].set_sensitive(False) gmwidg = gamewidget.cur_gmwidg() gamemodel = gameDic[gmwidg] analyzer = gamemodel.spectators[HINT] def analyse_moves(): move_time = int(conf.get("max_analysis_spin", 3)) thresold = int(conf.get("variation_thresold_spin", 50)) for board in gamemodel.boards: if stop_event.is_set(): break glock.acquire() try: gmwidg.board.view.setShownBoard(board) finally: glock.release() analyzer.setBoard(board) time.sleep(move_time + 0.1) ply = board.ply if ply - 1 in gamemodel.scores: color = (ply - 1) % 2 oldmoves, oldscore, olddepth = gamemodel.scores[ply - 1] oldscore = oldscore * -1 if color == BLACK else oldscore moves, score, depth = gamemodel.scores[ply] score = score * -1 if color == WHITE else score diff = score - oldscore if (diff > thresold and color == BLACK) or (diff < -1 * thresold and color == WHITE): gamemodel.add_variation(gamemodel.boards[ply - 1], oldmoves) widgets["analyze_game"].hide() widgets["analyze_ok_button"].set_sensitive(True) conf.set("analyzer_check", old_check_value) t = threading.Thread(target=analyse_moves, name=fident(analyse_moves)) t.daemon = True t.start() return True widgets["analyze_game"].connect("delete-event", hide_window) widgets["analyze_cancel_button"].connect("clicked", hide_window) widgets["analyze_ok_button"].connect("clicked", run_analyze)
def __init__ (self, widgets): self.widgets = widgets # Opening book default_path = os.path.join(addDataPrefix("pychess_book.bin")) path = conf.get("opening_file_entry", default_path) conf.set("opening_file_entry", path) book_chooser_dialog = gtk.FileChooserDialog(_("Select book file"), None, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) book_chooser_button = gtk.FileChooserButton(book_chooser_dialog) filter = gtk.FileFilter() filter.set_name(_("Opening books")) filter.add_pattern("*.bin") book_chooser_dialog.add_filter(filter) book_chooser_button.set_filename(path) self.widgets["bookChooserDock"].add(book_chooser_button) book_chooser_button.show() def select_new_book(button): new_book = book_chooser_dialog.get_filename() if new_book: conf.set("opening_file_entry", new_book) else: # restore the original book_chooser_dialog.set_filename(path) book_chooser_button.connect("file-set", select_new_book) def on_opening_check_toggled (check): widgets["opening_hbox"].set_sensitive(check.get_active()) widgets["opening_check"].connect_after("toggled", on_opening_check_toggled) uistuff.keep(widgets["opening_check"], "opening_check") # Endgame conf.set("online_egtb_check", conf.get("online_egtb_check", 0)) uistuff.keep(widgets["online_egtb_check"], "online_egtb_check") default_path = os.path.join(getDataPrefix()) egtb_path = conf.get("egtb_path", default_path) conf.set("egtb_path", egtb_path) egtb_chooser_dialog = gtk.FileChooserDialog(_("Select Gaviota TB path"), None, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) egtb_chooser_button = gtk.FileChooserButton(egtb_chooser_dialog) egtb_chooser_button.set_current_folder(egtb_path) self.widgets["egtbChooserDock"].add(egtb_chooser_button) egtb_chooser_button.show() def select_egtb(button): new_directory = egtb_chooser_dialog.get_filename() if new_directory != egtb_path: conf.set("egtb_path", new_directory) egtb_chooser_button.connect("current-folder-changed", select_egtb) def on_endgame_check_toggled (check): widgets["endgame_hbox"].set_sensitive(check.get_active()) widgets["endgame_check"].connect_after("toggled", on_endgame_check_toggled) uistuff.keep(widgets["endgame_check"], "endgame_check") # Analyzing engines uistuff.createCombo(widgets["ana_combobox"]) uistuff.createCombo(widgets["inv_ana_combobox"]) from pychess.widgets import newGameDialog def update_analyzers_store(discoverer): data = [(item[0], item[1]) for item in newGameDialog.analyzerItems] uistuff.updateCombo(widgets["ana_combobox"], data) uistuff.updateCombo(widgets["inv_ana_combobox"], data) glock_connect_after(discoverer, "all_engines_discovered", update_analyzers_store) update_analyzers_store(discoverer) # Save, load and make analyze combos active conf.set("ana_combobox", conf.get("ana_combobox", 0)) conf.set("inv_ana_combobox", conf.get("inv_ana_combobox", 0)) def on_analyzer_check_toggled (check): widgets["analyzers_vbox"].set_sensitive(check.get_active()) from pychess.Main import gameDic if gameDic: if check.get_active(): for gmwidg in gameDic.keys(): gmwidg.gamemodel.restart_analyzer(HINT) else: for gmwidg in gameDic.keys(): gmwidg.gamemodel.remove_analyzer(HINT) widgets["analyzer_check"].connect_after("toggled", on_analyzer_check_toggled) uistuff.keep(widgets["analyzer_check"], "analyzer_check") def on_invanalyzer_check_toggled (check): widgets["inv_analyzers_vbox"].set_sensitive(check.get_active()) from pychess.Main import gameDic if gameDic: if check.get_active(): for gmwidg in gameDic.keys(): gmwidg.gamemodel.restart_analyzer(SPY) else: for gmwidg in gameDic.keys(): gmwidg.gamemodel.remove_analyzer(SPY) widgets["inv_analyzer_check"].connect_after("toggled", on_invanalyzer_check_toggled) uistuff.keep(widgets["inv_analyzer_check"], "inv_analyzer_check") # Give widgets to keeper def get_value (combobox): engine = list(discoverer.getAnalyzers())[combobox.get_active()] return engine.get("md5") def set_value (combobox, value, show_arrow_check, ana_check, analyzer_type): engine = discoverer.getEngineByMd5(value) if engine is None: combobox.set_active(0) # This return saves us from the None-engine being used # in later code -Jonas Thiem return else: try: index = list(discoverer.getAnalyzers()).index(engine) except ValueError: index = 0 combobox.set_active(index) replace_analyzers = False if widgets[show_arrow_check].get_active() is True and \ widgets[ana_check].get_active() is True: replace_analyzers = True from pychess.Main import gameDic for gmwidg in gameDic.keys(): spectators = gmwidg.gamemodel.spectators md5 = engine.get('md5') if analyzer_type in spectators and \ spectators[analyzer_type].md5 != md5: gmwidg.gamemodel.remove_analyzer(analyzer_type) if replace_analyzers: gmwidg.gamemodel.start_analyzer(analyzer_type) uistuff.keep(widgets["ana_combobox"], "ana_combobox", get_value, lambda combobox, value: set_value(combobox, value, "hint_mode", "analyzer_check", HINT)) uistuff.keep(widgets["inv_ana_combobox"], "inv_ana_combobox", get_value, lambda combobox, value: set_value(combobox, value, "spy_mode", "inv_analyzer_check", SPY))
def _init (cls): cls.widgets = uistuff.GladeWidgets ("newInOut.glade") uistuff.createCombo(cls.widgets["whitePlayerCombobox"]) uistuff.createCombo(cls.widgets["blackPlayerCombobox"]) cls.widgets["playersIcon"].set_from_pixbuf(big_people) cls.widgets["timeIcon"].set_from_pixbuf(big_time) def on_playerCombobox_changed (widget, skillHbox): skillHbox.props.visible = widget.get_active() > 0 cls.widgets["whitePlayerCombobox"].connect( "changed", on_playerCombobox_changed, cls.widgets["skillHbox1"]) cls.widgets["blackPlayerCombobox"].connect( "changed", on_playerCombobox_changed, cls.widgets["skillHbox2"]) cls.widgets["whitePlayerCombobox"].set_active(0) cls.widgets["blackPlayerCombobox"].set_active(1) def on_skill_changed (scale, image): image.set_from_pixbuf(skillToIcon[int(scale.get_value())]) cls.widgets["skillSlider1"].connect("value-changed", on_skill_changed, cls.widgets["skillIcon1"]) cls.widgets["skillSlider2"].connect("value-changed", on_skill_changed, cls.widgets["skillIcon2"]) cls.widgets["skillSlider1"].set_value(3) cls.widgets["skillSlider2"].set_value(3) cls.__initTimeRadio(_("Blitz"), "ngblitz", cls.widgets["blitzRadio"], cls.widgets["configImageBlitz"], 5, 0) cls.__initTimeRadio(_("Rapid"), "ngrapid", cls.widgets["rapidRadio"], cls.widgets["configImageRapid"], 15, 5) cls.__initTimeRadio(_("Normal"), "ngnormal", cls.widgets["normalRadio"], cls.widgets["configImageNormal"], 40, 15) cls.__initVariantRadio("ngvariant1", cls.widgets["playVariant1Radio"], cls.widgets["configImageVariant1"], FISCHERRANDOMCHESS) cls.__initVariantRadio("ngvariant2", cls.widgets["playVariant2Radio"], cls.widgets["configImageVariant2"], LOSERSCHESS) def updateCombos(*args): if cls.widgets["playNormalRadio"].get_active(): variant = NORMALCHESS elif cls.widgets["playVariant1Radio"].get_active(): variant = conf.get("ngvariant1", FISCHERRANDOMCHESS) else: variant = conf.get("ngvariant2", LOSERSCHESS) variant1 = conf.get("ngvariant1", FISCHERRANDOMCHESS) cls.widgets["playVariant1Radio"].set_tooltip_text(variants[variant1].__desc__) variant2 = conf.get("ngvariant2", LOSERSCHESS) cls.widgets["playVariant2Radio"].set_tooltip_text(variants[variant2].__desc__) data = [(item[0], item[1]) for item in playerItems[variant]] uistuff.updateCombo(cls.widgets["blackPlayerCombobox"], data) uistuff.updateCombo(cls.widgets["whitePlayerCombobox"], data) glock_connect_after(discoverer, "all_engines_discovered", updateCombos) updateCombos(discoverer) conf.notify_add("ngvariant1", updateCombos) conf.notify_add("ngvariant2", updateCombos) cls.widgets["playNormalRadio"].connect("toggled", updateCombos) cls.widgets["playNormalRadio"].set_tooltip_text(variants[NORMALCHESS].__desc__) cls.widgets["playVariant1Radio"].connect("toggled", updateCombos) variant1 = conf.get("ngvariant1", FISCHERRANDOMCHESS) cls.widgets["playVariant1Radio"].set_tooltip_text(variants[variant1].__desc__) cls.widgets["playVariant2Radio"].connect("toggled", updateCombos) variant2 = conf.get("ngvariant2", LOSERSCHESS) cls.widgets["playVariant2Radio"].set_tooltip_text(variants[variant2].__desc__) # The "variant" has to come before players, because the engine positions # in the user comboboxes can be different in different variants for key in ("whitePlayerCombobox", "blackPlayerCombobox", "skillSlider1", "skillSlider2", "notimeRadio", "blitzRadio", "rapidRadio", "normalRadio", "playNormalRadio", "playVariant1Radio", "playVariant2Radio"): uistuff.keep(cls.widgets[key], key) # We don't want the dialog to deallocate when closed. Rather we hide # it on respond cls.widgets["newgamedialog"].connect("delete_event", lambda *a: True)
def add(button): self.add = True response = engine_chooser_dialog.run() if response == Gtk.ResponseType.OK: new_engine = engine_chooser_dialog.get_filename() if new_engine.lower().endswith(".exe"): vm_name = "wine" vmpath = searchPath(vm_name, access=os.R_OK|os.X_OK) if vmpath is None: d = Gtk.MessageDialog( type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK) d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine)) d.format_secondary_text(_("wine not installed")) d.run() d.hide() new_engine = "" else: vmpath += " " else: vm_name = None vmpath = "" if new_engine: try: uci = is_uci(vmpath + new_engine) if not uci: if not is_cecp(vmpath + new_engine): # restore the original engine = discoverer.getEngineByName(self.cur_engine) engine_chooser_dialog.set_filename(engine["command"]) d = Gtk.MessageDialog( type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK) d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine)) d.format_secondary_text(_("There is something wrong with this executable")) d.run() d.hide() engine_chooser_dialog.hide() return path, binname = os.path.split(new_engine) for e in discoverer.getEngines(): if e["name"] == binname: binname = e["name"] + "(1)" break self.widgets["engine_command_entry"].set_text(new_engine) self.widgets["engine_protocol_combo"].set_active(0 if uci else 1) self.widgets["engine_args_entry"].set_text("") active = self.widgets["engine_protocol_combo"].get_active() protocol = "uci" if active==0 else "xboard" discoverer.addEngine(binname, new_engine, protocol, vm_name) self.cur_engine = binname glock_connect_after(discoverer, "engine_discovered", update_store) self.add = False discoverer.discover() except: d = Gtk.MessageDialog( type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK) d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine)) d.format_secondary_text(_("There is something wrong with this executable")) d.run() d.hide() else: # restore the original engine = discoverer.getEngineByName(self.cur_engine) engine_chooser_dialog.set_filename(engine["command"]) engine_chooser_dialog.hide()