def run(widgets):
global firstRun, engine_dialog
if firstRun:
# Display of the countries
items = []
for iso in ISO3166_LIST:
path = addDataPrefix("flags/%s.png" % iso.iso2)
if not (iso.iso2 and os.path.isfile(path)):
path = addDataPrefix("flags/unknown.png")
items.append((get_pixbuf(path), iso.country))
uistuff.createCombo(widgets["engine_country_combo"],
name="engine_country_combo",
ellipsize_mode=Pango.EllipsizeMode.END)
data = [(item[0], item[1]) for item in items]
uistuff.updateCombo(widgets["engine_country_combo"], data)
engine_dialog = EnginesDialog(widgets)
def cancel_event(widget, with_confirmation, *args):
# Confirm if the changes need to be saved
modified = discoverer.hasChanged()
if modified and with_confirmation:
dialog = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(
_("You have unsaved changes. Do you want to save before leaving?"
))
response = dialog.run()
dialog.destroy()
# if response == Gtk.ResponseType.CANCEL:
# return False
if response == Gtk.ResponseType.NO:
discoverer.restore()
if response == Gtk.ResponseType.YES:
discoverer.save()
# Close the window
widgets["manage_engines_dialog"].hide()
return True
def save_event(widget, *args):
discoverer.save()
widgets["manage_engines_dialog"].hide()
return True
widgets["manage_engines_dialog"].connect("delete-event", cancel_event,
True)
widgets["engine_cancel_button"].connect("clicked", cancel_event, False)
widgets["engine_save_button"].connect("clicked", save_event)
widgets["manage_engines_dialog"].connect(
"key-press-event", lambda w, e: cancel_event(w, True)
if e.keyval == Gdk.KEY_Escape else None)
discoverer.backup()
engine_dialog.widgets["enginebook"].set_current_page(0)
widgets["manage_engines_dialog"].show()
if not firstRun:
engine_dialog.update_store()
firstRun = False
def run(widgets):
global firstRun, engine_dialog
if firstRun:
# Display of the countries
items = []
for iso in ISO3166_LIST:
path = addDataPrefix("flags/%s.png" % iso.iso2)
if not(iso.iso2 and os.path.isfile(path)):
path = addDataPrefix("flags/unknown.png")
items.append((get_pixbuf(path), iso.country))
uistuff.createCombo(widgets["engine_country_combo"], name="engine_country_combo",
ellipsize_mode=Pango.EllipsizeMode.END)
data = [(item[0], item[1]) for item in items]
uistuff.updateCombo(widgets["engine_country_combo"], data)
engine_dialog = EnginesDialog(widgets)
def cancel_event(widget, with_confirmation, *args):
# Confirm if the changes need to be saved
modified = discoverer.hasChanged()
if modified and with_confirmation:
dialog = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(_("You have unsaved changes. Do you want to save before leaving?"))
response = dialog.run()
dialog.destroy()
# if response == Gtk.ResponseType.CANCEL:
# return False
if response == Gtk.ResponseType.NO:
discoverer.restore()
if response == Gtk.ResponseType.YES:
discoverer.save()
# Close the window
widgets["manage_engines_dialog"].hide()
return True
def save_event(widget, *args):
discoverer.save()
widgets["manage_engines_dialog"].hide()
return True
widgets["manage_engines_dialog"].connect("delete-event", cancel_event, True)
widgets["engine_cancel_button"].connect("clicked", cancel_event, False)
widgets["engine_save_button"].connect("clicked", save_event)
widgets["manage_engines_dialog"].connect(
"key-press-event",
lambda w, e: cancel_event(w, True) if e.keyval == Gdk.KEY_Escape else None)
discoverer.backup()
engine_dialog.widgets["enginebook"].set_current_page(0)
widgets["manage_engines_dialog"].show()
if not firstRun:
engine_dialog.update_store()
firstRun = False
def __initPlayerCombo(self, discoverer, widgets):
combo = self.playerCombo
uistuff.createCombo(combo, newGameDialog.playerItems[0])
if combo.get_active() < 0:
combo.set_active(1)
uistuff.keep(self.playerCombo, "newgametasker_playercombo")
def on_playerCombobox_changed(widget):
widgets["skillSlider"].props.visible = widget.get_active() > 0
combo.connect("changed", on_playerCombobox_changed)
uistuff.keep(widgets["skillSlider"], "taskerSkillSlider")
widgets["skillSlider"].set_no_show_all(True)
on_playerCombobox_changed(self.playerCombo)
def __initPlayerCombo(self, discoverer, widgets):
combo = self.playerCombo
uistuff.createCombo(combo, newGameDialog.playerItems[0])
if combo.get_active() < 0:
combo.set_active(1)
uistuff.keep(self.playerCombo, "newgametasker_playercombo")
def on_playerCombobox_changed(widget):
widgets["skillSlider"].props.visible = widget.get_active() > 0
combo.connect("changed", on_playerCombobox_changed)
uistuff.keep(widgets["skillSlider"], "taskerSkillSlider")
widgets["skillSlider"].set_no_show_all(True)
on_playerCombobox_changed(self.playerCombo)
def __init__(self):
GObject.GObject.__init__(self)
self.widgets = widgets = tasker_widgets
tasker = widgets["newGameTasker"]
tasker.unparent()
self.add(tasker)
startButton = self.widgets["startButton"]
startButton.set_name("startButton")
combo = Gtk.ComboBox()
uistuff.createCombo(
combo,
[
(get_pixbuf("glade/white.png"), _("White")),
(get_pixbuf("glade/black.png"), _("Black")),
(get_pixbuf("glade/random.png"), _("Random")),
],
)
widgets["colorDock"].add(combo)
if combo.get_active() < 0:
combo.set_active(0)
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 = Gtk.ComboBox()
widgets["opponentDock"].add(self.playerCombo)
discoverer.connect_after("all_engines_discovered",
self.__initPlayerCombo, widgets)
widgets["opponentLabel"].set_mnemonic_widget(self.playerCombo)
def on_skill_changed(scale):
# Just to make sphinx happy...
try:
pix = newGameDialog.skillToIconLarge[int(scale.get_value())]
widgets["skillImage"].set_from_pixbuf(pix)
except TypeError:
pass
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):
GObject.GObject.__init__(self)
self.widgets = widgets = uistuff.GladeWidgets("taskers.glade")
tasker = widgets["newGameTasker"]
tasker.unparent()
self.add(tasker)
startButton = self.widgets["startButton"]
startButton.set_name("startButton")
combo = Gtk.ComboBox()
uistuff.createCombo(combo, [
(get_pixbuf("glade/white.png"), _("White")),
(get_pixbuf("glade/black.png"), _("Black")),
(get_pixbuf("glade/random.png"), _("Random"))])
widgets["colorDock"].add(combo)
if combo.get_active() < 0:
combo.set_active(0)
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 = Gtk.ComboBox()
widgets["opponentDock"].add(self.playerCombo)
discoverer.connect_after("all_engines_discovered",
self.__initPlayerCombo, widgets)
widgets['opponentLabel'].set_mnemonic_widget(self.playerCombo)
def on_skill_changed(scale):
# Just to make sphinx happy...
try:
pix = newGameDialog.skillToIconLarge[int(scale.get_value())]
widgets["skillImage"].set_from_pixbuf(pix)
except TypeError:
pass
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 run(widgets):
global firstRun
if firstRun:
# Bubble sort for the translated countries
for i in range(len(ISO3166_LIST) - 1, 1, -1):
for j in range(1, i - 1):
if ISO3166_LIST[i].country < ISO3166_LIST[j].country:
tmp = ISO3166_LIST[i]
ISO3166_LIST[i] = ISO3166_LIST[j]
ISO3166_LIST[j] = tmp
# Display of the countries
items = []
for iso in ISO3166_LIST:
path = addDataPrefix("flags/%s.png" % iso.iso2)
if not (iso.iso2 and os.path.isfile(path)):
path = addDataPrefix("flags/unknown.png")
items.append((get_pixbuf(path), iso.country))
uistuff.createCombo(widgets["engine_country_combo"],
name="engine_country_combo")
data = [(item[0], item[1]) for item in items]
uistuff.updateCombo(widgets["engine_country_combo"], data)
EnginesDialog(widgets)
def delete_event(widget, *args):
widgets["manage_engines_dialog"].hide()
return True
widgets["manage_engines_dialog"].connect("delete-event", delete_event)
widgets["engines_close_button"].connect("clicked", delete_event)
widgets["manage_engines_dialog"].connect(
"key-press-event", lambda w, e: delete_event(w)
if e.keyval == Gdk.KEY_Escape else None)
firstRun = False
widgets["manage_engines_dialog"].show()
def run(widgets):
global firstRun
if firstRun:
# Bubble sort for the translated countries
for i in range(len(ISO3166_LIST) - 1, 1, - 1):
for j in range(1, i - 1):
if ISO3166_LIST[i].country < ISO3166_LIST[j].country:
tmp = ISO3166_LIST[i]
ISO3166_LIST[i] = ISO3166_LIST[j]
ISO3166_LIST[j] = tmp
# Display of the countries
items = []
for iso in ISO3166_LIST:
path = addDataPrefix("flags/%s.png" % iso.iso2)
if not(iso.iso2 and os.path.isfile(path)):
path = addDataPrefix("flags/unknown.png")
items.append((get_pixbuf(path), iso.country))
uistuff.createCombo(widgets["engine_country_combo"], name="engine_country_combo",
ellipsize_mode=Pango.EllipsizeMode.END)
data = [(item[0], item[1]) for item in items]
uistuff.updateCombo(widgets["engine_country_combo"], data)
EnginesDialog(widgets)
def delete_event(widget, *args):
widgets["manage_engines_dialog"].hide()
return True
widgets["manage_engines_dialog"].connect("delete-event", delete_event)
widgets["engines_close_button"].connect("clicked", delete_event)
widgets["manage_engines_dialog"].connect(
"key-press-event",
lambda w, e: delete_event(w) if e.keyval == Gdk.KEY_Escape else None)
firstRun = False
widgets["manage_engines_dialog"].show()
def __init__ (self, widgets):
# Init open dialog
opendialog = gtk.FileChooserDialog (
_("Open Sound File"), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_ACCEPT))
for dir in self.SOUND_DIRS:
if os.path.isdir(dir):
opendialog.set_current_folder(dir)
break
soundfilter = gtk.FileFilter()
soundfilter.add_custom(soundfilter.get_needed(),
lambda data: data[3] and data[3].startswith("audio/"))
opendialog.add_filter(soundfilter)
opendialog.set_filter(soundfilter)
# Get combo icons
icons = ((_("No sound"), "audio-volume-muted", "audio-volume-muted"),
(_("Beep"), "stock_bell", "audio-x-generic"),
(_("Select sound file..."), "gtk-open", "document-open"))
items = []
for level, stock, altstock in icons:
image = load_icon(16, stock, altstock)
items += [(image, level)]
audioIco = load_icon(16, "audio-x-generic")
# Set-up combos
def callback (combobox, index):
if combobox.get_active() == SOUND_SELECT:
if opendialog.run() == gtk.RESPONSE_ACCEPT:
uri = opendialog.get_uri()
model = combobox.get_model()
conf.set("sounduri%d"%index, uri)
label = os.path.split(uri)[1]
if len(model) == 3:
model.append([audioIco, label])
else:
model.set(model.get_iter((3,)), 1, label)
combobox.set_active(3)
else:
combobox.set_active(conf.get("soundcombo%d"%index,SOUND_MUTE))
opendialog.hide()
for i in xrange(self.COUNT_OF_SOUNDS):
combo = widgets["soundcombo%d"%i]
uistuff.createCombo (combo, items)
combo.set_active(0)
combo.connect("changed", callback, i)
label = widgets["soundlabel%d"%i]
label.props.mnemonic_widget = combo
uri = conf.get("sounduri%d"%i,"")
if os.path.isfile(uri[7:]):
model = combo.get_model()
model.append([audioIco, os.path.split(uri)[1]])
combo.set_active(3)
for i in xrange(self.COUNT_OF_SOUNDS):
if conf.get("soundcombo%d"%i, SOUND_MUTE) == SOUND_URI and \
not os.path.isfile(conf.get("sounduri%d"%i,"")[7:]):
conf.set("soundcombo%d"%i, SOUND_MUTE)
uistuff.keep(widgets["soundcombo%d"%i], "soundcombo%d"%i)
#widgets["soundcombo%d"%i].set_active(conf.get("soundcombo%d"%i, SOUND_MUTE))
# Init play button
def playCallback (button, index):
SoundTab.playAction(index)
for i in range (self.COUNT_OF_SOUNDS):
button = widgets["soundbutton%d"%i]
button.connect("clicked", playCallback, i)
# Init 'use sound" checkbutton
def checkCallBack (*args):
checkbox = widgets["useSounds"]
widgets["frame23"].set_property("sensitive", checkbox.get_active())
conf.notify_add("useSounds", checkCallBack)
widgets["useSounds"].set_active(True)
uistuff.keep(widgets["useSounds"], "useSounds")
checkCallBack()
def soundError (player, gstmessage):
widgets["useSounds"].set_sensitive(False)
widgets["useSounds"].set_active(False)
self.getPlayer().connect("error", soundError)
def _init (cls):
cls.widgets = uistuff.GladeWidgets ("newInOut.glade")
uistuff.createCombo(cls.widgets["whitePlayerCombobox"],
(i[:2] for i in playerItems[0]))
uistuff.createCombo(cls.widgets["blackPlayerCombobox"],
(i[:2] for i in playerItems[0]))
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__)
uistuff.updateCombo(cls.widgets["blackPlayerCombobox"], playerItems[variant])
uistuff.updateCombo(cls.widgets["whitePlayerCombobox"], playerItems[variant])
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 __init__(self):
self.widgets = uistuff.GladeWidgets("analyze_game.glade")
self.widgets["analyze_game"].set_transient_for(mainwindow())
self.stop_event = asyncio.Event()
uistuff.keep(self.widgets["fromCurrent"], "fromCurrent")
uistuff.keep(self.widgets["shouldBlack"], "shouldBlack")
uistuff.keep(self.widgets["shouldWhite"], "shouldWhite")
uistuff.keep(self.widgets["threatPV"], "threatPV")
uistuff.keep(self.widgets["showEval"], "showEval")
uistuff.keep(self.widgets["showBlunder"], "showBlunder")
uistuff.keep(self.widgets["max_analysis_spin"], "max_analysis_spin")
uistuff.keep(self.widgets["variation_threshold_spin"],
"variation_threshold_spin")
# Analyzing engines
uistuff.createCombo(self.widgets["ana_combobox"], name="ana_combobox")
from pychess.widgets import newGameDialog
def update_analyzers_store(discoverer):
data = [(item[0], item[1]) for item in newGameDialog.analyzerItems]
uistuff.updateCombo(self.widgets["ana_combobox"], data)
discoverer.connect_after("all_engines_discovered",
update_analyzers_store)
update_analyzers_store(discoverer)
uistuff.keep(
self.widgets["ana_combobox"], "ana_combobox", anal_combo_get_value,
lambda combobox, value: anal_combo_set_value(
combobox, value, "hint_mode", HINT))
def hide_window(button, *args):
self.widgets["analyze_game"].destroy()
def abort():
self.analyzer.pause()
if self.threat_PV:
self.inv_analyzer.pause()
self.stop_event.set()
self.widgets["analyze_game"].destroy()
def run_analyze(button, *args):
@asyncio.coroutine
def coro():
persp = perspective_manager.get_perspective("games")
gmwidg = persp.cur_gmwidg()
gamemodel = gmwidg.gamemodel
old_check_value = conf.get("analyzer_check")
conf.set("analyzer_check", True)
if HINT not in gamemodel.spectators:
try:
yield from asyncio.wait_for(
gamemodel.start_analyzer(HINT), 5.0)
except asyncio.TimeoutError:
log.error(
"Got timeout error while starting hint analyzer")
return
except Exception:
log.error("Unknown error while starting hint analyzer")
return
self.analyzer = gamemodel.spectators[HINT]
gmwidg.menuitems["hint_mode"].active = True
self.threat_PV = conf.get("ThreatPV")
if self.threat_PV:
old_inv_check_value = conf.get("inv_analyzer_check")
conf.set("inv_analyzer_check", True)
if SPY not in gamemodel.spectators:
try:
yield from asyncio.wait_for(
gamemodel.start_analyzer(SPY), 5.0)
except asyncio.TimeoutError:
log.error(
"Got timeout error while starting spy analyzer"
)
return
except Exception:
log.error(
"Unknown error while starting spy analyzer")
return
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):
conf.set("analyzer_check", old_check_value)
if self.threat_PV:
conf.set("inv_analyzer_check", old_inv_check_value)
message.dismiss()
abort()
message = InfoBarMessage(Gtk.MessageType.QUESTION, content,
response_cb)
message.add_button(
InfoBarMessageButton(_("Abort"), Gtk.ResponseType.CANCEL))
gmwidg.replaceMessages(message)
@asyncio.coroutine
def analyse_moves():
should_black = conf.get("shouldBlack")
should_white = conf.get("shouldWhite")
from_current = conf.get("fromCurrent")
start_ply = gmwidg.board.view.shown if from_current else 0
move_time = int(conf.get("max_analysis_spin"))
threshold = int(conf.get("variation_threshold_spin"))
for board in gamemodel.boards[start_ply:]:
if self.stop_event.is_set():
break
gmwidg.board.view.setShownBoard(board)
self.analyzer.setBoard(board)
if self.threat_PV:
inv_analyzer.setBoard(board)
yield from asyncio.sleep(move_time + 0.1)
ply = board.ply - gamemodel.lowply
color = (ply - 1) % 2
if ply - 1 in gamemodel.scores and ply in gamemodel.scores and (
(color == BLACK and should_black) or
(color == WHITE and should_white)):
oldmoves, oldscore, olddepth = gamemodel.scores[ply
-
1]
oldscore = oldscore * -1 if color == BLACK else oldscore
score_str = prettyPrintScore(oldscore, olddepth)
moves, score, depth = gamemodel.scores[ply]
score = score * -1 if color == WHITE else score
diff = score - oldscore
if ((diff > threshold and color == BLACK) or
(diff < -1 * threshold and color == WHITE)
) and (gamemodel.moves[ply - 1] != parseAny(
gamemodel.boards[ply - 1], oldmoves[0])):
if self.threat_PV:
try:
if ply - 1 in gamemodel.spy_scores:
oldmoves0, oldscore0, olddepth0 = gamemodel.spy_scores[
ply - 1]
score_str0 = prettyPrintScore(
oldscore0, olddepth0)
pv0 = listToMoves(
gamemodel.boards[ply - 1],
["--"] + oldmoves0,
validate=True)
if len(pv0) > 2:
gamemodel.add_variation(
gamemodel.boards[ply - 1],
pv0,
comment="Threatening",
score=score_str0,
emit=False)
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,
emit=False)
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))
self.widgets["analyze_game"].hide()
self.widgets["analyze_ok_button"].set_sensitive(True)
conf.set("analyzer_check", old_check_value)
if self.threat_PV:
conf.set("inv_analyzer_check", old_inv_check_value)
message.dismiss()
gamemodel.emit("analysis_finished")
create_task(analyse_moves())
hide_window(None)
return True
create_task(coro())
self.widgets["analyze_game"].connect("delete-event", hide_window)
self.widgets["analyze_cancel_button"].connect("clicked", hide_window)
self.widgets["analyze_ok_button"].connect("clicked", run_analyze)
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
@idle_add
def update_analyzers_store(discoverer):
data = [(item[0], item[1]) for item in newGameDialog.analyzerItems]
uistuff.updateCombo(widgets["ana_combobox"], data)
discoverer.connect_after("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.replaceMessages(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
@idle_add
def do():
gmwidg.board.view.setShownBoard(board)
do()
analyzer.setBoard(board)
if threat_PV:
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:
if ply - 1 in gamemodel.spy_scores:
oldmoves0, oldscore0, olddepth0 = gamemodel.spy_scores[
ply - 1]
score_str0 = prettyPrintScore(
oldscore0, olddepth0)
pv0 = listToMoves(gamemodel.boards[ply -
1],
["--"] + oldmoves0,
validate=True)
if len(pv0) > 2:
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 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
@idle_add
def update_analyzers_store(discoverer):
data = [(item[0], item[1]) for item in newGameDialog.analyzerItems]
uistuff.updateCombo(widgets["ana_combobox"], data)
discoverer.connect_after("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
@idle_add
def do():
gmwidg.board.view.setShownBoard(board)
do()
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:
if ply-1 in gamemodel.spy_scores:
oldmoves0, oldscore0, olddepth0 = gamemodel.spy_scores[ply-1]
score_str0 = prettyPrintScore(oldscore0, olddepth0)
pv0 = listToMoves(gamemodel.boards[ply-1], ["--"] + oldmoves0, validate=True)
if len(pv0) > 2:
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, 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"), mainwindow(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
book_chooser_button = Gtk.FileChooserButton.new_with_dialog(
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):
self.widgets["opening_hbox"].set_sensitive(check.get_active())
self.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"), mainwindow(),
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):
self.widgets["endgame_hbox"].set_sensitive(check.get_active())
self.widgets["endgame_check"].connect_after("toggled",
on_endgame_check_toggled)
# Analyzing engines
from pychess.widgets import newGameDialog
data = [(item[0], item[1]) for item in newGameDialog.analyzerItems]
uistuff.createCombo(widgets["ana_combobox"], data, name="ana_combobox")
uistuff.createCombo(widgets["inv_ana_combobox"],
data,
name="inv_ana_combobox")
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)
discoverer.connect_after("all_engines_discovered",
update_analyzers_store)
update_analyzers_store(discoverer)
# Save, load and make analyze combos active
# Let Stockfish to be default analyzer in Windows installer
default = discoverer.getEngineN(-1).get("md5")
conf.set("ana_combobox", conf.get("ana_combobox", default))
conf.set("inv_ana_combobox", conf.get("inv_ana_combobox", default))
def on_analyzer_check_toggled(check):
self.widgets["analyzers_vbox"].set_sensitive(check.get_active())
from pychess.widgets.gamewidget import widgets
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
asyncio. async (
gmwidg.gamemodel.restart_analyzer(HINT))
if not widgets["hint_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(HINT)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(HINT)
self.widgets["analyzers_vbox"].set_sensitive(
widgets["analyzer_check"].get_active())
self.widgets["analyzer_check"].connect_after(
"toggled", on_analyzer_check_toggled)
def on_invanalyzer_check_toggled(check):
self.widgets["inv_analyzers_vbox"].set_sensitive(
check.get_active())
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
asyncio. async (gmwidg.gamemodel.restart_analyzer(SPY))
if not widgets["spy_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(SPY)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(SPY)
self.widgets["inv_analyzers_vbox"].set_sensitive(
widgets["inv_analyzer_check"].get_active())
self.widgets["inv_analyzer_check"].connect_after(
"toggled", on_invanalyzer_check_toggled)
# Give widgets to keeper
uistuff.keep(
self.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(
self.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(self.widgets["max_analysis_spin"],
"max_analysis_spin",
first_value=3)
def __init__(self, widgets):
# Init open dialog
opendialog = Gtk.FileChooserDialog(
_("Open Sound File"), None, Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.ACCEPT))
for dir in self.SOUND_DIRS:
if os.path.isdir(dir):
opendialog.set_current_folder(dir)
break
soundfilter = Gtk.FileFilter()
soundfilter.set_name(_("Sound files"))
soundfilter.add_mime_type("audio/%s" % EXT)
soundfilter.add_pattern("*.%s" % EXT)
opendialog.add_filter(soundfilter)
# Get combo icons
icons = ((_("No sound"), "audio-volume-muted", "audio-volume-muted"),
(_("Beep"), "stock_bell", "audio-x-generic"),
(_("Select sound file..."), "gtk-open", "document-open"))
items = []
for level, stock, altstock in icons:
image = load_icon(16, stock, altstock)
items += [(image, level)]
audioIco = load_icon(16, "audio-x-generic")
# Set-up combos
def callback(combobox, index):
if combobox.get_active() == SOUND_SELECT:
if opendialog.run() == Gtk.ResponseType.ACCEPT:
uri = opendialog.get_uri()
model = combobox.get_model()
conf.set("sounduri%d" % index, uri)
label = unquote(os.path.split(uri)[1])
if len(model) == 3:
model.append([audioIco, label])
else:
model.set(model.get_iter((3, )), 1, label)
combobox.set_active(3)
else:
combobox.set_active(conf.get("soundcombo%d" % index,
SOUND_MUTE))
opendialog.hide()
for i in range(self.COUNT_OF_SOUNDS):
combo = widgets["sound%dcombo" % i]
uistuff.createCombo(combo, items, name="soundcombo%d" % i)
# combo.set_active(0)
combo.connect("changed", callback, i)
label = widgets["soundlabel%d" % i]
label.props.mnemonic_widget = combo
uri = conf.get("sounduri%d" % i, "")
if os.path.isfile(url2pathname(uri[5:])):
model = combo.get_model()
model.append([audioIco, unquote(os.path.split(uri)[1])])
# combo.set_active(3)
for i in range(self.COUNT_OF_SOUNDS):
if conf.get("soundcombo%d" % i, SOUND_MUTE) == SOUND_URI and \
not os.path.isfile(url2pathname(conf.get("sounduri%d" % i, "")[5:])):
conf.set("soundcombo%d" % i, SOUND_MUTE)
uistuff.keep(widgets["sound%dcombo" % i], "soundcombo%d" % i)
# Init play button
def playCallback(button, index):
SoundTab.playAction(index)
for i in range(self.COUNT_OF_SOUNDS):
button = widgets["sound%dbutton" % i]
button.connect("clicked", playCallback, i)
# Init 'use sound" checkbutton
def checkCallBack(*args):
checkbox = widgets["useSounds"]
widgets["sounds_frame"].set_property("sensitive", checkbox.get_active())
conf.notify_add("useSounds", checkCallBack)
widgets["useSounds"].set_active(True)
uistuff.keep(widgets["useSounds"], "useSounds")
checkCallBack()
if not self.getPlayer().ready:
widgets["useSounds"].set_sensitive(False)
widgets["useSounds"].set_active(False)
uistuff.keep(widgets["alarm_spin"], "alarm_spin", first_value=15)
def __init__(self, widgets):
self.widgets = widgets
# Font chooser
font = conf.get("movetextFont", "FreeSerif Regular 12")
font_button = Gtk.FontButton.new_with_font(font)
demo_text = "♔a1 ♕f8 ♖h8 ♗g7 ♘g2 Ka1 Qf8 Rh8 Bg7 Ng2"
font_button.set_preview_text(demo_text)
self.widgets["fontChooserDock"].add(font_button)
font_button.show()
def select_font(button):
conf.set("movetextFont", button.get_font_name())
font_button.connect("font-set", select_font)
# Background image
path = conf.get("welcome_image", addDataPrefix("glade/clear.png"))
conf.set("welcome_image", path)
image_chooser_dialog = Gtk.FileChooserDialog(
_("Select background image file"), mainwindow(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
image_chooser_button = Gtk.FileChooserButton.new_with_dialog(
image_chooser_dialog)
filter = Gtk.FileFilter()
filter.set_name(_("Images"))
filter.add_pattern("*.bmp")
filter.add_pattern("*.jpg")
filter.add_pattern("*.png")
filter.add_pattern("*.svg")
image_chooser_dialog.add_filter(filter)
image_chooser_button.set_filename(path)
self.widgets["imageChooserDock"].add(image_chooser_button)
image_chooser_button.show()
def select_new_image(button):
new_image = image_chooser_dialog.get_filename()
if new_image:
conf.set("welcome_image", new_image)
from pychess.widgets.TaskerManager import tasker
newTheme(tasker, background=new_image)
tasker.queue_draw()
else:
# restore the original
image_chooser_dialog.set_filename(path)
image_chooser_button.connect("file-set", select_new_image)
# Board style
uistuff.createCombo(widgets["board_style"], name="board_style")
data = [(item[0], item[1]) for item in board_items]
uistuff.createCombo(widgets["board_style"], data)
uistuff.keep(widgets["board_style"], "board_style", first_value=1)
# conf.set("board_style", conf.get("board_style", 1))
# Board frame
uistuff.createCombo(widgets["board_frame"], name="board_frame")
data = [(item[0], item[1]) for item in [(None, "no frame")] + board_items[1:]]
uistuff.createCombo(widgets["board_frame"], data)
uistuff.keep(widgets["board_frame"], "board_frame", first_value=1)
# conf.set("board_frame", conf.get("board_frame", 1))
# Board Colours
style_ctxt = widgets["main_window"].get_style_context()
LIGHT = hexcol(style_ctxt.lookup_color("p_light_color")[1])
DARK = hexcol(style_ctxt.lookup_color("p_dark_color")[1])
def onColourSetLight(_):
""" :Description: Sets the light squares of the chess board
to the value selected in the colour picker
"""
conf.set('lightcolour',
widgets['light_cbtn'].get_color().to_string())
widgets["light_cbtn"].connect_after("color-set", onColourSetLight)
def onColourSetDark(_):
""" :Description: Sets the dark squares of the chess board
to the value selected in the colour picker
"""
conf.set('darkcolour',
widgets['dark_cbtn'].get_color().to_string())
widgets["dark_cbtn"].connect_after("color-set", onColourSetDark)
def onResetColourClicked(_):
""" :Description: Resets the chess board squares to factory default
"""
conf.set("lightcolour", LIGHT)
conf.set("darkcolour", DARK)
widgets["reset_btn"].connect("clicked", onResetColourClicked)
# Get the current board colours if set, if not set, set them to default
conf.set("lightcolour", conf.get("lightcolour", LIGHT))
conf.set("darkcolour", conf.get("darkcolour", DARK))
# Next 2 lines take a #hex str converts them to a color then to a RGBA representation
self.lightcolour = Gdk.RGBA()
self.lightcolour.parse(conf.get("lightcolour", LIGHT))
self.darkcolour = Gdk.RGBA()
self.darkcolour.parse(conf.get("darkcolour", DARK))
# Set the color swatches in preference to stored values
widgets['light_cbtn'].set_rgba(self.lightcolour)
widgets['dark_cbtn'].set_rgba(self.darkcolour)
# Chess Sets
self.themes = self.discoverThemes()
store = Gtk.ListStore(GdkPixbuf.Pixbuf, str)
for theme in self.themes:
pngfile = "%s/%s.png" % (addDataPrefix("pieces"), theme)
if isfile(pngfile):
pixbuf = get_pixbuf(pngfile)
store.append((pixbuf, theme))
else:
print(
"WARNING: No piece theme preview icons found. Please run \
create_theme_preview.sh !")
break
self.icon_view = widgets["pieceTheme"]
self.icon_view.set_model(store)
self.icon_view.set_pixbuf_column(0)
self.icon_view.set_text_column(1)
def keepSize(crt, _):
""" :Description: Hack to fix spacing problem in iconview
http://stackoverflow.com/questions/14090094/what-causes-the-different-\
display-behaviour-for-a-gtkiconview-between-different
"""
crt.handler_block(crt_notify)
crt.set_property('width', 40)
crt.handler_unblock(crt_notify)
crt = self.icon_view.get_cells()[0]
crt_notify = crt.connect('notify', keepSize)
def _getActive(iconview):
model = iconview.get_model()
selected = iconview.get_selected_items()
if len(selected) == 0:
return conf.get("pieceTheme", "Chessicons")
indices = selected[0].get_indices()
if indices:
idx = indices[0]
theme = model[idx][1]
Pieces.set_piece_theme(theme)
return theme
def _setActive(iconview, value):
try:
index = self.themes.index(value)
except ValueError:
index = 0
iconview.select_path(Gtk.TreePath(index, ))
uistuff.keep(widgets["pieceTheme"], "pieceTheme", _getActive, _setActive, "Chessicons")
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):
# Put engines in trees and combos
engines = discoverer.getEngines()
allstore = gtk.ListStore(gtk.gdk.Pixbuf, str)
for engine in engines.values():
c = discoverer.getCountry(engine)
if c:
flag = addDataPrefix("flags/%s.png" % c)
if not c or not os.path.isfile(flag):
flag = addDataPrefix("flags/unknown.png")
flag_icon = gtk.gdk.pixbuf_new_from_file(flag)
allstore.append((flag_icon, discoverer.getName(engine)))
tv = widgets["engines_treeview"]
tv.set_model(allstore)
tv.append_column(gtk.TreeViewColumn(
_("Flag"), gtk.CellRendererPixbuf(), pixbuf=0))
tv.append_column(gtk.TreeViewColumn(
_("Name"), gtk.CellRendererText(), text=1))
analyzers = list(discoverer.getAnalyzers())
ana_data = []
invana_data = []
for engine in analyzers:
name = discoverer.getName(engine)
c = discoverer.getCountry(engine)
if c:
flag = addDataPrefix("flags/%s.png" % c)
if not c or not os.path.isfile(flag):
flag = addDataPrefix("flags/unknown.png")
flag_icon = gtk.gdk.pixbuf_new_from_file(flag)
ana_data.append((flag_icon, name))
invana_data.append((flag_icon, name))
uistuff.createCombo(widgets["ana_combobox"], ana_data)
uistuff.createCombo(widgets["inv_ana_combobox"], invana_data)
# 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())
widgets["hint_mode"].set_active(check.get_active())
from pychess.Main import gameDic
if gameDic:
widgets["hint_mode"].set_sensitive(check.get_active())
widgets["analyzer_check"].connect("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())
widgets["spy_mode"].set_active(check.get_active())
from pychess.Main import gameDic
if gameDic:
widgets["spy_mode"].set_sensitive(check.get_active())
widgets["inv_analyzer_check"].connect("toggled", on_invanalyzer_check_toggled)
uistuff.keep(widgets["inv_analyzer_check"], "inv_analyzer_check")
# Put options in trees in add/edit dialog
#=======================================================================
# tv = widgets["optionview"]
# tv.append_column(gtk.TreeViewColumn(
# "Option", gtk.CellRendererText(), text=0))
# tv.append_column(gtk.TreeViewColumn(
# "Value", gtk.CellRendererText(), text=1))
#
# def edit (button):
#
# iter = widgets["engines_treeview"].get_selection().get_selected()[1]
# if iter: row = allstore.get_path(iter)[0]
# else: return
#
# engine = discoverer.getEngineN(row)
# optionstags = engine.getElementsByTagName("options")
# if not optionstags:
# widgets["engine_options_expander"].hide()
# else:
# widgets["engine_options_expander"].show()
# widgets["engine_options_expander"].set_expanded(False)
#
# optionsstore = gtk.ListStore(str, str)
# tv = widgets["optionview"]
# tv.set_model(optionsstore)
#
# for option in optionstags[0].childNodes:
# if option.nodeType != option.ELEMENT_NODE: continue
# optionsstore.append( [option.getAttribute("name"),
# option.getAttribute("default")] )
#
# widgets["engine_path_chooser"].set_title(_("Locate Engine"))
# widgets["engine_path_chooser"].set_uri("file:///usr/bin/gnuchess")
#
# dialog = widgets["addconfig_engine"]
# answer = dialog.run()
# dialog.hide()
# widgets["edit_engine_button"].connect("clicked", edit)
#=======================================================================
#widgets["remove_engine_button"].connect("clicked", remove)
#widgets["add_engine_button"].connect("clicked", add)
# Give widgets to kepper
for combo in ("ana_combobox", "inv_ana_combobox"):
def get_value (combobox):
engine = list(discoverer.getAnalyzers())[combobox.get_active()]
if engine.find('md5') != None:
return engine.find('md5').text.strip()
def set_value (combobox, value):
engine = discoverer.getEngineByMd5(value)
if not engine:
combobox.set_active(0)
else:
try:
index = list(discoverer.getAnalyzers()).index(engine)
except ValueError:
index = 0
combobox.set_active(index)
uistuff.keep (widgets[combo], combo, get_value, set_value)
# Init info box
uistuff.makeYellow(widgets["analyzer_pref_infobox"])
widgets["analyzer_pref_infobox"].hide()
def updatePrefInfobox (widget, *args):
widgets["analyzer_pref_infobox"].show()
widgets["ana_combobox"].connect("changed", updatePrefInfobox)
widgets["analyzer_check"].connect("toggled", updatePrefInfobox)
widgets["inv_ana_combobox"].connect("changed", updatePrefInfobox)
widgets["inv_analyzer_check"].connect("toggled", updatePrefInfobox)
widgets["preferences"].connect("hide", lambda *a: widgets["analyzer_pref_infobox"].hide())
def _init (cls):
cls.widgets = uistuff.GladeWidgets ("newInOut.glade")
uistuff.createCombo(cls.widgets["whitePlayerCombobox"], name="whitePlayerCombobox")
uistuff.createCombo(cls.widgets["blackPlayerCombobox"], name="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)
#@idle_add
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)
discoverer.connect_after("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 __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.new_with_dialog(
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):
self.widgets["opening_hbox"].set_sensitive(check.get_active())
self.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):
self.widgets["endgame_hbox"].set_sensitive(check.get_active())
self.widgets["endgame_check"].connect_after("toggled",
on_endgame_check_toggled)
# Analyzing engines
from pychess.widgets import newGameDialog
data = [(item[0], item[1]) for item in newGameDialog.analyzerItems]
uistuff.createCombo(widgets["ana_combobox"], data, name="ana_combobox")
uistuff.createCombo(widgets["inv_ana_combobox"], data, name="inv_ana_combobox")
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)
discoverer.connect_after("all_engines_discovered",
update_analyzers_store)
update_analyzers_store(discoverer)
# Save, load and make analyze combos active
# Let Stockfish to be default analyzer in Windows installer
default = discoverer.getEngineN(-1).get("md5")
conf.set("ana_combobox", conf.get("ana_combobox", default))
conf.set("inv_ana_combobox", conf.get("inv_ana_combobox", default))
def on_analyzer_check_toggled(check):
self.widgets["analyzers_vbox"].set_sensitive(check.get_active())
from pychess.widgets.gamewidget import widgets
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
asyncio.async(gmwidg.gamemodel.restart_analyzer(HINT))
if not widgets["hint_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(HINT)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(HINT)
self.widgets["analyzers_vbox"].set_sensitive(widgets[
"analyzer_check"].get_active())
self.widgets["analyzer_check"].connect_after("toggled",
on_analyzer_check_toggled)
def on_invanalyzer_check_toggled(check):
self.widgets["inv_analyzers_vbox"].set_sensitive(check.get_active())
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
asyncio.async(gmwidg.gamemodel.restart_analyzer(SPY))
if not widgets["spy_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(SPY)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(SPY)
self.widgets["inv_analyzers_vbox"].set_sensitive(widgets[
"inv_analyzer_check"].get_active())
self.widgets["inv_analyzer_check"].connect_after(
"toggled", on_invanalyzer_check_toggled)
# Give widgets to keeper
uistuff.keep(
self.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(
self.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(self.widgets["max_analysis_spin"], "max_analysis_spin", first_value=3)
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__(self, widgets):
self.widgets = widgets
# Background image
path = conf.get("welcome_image", addDataPrefix("glade/clear.png"))
conf.set("welcome_image", path)
image_chooser_dialog = Gtk.FileChooserDialog(
_("Select background image file"), mainwindow(),
Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
image_chooser_button = Gtk.FileChooserButton.new_with_dialog(
image_chooser_dialog)
filter = Gtk.FileFilter()
filter.set_name(_("Images"))
filter.add_pattern("*.bmp")
filter.add_pattern("*.jpg")
filter.add_pattern("*.png")
filter.add_pattern("*.svg")
image_chooser_dialog.add_filter(filter)
image_chooser_button.set_filename(path)
self.widgets["imageChooserDock"].add(image_chooser_button)
image_chooser_button.show()
def select_new_image(button):
new_image = image_chooser_dialog.get_filename()
if new_image:
conf.set("welcome_image", new_image)
from pychess.widgets.TaskerManager import tasker
newTheme(tasker, background=new_image)
tasker.queue_draw()
else:
# restore the original
image_chooser_dialog.set_filename(path)
image_chooser_button.connect("file-set", select_new_image)
# Board style
uistuff.createCombo(widgets["board_style"], name="board_style")
data = [(item[0], item[1]) for item in board_items]
uistuff.createCombo(widgets["board_style"], data)
uistuff.keep(widgets["board_style"], "board_style", first_value=1)
# conf.set("board_style", conf.get("board_style", 1))
# Board frame
uistuff.createCombo(widgets["board_frame"], name="board_frame")
data = [(item[0], item[1])
for item in [(None, "no frame")] + board_items[1:]]
uistuff.createCombo(widgets["board_frame"], data)
uistuff.keep(widgets["board_frame"], "board_frame", first_value=1)
# conf.set("board_frame", conf.get("board_frame", 1))
# Board Colours
style_ctxt = widgets["main_window"].get_style_context()
LIGHT = hexcol(style_ctxt.lookup_color("p_light_color")[1])
DARK = hexcol(style_ctxt.lookup_color("p_dark_color")[1])
def onColourSetLight(_):
""" :Description: Sets the light squares of the chess board
to the value selected in the colour picker
"""
conf.set('lightcolour',
widgets['light_cbtn'].get_color().to_string())
widgets["light_cbtn"].connect_after("color-set", onColourSetLight)
def onColourSetDark(_):
""" :Description: Sets the dark squares of the chess board
to the value selected in the colour picker
"""
conf.set('darkcolour',
widgets['dark_cbtn'].get_color().to_string())
widgets["dark_cbtn"].connect_after("color-set", onColourSetDark)
def onResetColourClicked(_):
""" :Description: Resets the chess board squares to factory default
"""
conf.set("lightcolour", LIGHT)
conf.set("darkcolour", DARK)
widgets["reset_btn"].connect("clicked", onResetColourClicked)
# Get the current board colours if set, if not set, set them to default
conf.set("lightcolour", conf.get("lightcolour", LIGHT))
conf.set("darkcolour", conf.get("darkcolour", DARK))
# Next 2 lines take a #hex str converts them to a color then to a RGBA representation
self.lightcolour = Gdk.RGBA()
self.lightcolour.parse(conf.get("lightcolour", LIGHT))
self.darkcolour = Gdk.RGBA()
self.darkcolour.parse(conf.get("darkcolour", DARK))
# Set the color swatches in preference to stored values
widgets['light_cbtn'].set_rgba(self.lightcolour)
widgets['dark_cbtn'].set_rgba(self.darkcolour)
# Chess Sets
self.themes = self.discoverThemes()
store = Gtk.ListStore(GdkPixbuf.Pixbuf, str)
for theme in self.themes:
pngfile = "%s/%s.png" % (addDataPrefix("pieces"), theme)
if isfile(pngfile):
pixbuf = get_pixbuf(pngfile)
store.append((pixbuf, theme))
else:
print(
"WARNING: No piece theme preview icons found. Please run \
create_theme_preview.sh !")
break
self.icon_view = widgets["pieceTheme"]
self.icon_view.set_model(store)
self.icon_view.set_pixbuf_column(0)
self.icon_view.set_text_column(1)
def keepSize(crt, _):
""" :Description: Hack to fix spacing problem in iconview
http://stackoverflow.com/questions/14090094/what-causes-the-different-\
display-behaviour-for-a-gtkiconview-between-different
"""
crt.handler_block(crt_notify)
crt.set_property('width', 40)
crt.handler_unblock(crt_notify)
crt = self.icon_view.get_cells()[0]
crt_notify = crt.connect('notify', keepSize)
def _getActive(iconview):
model = iconview.get_model()
selected = iconview.get_selected_items()
if len(selected) == 0:
return conf.get("pieceTheme", "Chessicons")
indices = selected[0].get_indices()
if indices:
idx = indices[0]
theme = model[idx][1]
Pieces.set_piece_theme(theme)
return theme
def _setActive(iconview, value):
try:
index = self.themes.index(value)
except ValueError:
index = 0
iconview.select_path(Gtk.TreePath(index, ))
uistuff.keep(widgets["pieceTheme"], "pieceTheme", _getActive,
_setActive, "Chessicons")
def __init__(self):
self.widgets = uistuff.GladeWidgets("analyze_game.glade")
self.widgets["analyze_game"].set_transient_for(mainwindow())
self.stop_event = asyncio.Event()
uistuff.keep(self.widgets["fromCurrent"], "fromCurrent")
uistuff.keep(self.widgets["shouldBlack"], "shouldBlack")
uistuff.keep(self.widgets["shouldWhite"], "shouldWhite")
uistuff.keep(self.widgets["threatPV"], "threatPV")
uistuff.keep(self.widgets["showEval"], "showEval")
uistuff.keep(self.widgets["showBlunder"], "showBlunder")
uistuff.keep(self.widgets["max_analysis_spin"], "max_analysis_spin")
uistuff.keep(self.widgets["variation_threshold_spin"], "variation_threshold_spin")
# Analyzing engines
uistuff.createCombo(self.widgets["ana_combobox"], name="ana_combobox")
from pychess.widgets import newGameDialog
def update_analyzers_store(discoverer):
data = [(item[0], item[1]) for item in newGameDialog.analyzerItems]
uistuff.updateCombo(self.widgets["ana_combobox"], data)
discoverer.connect_after("all_engines_discovered", update_analyzers_store)
update_analyzers_store(discoverer)
uistuff.keep(self.widgets["ana_combobox"], "ana_combobox", anal_combo_get_value,
lambda combobox, value: anal_combo_set_value(combobox, value, "hint_mode", HINT))
def hide_window(button, *args):
self.widgets["analyze_game"].destroy()
def abort():
self.stop_event.set()
self.widgets["analyze_game"].destroy()
def run_analyze(button, *args):
@asyncio.coroutine
def coro():
persp = perspective_manager.get_perspective("games")
gmwidg = persp.cur_gmwidg()
gamemodel = gmwidg.gamemodel
old_check_value = conf.get("analyzer_check")
conf.set("analyzer_check", True)
if HINT not in gamemodel.spectators:
try:
yield from asyncio.wait_for(gamemodel.start_analyzer(HINT), 5.0)
except asyncio.TimeoutError:
log.error("Got timeout error while starting hint analyzer")
return
except Exception:
log.error("Unknown error while starting hint analyzer")
return
analyzer = gamemodel.spectators[HINT]
gmwidg.menuitems["hint_mode"].active = True
threat_PV = conf.get("ThreatPV")
if threat_PV:
old_inv_check_value = conf.get("inv_analyzer_check")
conf.set("inv_analyzer_check", True)
if SPY not in gamemodel.spectators:
try:
yield from asyncio.wait_for(gamemodel.start_analyzer(SPY), 5.0)
except asyncio.TimeoutError:
log.error("Got timeout error while starting spy analyzer")
return
except Exception:
log.error("Unknown error while starting spy analyzer")
return
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):
conf.set("analyzer_check", old_check_value)
if threat_PV:
conf.set("inv_analyzer_check", old_inv_check_value)
message.dismiss()
abort()
message = InfoBarMessage(Gtk.MessageType.QUESTION, content, response_cb)
message.add_button(InfoBarMessageButton(_("Abort"), Gtk.ResponseType.CANCEL))
gmwidg.replaceMessages(message)
@asyncio.coroutine
def analyse_moves():
should_black = conf.get("shouldBlack")
should_white = conf.get("shouldWhite")
from_current = conf.get("fromCurrent")
start_ply = gmwidg.board.view.shown if from_current else 0
move_time = int(conf.get("max_analysis_spin"))
threshold = int(conf.get("variation_threshold_spin"))
for board in gamemodel.boards[start_ply:]:
if self.stop_event.is_set():
break
gmwidg.board.view.setShownBoard(board)
analyzer.setBoard(board)
if threat_PV:
inv_analyzer.setBoard(board)
yield from asyncio.sleep(move_time + 0.1)
ply = board.ply - gamemodel.lowply
color = (ply - 1) % 2
if ply - 1 in gamemodel.scores and ply in gamemodel.scores and (
(color == BLACK and should_black) or (color == WHITE and should_white)):
oldmoves, oldscore, olddepth = gamemodel.scores[ply - 1]
oldscore = oldscore * -1 if color == BLACK else oldscore
score_str = prettyPrintScore(oldscore, olddepth)
moves, score, depth = gamemodel.scores[ply]
score = score * -1 if color == WHITE else score
diff = score - oldscore
if ((diff > threshold and color == BLACK) or (diff < -1 * threshold and color == WHITE)) and (
gamemodel.moves[ply - 1] != parseAny(gamemodel.boards[ply - 1], oldmoves[0])):
if threat_PV:
try:
if ply - 1 in gamemodel.spy_scores:
oldmoves0, oldscore0, olddepth0 = gamemodel.spy_scores[ply - 1]
score_str0 = prettyPrintScore(oldscore0, olddepth0)
pv0 = listToMoves(gamemodel.boards[ply - 1], ["--"] + oldmoves0, validate=True)
if len(pv0) > 2:
gamemodel.add_variation(gamemodel.boards[ply - 1], pv0,
comment="Threatening", score=score_str0, emit=False)
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, emit=False)
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))
self.widgets["analyze_game"].hide()
self.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()
gamemodel.emit("analysis_finished")
create_task(analyse_moves())
hide_window(None)
return True
create_task(coro())
self.widgets["analyze_game"].connect("delete-event", hide_window)
self.widgets["analyze_cancel_button"].connect("clicked", hide_window)
self.widgets["analyze_ok_button"].connect("clicked", run_analyze)
def __init__(self, widgets):
# Init open dialog
opendialog = Gtk.FileChooserDialog(
_("Open Sound File"), mainwindow(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.ACCEPT))
for dir in self.SOUND_DIRS:
if os.path.isdir(dir):
opendialog.set_current_folder(dir)
break
soundfilter = Gtk.FileFilter()
soundfilter.set_name(_("Sound files"))
soundfilter.add_mime_type("audio/%s" % EXT)
soundfilter.add_pattern("*.%s" % EXT)
opendialog.add_filter(soundfilter)
# Get combo icons
icons = ((_("No sound"), "audio-volume-muted", "audio-volume-muted"),
(_("Beep"), "stock_bell", "audio-x-generic"),
(_("Select sound file..."), "gtk-open", "document-open"))
items = []
for level, stock, altstock in icons:
image = load_icon(16, stock, altstock)
items += [(image, level)]
audioIco = load_icon(16, "audio-x-generic")
# Set-up combos
def callback(combobox, index):
if combobox.get_active() == SOUND_SELECT:
if opendialog.run() == Gtk.ResponseType.ACCEPT:
uri = opendialog.get_uri()
model = combobox.get_model()
conf.set("sounduri%d" % index, uri)
label = unquote(os.path.split(uri)[1])
if len(model) == 3:
model.append([audioIco, label])
else:
model.set(model.get_iter((3, )), 1, label)
combobox.set_active(3)
else:
combobox.set_active(
conf.get("soundcombo%d" % index, SOUND_MUTE))
opendialog.hide()
for i in range(self.COUNT_OF_SOUNDS):
combo = widgets["sound%dcombo" % i]
uistuff.createCombo(combo, items, name="soundcombo%d" % i)
# combo.set_active(0)
combo.connect("changed", callback, i)
label = widgets["soundlabel%d" % i]
label.props.mnemonic_widget = combo
uri = conf.get("sounduri%d" % i, "")
if os.path.isfile(url2pathname(uri[5:])):
model = combo.get_model()
model.append([audioIco, unquote(os.path.split(uri)[1])])
# combo.set_active(3)
for i in range(self.COUNT_OF_SOUNDS):
if conf.get("soundcombo%d" % i, SOUND_MUTE) == SOUND_URI and \
not os.path.isfile(url2pathname(conf.get("sounduri%d" % i, "")[5:])):
conf.set("soundcombo%d" % i, SOUND_MUTE)
uistuff.keep(widgets["sound%dcombo" % i], "soundcombo%d" % i)
# Init play button
def playCallback(button, index):
SoundTab.playAction(index)
for i in range(self.COUNT_OF_SOUNDS):
button = widgets["sound%dbutton" % i]
button.connect("clicked", playCallback, i)
# Init 'use sound" checkbutton
def checkCallBack(*args):
checkbox = widgets["useSounds"]
widgets["sounds_frame"].set_property("sensitive",
checkbox.get_active())
conf.notify_add("useSounds", checkCallBack)
widgets["useSounds"].set_active(True)
uistuff.keep(widgets["useSounds"], "useSounds")
checkCallBack()
if not self.getPlayer().ready:
widgets["useSounds"].set_sensitive(False)
widgets["useSounds"].set_active(False)
uistuff.keep(widgets["alarm_spin"], "alarm_spin", first_value=15)
def __init__(self, widgets):
# Init open dialog
opendialog = gtk.FileChooserDialog(
_("Open Sound File"), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_ACCEPT))
for dir in self.SOUND_DIRS:
if os.path.isdir(dir):
opendialog.set_current_folder(dir)
break
soundfilter = gtk.FileFilter()
soundfilter.add_custom(
soundfilter.get_needed(),
lambda data: data[3] and data[3].startswith("audio/"))
opendialog.add_filter(soundfilter)
opendialog.set_filter(soundfilter)
# Get combo icons
icons = ((_("No sound"), "audio-volume-muted", "audio-volume-muted"),
(_("Beep"), "stock_bell", "audio-x-generic"),
(_("Select sound file..."), "gtk-open", "document-open"))
items = []
for level, stock, altstock in icons:
image = load_icon(16, stock, altstock)
items += [(image, level)]
audioIco = load_icon(16, "audio-x-generic")
# Set-up combos
def callback(combobox, index):
if combobox.get_active() == SOUND_SELECT:
if opendialog.run() == gtk.RESPONSE_ACCEPT:
uri = opendialog.get_uri()
model = combobox.get_model()
conf.set("sounduri%d" % index, uri)
label = os.path.split(uri)[1]
if len(model) == 3:
model.append([audioIco, label])
else:
model.set(model.get_iter((3, )), 1, label)
combobox.set_active(3)
else:
combobox.set_active(
conf.get("soundcombo%d" % index, SOUND_MUTE))
opendialog.hide()
for i in xrange(self.COUNT_OF_SOUNDS):
combo = widgets["soundcombo%d" % i]
uistuff.createCombo(combo, items)
combo.set_active(0)
combo.connect("changed", callback, i)
label = widgets["soundlabel%d" % i]
label.props.mnemonic_widget = combo
uri = conf.get("sounduri%d" % i, "")
if os.path.isfile(uri[7:]):
model = combo.get_model()
model.append([audioIco, os.path.split(uri)[1]])
combo.set_active(3)
for i in xrange(self.COUNT_OF_SOUNDS):
if conf.get("soundcombo%d"%i, SOUND_MUTE) == SOUND_URI and \
not os.path.isfile(conf.get("sounduri%d"%i,"")[7:]):
conf.set("soundcombo%d" % i, SOUND_MUTE)
uistuff.keep(widgets["soundcombo%d" % i], "soundcombo%d" % i)
#widgets["soundcombo%d"%i].set_active(conf.get("soundcombo%d"%i, SOUND_MUTE))
# Init play button
def playCallback(button, index):
SoundTab.playAction(index)
for i in range(self.COUNT_OF_SOUNDS):
button = widgets["soundbutton%d" % i]
button.connect("clicked", playCallback, i)
# Init 'use sound" checkbutton
def checkCallBack(*args):
checkbox = widgets["useSounds"]
widgets["frame23"].set_property("sensitive", checkbox.get_active())
conf.notify_add("useSounds", checkCallBack)
widgets["useSounds"].set_active(True)
uistuff.keep(widgets["useSounds"], "useSounds")
checkCallBack()
def soundError(player, gstmessage):
widgets["useSounds"].set_sensitive(False)
widgets["useSounds"].set_active(False)
self.getPlayer().connect("error", soundError)
def _init(cls):
cls.white = get_pixbuf("glade/white.png")
cls.black = get_pixbuf("glade/black.png")
cls.widgets = uistuff.GladeWidgets("newInOut.glade")
cls.widgets["newgamedialog"].set_transient_for(mainwindow())
def on_exchange_players(widget, button_event):
white = cls.widgets["whitePlayerCombobox"].get_active()
black = cls.widgets["blackPlayerCombobox"].get_active()
whiteLevel = cls.widgets["skillSlider1"].get_value()
blackLevel = cls.widgets["skillSlider2"].get_value()
cls.widgets["whitePlayerCombobox"].set_active(black)
cls.widgets["blackPlayerCombobox"].set_active(white)
cls.widgets["skillSlider1"].set_value(blackLevel)
cls.widgets["skillSlider2"].set_value(whiteLevel)
cls.widgets["whitePlayerButton"].set_image(
Gtk.Image.new_from_pixbuf(cls.white))
cls.widgets["whitePlayerButton"].connect("button-press-event",
on_exchange_players)
cls.widgets["blackPlayerButton"].set_image(
Gtk.Image.new_from_pixbuf(cls.black))
cls.widgets["blackPlayerButton"].connect("button-press-event",
on_exchange_players)
uistuff.createCombo(cls.widgets["whitePlayerCombobox"],
name="whitePlayerCombobox")
uistuff.createCombo(cls.widgets["blackPlayerCombobox"],
name="blackPlayerCombobox")
cls.widgets["playersIcon"].set_from_pixbuf(big_people)
cls.widgets["timeIcon"].set_from_pixbuf(big_time)
def on_playerCombobox_changed(widget, skill_hbox):
skill_hbox.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, 0)
cls.__initTimeRadio(_("Rapid"), "ngrapid", cls.widgets["rapidRadio"],
cls.widgets["configImageRapid"], 15, 5, 0)
cls.__initTimeRadio(_("Normal"), "ngnormal",
cls.widgets["normalRadio"],
cls.widgets["configImageNormal"], 40, 15, 0)
cls.__initTimeRadio(_("Classical"), "ngclassical",
cls.widgets["classicalRadio"],
cls.widgets["configImageClassical"], 3, 0, 40)
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)
discoverer.connect_after("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",
"classicalRadio", "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 __init__(self, widgets):
# Put engines in trees and combos
engines = discoverer.getEngines()
allstore = gtk.ListStore(gtk.gdk.Pixbuf, str)
for engine in engines.values():
c = discoverer.getCountry(engine)
if c:
flag = addDataPrefix("flags/%s.png" % c)
if not c or not os.path.isfile(flag):
flag = addDataPrefix("flags/unknown.png")
flag_icon = gtk.gdk.pixbuf_new_from_file(flag)
allstore.append((flag_icon, discoverer.getName(engine)))
tv = widgets["engines_treeview"]
tv.set_model(allstore)
tv.append_column(
gtk.TreeViewColumn(_("Flag"), gtk.CellRendererPixbuf(), pixbuf=0))
tv.append_column(
gtk.TreeViewColumn(_("Name"), gtk.CellRendererText(), text=1))
analyzers = list(discoverer.getAnalyzers())
ana_data = []
invana_data = []
for engine in analyzers:
name = discoverer.getName(engine)
c = discoverer.getCountry(engine)
if c:
flag = addDataPrefix("flags/%s.png" % c)
if not c or not os.path.isfile(flag):
flag = addDataPrefix("flags/unknown.png")
flag_icon = gtk.gdk.pixbuf_new_from_file(flag)
ana_data.append((flag_icon, name))
invana_data.append((flag_icon, name))
uistuff.createCombo(widgets["ana_combobox"], ana_data)
uistuff.createCombo(widgets["inv_ana_combobox"], invana_data)
# 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())
widgets["hint_mode"].set_active(check.get_active())
from pychess.Main import gameDic
if gameDic:
widgets["hint_mode"].set_sensitive(check.get_active())
widgets["analyzer_check"].connect("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())
widgets["spy_mode"].set_active(check.get_active())
from pychess.Main import gameDic
if gameDic:
widgets["spy_mode"].set_sensitive(check.get_active())
widgets["inv_analyzer_check"].connect("toggled",
on_invanalyzer_check_toggled)
uistuff.keep(widgets["inv_analyzer_check"], "inv_analyzer_check")
# Put options in trees in add/edit dialog
#=======================================================================
# tv = widgets["optionview"]
# tv.append_column(gtk.TreeViewColumn(
# "Option", gtk.CellRendererText(), text=0))
# tv.append_column(gtk.TreeViewColumn(
# "Value", gtk.CellRendererText(), text=1))
#
# def edit (button):
#
# iter = widgets["engines_treeview"].get_selection().get_selected()[1]
# if iter: row = allstore.get_path(iter)[0]
# else: return
#
# engine = discoverer.getEngineN(row)
# optionstags = engine.getElementsByTagName("options")
# if not optionstags:
# widgets["engine_options_expander"].hide()
# else:
# widgets["engine_options_expander"].show()
# widgets["engine_options_expander"].set_expanded(False)
#
# optionsstore = gtk.ListStore(str, str)
# tv = widgets["optionview"]
# tv.set_model(optionsstore)
#
# for option in optionstags[0].childNodes:
# if option.nodeType != option.ELEMENT_NODE: continue
# optionsstore.append( [option.getAttribute("name"),
# option.getAttribute("default")] )
#
# widgets["engine_path_chooser"].set_title(_("Locate Engine"))
# widgets["engine_path_chooser"].set_uri("file:///usr/bin/gnuchess")
#
# dialog = widgets["addconfig_engine"]
# answer = dialog.run()
# dialog.hide()
# widgets["edit_engine_button"].connect("clicked", edit)
#=======================================================================
#widgets["remove_engine_button"].connect("clicked", remove)
#widgets["add_engine_button"].connect("clicked", add)
# Give widgets to kepper
for combo in ("ana_combobox", "inv_ana_combobox"):
def get_value(combobox):
engine = list(discoverer.getAnalyzers())[combobox.get_active()]
if engine.find('md5') != None:
return engine.find('md5').text.strip()
def set_value(combobox, value):
engine = discoverer.getEngineByMd5(value)
if not engine:
combobox.set_active(0)
else:
try:
index = list(discoverer.getAnalyzers()).index(engine)
except ValueError:
index = 0
combobox.set_active(index)
uistuff.keep(widgets[combo], combo, get_value, set_value)
# Init info box
uistuff.makeYellow(widgets["analyzer_pref_infobox"])
widgets["analyzer_pref_infobox"].hide()
def updatePrefInfobox(widget, *args):
widgets["analyzer_pref_infobox"].show()
widgets["ana_combobox"].connect("changed", updatePrefInfobox)
widgets["analyzer_check"].connect("toggled", updatePrefInfobox)
widgets["inv_ana_combobox"].connect("changed", updatePrefInfobox)
widgets["inv_analyzer_check"].connect("toggled", updatePrefInfobox)
widgets["preferences"].connect(
"hide", lambda *a: widgets["analyzer_pref_infobox"].hide())
def _init(cls):
cls.white = get_pixbuf("glade/white.png")
cls.black = get_pixbuf("glade/black.png")
cls.widgets = uistuff.GladeWidgets("newInOut.glade")
cls.widgets["newgamedialog"].set_transient_for(mainwindow())
def on_exchange_players(widget, button_event):
white = cls.widgets["whitePlayerCombobox"].get_active()
black = cls.widgets["blackPlayerCombobox"].get_active()
whiteLevel = cls.widgets["skillSlider1"].get_value()
blackLevel = cls.widgets["skillSlider2"].get_value()
cls.widgets["whitePlayerCombobox"].set_active(black)
cls.widgets["blackPlayerCombobox"].set_active(white)
cls.widgets["skillSlider1"].set_value(blackLevel)
cls.widgets["skillSlider2"].set_value(whiteLevel)
cls.widgets["whitePlayerButton"].set_image(Gtk.Image.new_from_pixbuf(cls.white))
cls.widgets["whitePlayerButton"].connect("button-press-event", on_exchange_players)
cls.widgets["blackPlayerButton"].set_image(Gtk.Image.new_from_pixbuf(cls.black))
cls.widgets["blackPlayerButton"].connect("button-press-event", on_exchange_players)
uistuff.createCombo(cls.widgets["whitePlayerCombobox"], name="whitePlayerCombobox")
uistuff.createCombo(cls.widgets["blackPlayerCombobox"], name="blackPlayerCombobox")
cls.widgets["playersIcon"].set_from_pixbuf(big_people)
cls.widgets["timeIcon"].set_from_pixbuf(big_time)
def on_playerCombobox_changed(widget, skill_hbox, skill_level):
position = widget.get_active()
skill_hbox.props.visible = position > 0
if position > 0:
tree_iter = widget.get_active_iter()
if tree_iter is not None:
engine_name = widget.get_model()[tree_iter][1]
engine = discoverer.getEngineByName(engine_name)
if engine:
pref_level = engine.get("level")
if pref_level:
skill_level.set_value(pref_level)
cls.widgets["whitePlayerCombobox"].connect("changed", on_playerCombobox_changed, cls.widgets["skillHbox1"], cls.widgets["skillSlider1"])
cls.widgets["blackPlayerCombobox"].connect("changed", on_playerCombobox_changed, cls.widgets["skillHbox2"], cls.widgets["skillSlider2"])
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("ngblitz", cls.widgets["blitzRadio"], cls.widgets["configImageBlitz"], 5, 0, 0)
cls.__initTimeRadio("ngrapid", cls.widgets["rapidRadio"], cls.widgets["configImageRapid"], 15, 5, 0)
cls.__initTimeRadio("ngnormal", cls.widgets["normalRadio"], cls.widgets["configImageNormal"], 45, 15, 0)
cls.__initTimeRadio("ngclassical", cls.widgets["classicalRadio"], cls.widgets["configImageClassical"], 3, 0, 40)
cls.__initVariantRadio("ngvariant1", cls.widgets["playVariant1Radio"], cls.widgets["configImageVariant1"])
cls.__initVariantRadio("ngvariant2", cls.widgets["playVariant2Radio"], cls.widgets["configImageVariant2"])
def updateCombos(*args):
if cls.widgets["playNormalRadio"].get_active():
variant = NORMALCHESS
elif cls.widgets["playVariant1Radio"].get_active():
variant = conf.get("ngvariant1")
else:
variant = conf.get("ngvariant2")
variant1 = conf.get("ngvariant1")
cls.widgets["playVariant1Radio"].set_tooltip_text(variants[variant1].__desc__)
variant2 = conf.get("ngvariant2")
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)
discoverer.connect_after("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")
cls.widgets["playVariant1Radio"].set_tooltip_text(variants[variant1].__desc__)
cls.widgets["playVariant2Radio"].connect("toggled", updateCombos)
variant2 = conf.get("ngvariant2")
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", "classicalRadio",
"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)
