def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
# All side panels can be show/hide from View menu now, so no need to do the same from preferences
# We can re enable this after implementing install/uninstall functionality in the future...
# PanelTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
notebook = widgets["preferences_notebook"]
def switch_page(widget, page, page_num):
global hint_tab, theme_tab, sound_tab, save_tab
if page_num == 1 and hint_tab is None:
hint_tab = HintTab(widgets)
elif page_num == 3 and theme_tab is None:
theme_tab = ThemeTab(widgets)
elif page_num == 4 and sound_tab is None:
sound_tab = SoundTab(widgets)
elif page_num == 5 and save_tab is None:
save_tab = SaveTab(widgets)
notebook.connect("switch_page", switch_page)
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def initUi (self):
self.window = Gtk.Window()
self.window.set_border_width(12)
self.window.set_icon_name("pychess")
self.window.set_title("PyChess - Internet Chess Chat")
self.window.connect("delete-event", lambda w,e: w.hide() or True)
uistuff.keepWindowSize("chatwindow", self.window, defaultSize=(650,400))
dock = PyDockTop("icchat")
dock.show()
self.window.add(dock)
leaf = dock.dock(self.viewspanel, CENTER, Gtk.Label(label="chat"), "chat")
leaf.setDockable(False)
self.channelspanel.connect('conversationAdded', self.onConversationAdded)
self.channelspanel.connect('conversationRemoved', self.onConversationRemoved)
self.channelspanel.connect('conversationSelected', self.onConversationSelected)
leaf.dock(self.channelspanel, WEST, Gtk.Label(label=_("Conversations")), "conversations")
leaf.dock(self.infopanel, EAST, Gtk.Label(label=_("Conversation info")), "info")
for panel in self.panels:
panel.show_all()
panel.start()
def __init__(self):
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect(
'key-press-event',
lambda w, e: e.keyval == gtk.keysyms.Escape and w.hide())
def on_logOnAsGuest_toggled(check):
self.widgets["nameLabel"].set_sensitive(not check.get_active())
self.widgets["nameEntry"].set_sensitive(not check.get_active())
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled",
on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "logOnAsGuest")
uistuff.keep(self.widgets["nameEntry"], "usernameEntry")
uistuff.keep(self.widgets["passEntry"], "passwordEntry")
uistuff.makeYellow(self.widgets["messagePanel"])
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["fics_logon"].connect("delete-event", self.onClose)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.connection = None
self.lounge = None
def __init__ (self):
self.connection = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon", self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect('key-press-event',
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
def on_logOnAsGuest_toggled (check):
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled", on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "logOnAsGuest")
uistuff.keep(self.widgets["nameEntry"], "usernameEntry")
uistuff.keep(self.widgets["passEntry"], "passwordEntry")
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
#self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar,
False, False, 0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def __init__(self):
self.connection = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect(
'key-press-event',
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
def on_logOnAsGuest_toggled(check):
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled",
on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "logOnAsGuest")
uistuff.keep(self.widgets["nameEntry"], "usernameEntry")
uistuff.keep(self.widgets["passEntry"], "passwordEntry")
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
#self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar, False, False,
0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def __init__ (self):
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon", self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect('key-press-event',
lambda w, e: e.keyval == gtk.keysyms.Escape and w.hide())
def on_logOnAsGuest_toggled (check):
self.widgets["nameLabel"].set_sensitive(not check.get_active())
self.widgets["nameEntry"].set_sensitive(not check.get_active())
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled", on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "logOnAsGuest")
uistuff.keep(self.widgets["nameEntry"], "usernameEntry")
uistuff.keep(self.widgets["passEntry"], "passwordEntry")
uistuff.makeYellow(self.widgets["messagePanel"])
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["fics_logon"].connect("delete-event", self.onClose)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.connection = None
self.lounge = None
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
# All side panels can be show/hide from View menu now, so no need to do the same from preferences
# We can re enable this after implementing install/uninstall functionality in the future...
# PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE))
if e.keyval == Gdk.KEY_Escape else None)
def initUi(self):
self.window = Gtk.Window()
self.window.set_border_width(12)
self.window.set_icon_name("pychess")
self.window.set_title("PyChess - Internet Chess Chat")
self.window.connect("delete-event", lambda w, e: w.hide() or True)
uistuff.keepWindowSize("chatwindow",
self.window,
defaultSize=(650, 400))
dock = PyDockTop("icchat")
dock.show()
self.window.add(dock)
leaf = dock.dock(self.viewspanel, CENTER, Gtk.Label(label="chat"),
"chat")
leaf.setDockable(False)
self.channelspanel.connect('conversationAdded',
self.onConversationAdded)
self.channelspanel.connect('conversationRemoved',
self.onConversationRemoved)
self.channelspanel.connect('conversationSelected',
self.onConversationSelected)
leaf.dock(self.channelspanel, WEST,
Gtk.Label(label=_("Conversations")), "conversations")
leaf.dock(self.infopanel, EAST,
Gtk.Label(label=_("Conversation info")), "info")
for panel in self.panels:
panel.show_all()
panel.start()
def __init__(self):
self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL, title=_("Ask for permissions"))
self.window.set_transient_for(mainwindow())
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version())
if gtk_version >= (3, 12):
vbox.props.margin_start = 9
vbox.props.margin_end = 9
else:
vbox.props.margin_left = 9
vbox.props.margin_right = 9
vbox.props.margin_bottom = 9
self.window.add(vbox)
uistuff.keepWindowSize("externalsdialog", self.window, (320, 240), uistuff.POSITION_CENTER)
label = Gtk.Label(_("Some of PyChess features needs your permission to download external programs"))
vbox.pack_start(label, True, True, 0)
box = Gtk.Box()
check_button = Gtk.CheckButton(_("database querying needs scoutfish"))
check_button.set_active(conf.get("download_scoutfish", False))
check_button.connect("toggled", lambda w: conf.set("download_scoutfish", w.get_active()))
box.add(check_button)
link = "https://github.com/pychess/scoutfish"
link_button = Gtk.LinkButton(link, link)
box.add(link_button)
vbox.pack_start(box, False, False, 0)
box = Gtk.Box()
check_button = Gtk.CheckButton(_("database opening tree needs chess_db"))
check_button.set_active(conf.get("download_chess_db", False))
check_button.connect("toggled", lambda w: conf.set("download_chess_db", w.get_active()))
box.add(check_button)
link = "https://github.com/pychess/chess_db"
link_button = Gtk.LinkButton(link, link)
box.add(link_button)
vbox.pack_start(box, False, False, 0)
box = Gtk.Box()
check_button = Gtk.CheckButton(_("ICC lag compensation needs timestamp"))
check_button.set_active(conf.get("download_timestamp", False))
check_button.connect("toggled", lambda w: conf.set("download_timestamp", w.get_active()))
box.add(check_button)
link = "https://www.chessclub.com/user/resources/icc/timestamp"
link_button = Gtk.LinkButton(link, link)
box.add(link_button)
vbox.pack_start(box, False, False, 0)
check_button = Gtk.CheckButton(_("Don't show this dialog on startup."))
check_button.set_active(conf.get("dont_show_externals_at_startup", False))
check_button.connect("toggled", lambda w: conf.set("dont_show_externals_at_startup", w.get_active()))
vbox.pack_start(check_button, True, True, 0)
buttonbox = Gtk.ButtonBox()
close_button = Gtk.Button.new_from_stock(Gtk.STOCK_OK)
close_button.connect("clicked", self.on_close_clicked)
self.window.connect("delete_event", lambda w, a: self.window.destroy())
buttonbox.add(close_button)
vbox.pack_start(buttonbox, False, False, 0)
def __init__(self):
self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL, title=_("Ask for permissions"))
self.window.set_transient_for(mainwindow())
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version())
if gtk_version >= (3, 12):
vbox.props.margin_start = 9
vbox.props.margin_end = 9
else:
vbox.props.margin_left = 9
vbox.props.margin_right = 9
vbox.props.margin_bottom = 9
self.window.add(vbox)
uistuff.keepWindowSize("externalsdialog", self.window, (320, 240), uistuff.POSITION_CENTER)
label = Gtk.Label(_("Some of PyChess features needs your permission to download external programs"))
vbox.pack_start(label, True, True, 0)
box = Gtk.Box()
check_button = Gtk.CheckButton(_("database querying needs scoutfish"))
check_button.set_active(conf.get("download_scoutfish", False))
check_button.connect("toggled", lambda w: conf.set("download_scoutfish", w.get_active()))
box.add(check_button)
link = "https://github.com/pychess/scoutfish"
link_button = Gtk.LinkButton(link, link)
box.add(link_button)
vbox.pack_start(box, False, False, 0)
box = Gtk.Box()
check_button = Gtk.CheckButton(_("database opening tree needs chess_db"))
check_button.set_active(conf.get("download_chess_db", False))
check_button.connect("toggled", lambda w: conf.set("download_chess_db", w.get_active()))
box.add(check_button)
link = "https://github.com/pychess/chess_db"
link_button = Gtk.LinkButton(link, link)
box.add(link_button)
vbox.pack_start(box, False, False, 0)
box = Gtk.Box()
check_button = Gtk.CheckButton(_("ICC lag compensation needs timestamp"))
check_button.set_active(conf.get("download_timestamp", False))
check_button.connect("toggled", lambda w: conf.set("download_timestamp", w.get_active()))
box.add(check_button)
link = "http://download.chessclub.com/timestamp/"
link_button = Gtk.LinkButton(link, link)
box.add(link_button)
vbox.pack_start(box, False, False, 0)
check_button = Gtk.CheckButton(_("Don't show this dialog on startup."))
check_button.set_active(conf.get("dont_show_externals_at_startup", False))
check_button.connect("toggled", lambda w: conf.set("dont_show_externals_at_startup", w.get_active()))
vbox.pack_start(check_button, True, True, 0)
buttonbox = Gtk.ButtonBox()
close_button = Gtk.Button.new_from_stock(Gtk.STOCK_OK)
close_button.connect("clicked", self.on_close_clicked)
self.window.connect("delete_event", lambda w, a: self.window.destroy())
buttonbox.add(close_button)
vbox.pack_start(buttonbox, False, False, 0)
def __init__(self):
self.connection = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect(
'key-press-event',
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
def on_logOnAsGuest_toggled(check):
names = get_user_names()
self.widgets["nameEntry"].set_text(
names[1] if check.get_active() else names[0])
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled",
on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "asGuestCheck")
as_guest = self.widgets["logOnAsGuest"]
def user_name_get_value(entry):
names = get_user_names()
if as_guest.get_active():
text = "%s|%s" % (names[0], entry.get_text())
else:
text = "%s|%s" % (entry.get_text(), names[1])
return text
def user_name_set_value(entry, value):
names = get_user_names(value=value)
if as_guest.get_active():
entry.set_text(names[1])
else:
entry.set_text(names[0])
uistuff.keep(self.widgets["nameEntry"], "usernameEntry", \
user_name_get_value, user_name_set_value)
uistuff.keep(self.widgets["passEntry"], "passwordEntry")
uistuff.keep(self.widgets["hostEntry"], "hostEntry")
uistuff.keep(self.widgets["autoLogin"], "autoLogin")
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
#self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar, False, False,
0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def __init__(self):
self.connection = None
self.helperconn = None
self.connection_task = None
self.helperconn_task = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize(
"fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN,
)
self.widgets["fics_logon"].connect(
"key-press-event",
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
self.ics = "FICS"
self.as_guest = self.widgets["logOnAsGuest"]
self.widgets["logOnAsGuest"].connect("toggled",
self.on_logOnAsGuest_toggled)
def on_username_changed(widget):
conf.set("usernameEntry",
self.user_name_get_value(widget),
section=self.ics)
self.widgets["nameEntry"].connect("changed", on_username_changed)
def on_password_changed(widget):
conf.set("passwordEntry", widget.get_text(), section=self.ics)
self.widgets["passEntry"].connect("changed", on_password_changed)
def on_host_changed(widget):
conf.set("hostEntry",
self.host_get_value(widget),
section=self.ics)
self.widgets["hostEntry"].connect("changed", on_host_changed)
self.widgets["timesealCheck"].connect("toggled",
self.on_timeseal_toggled)
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
# self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar, False, False,
0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def __init__(self):
self.connection = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect(
'key-press-event',
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
def on_logOnAsGuest_toggled(check):
names = get_user_names()
self.widgets["nameEntry"].set_text(names[1] if check.get_active()
else names[0])
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled",
on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "asGuestCheck")
as_guest = self.widgets["logOnAsGuest"]
def user_name_get_value(entry):
names = get_user_names()
if as_guest.get_active():
text = "%s|%s" % (names[0], entry.get_text())
else:
text = "%s|%s" % (entry.get_text(), names[1])
return text
def user_name_set_value(entry, value):
names = get_user_names(value=value)
if as_guest.get_active():
entry.set_text(names[1])
else:
entry.set_text(names[0])
uistuff.keep(self.widgets["nameEntry"], "usernameEntry",
user_name_get_value, user_name_set_value)
uistuff.keep(self.widgets["passEntry"], "passwordEntry")
uistuff.keep(self.widgets["hostEntry"], "hostEntry")
uistuff.keep(self.widgets["autoLogin"], "autoLogin")
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
# self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar, False, False,
0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def __init__(self):
self.widgets = uistuff.GladeWidgets("tipoftheday.glade")
self.widgets["window1"].set_transient_for(mainwindow())
uistuff.keepWindowSize("tipoftheday", self.widgets["window1"], (320, 240), uistuff.POSITION_CENTER)
self.widgets["checkbutton1"].set_active(conf.get("show_tip_at_startup"))
self.widgets["checkbutton1"].connect("toggled", lambda w: conf.set("show_tip_at_startup", w.get_active()))
self.widgets["close_button"].connect("clicked", lambda w: self.widgets["window1"].emit("delete-event", None))
self.widgets["window1"].connect("delete_event", lambda w, a: self.widgets["window1"].destroy())
self.widgets["back_button"].connect("clicked", lambda w: self.set_currentIndex(self.currentIndex - 1))
self.widgets["forward_button"].connect("clicked", lambda w: self.set_currentIndex(self.currentIndex + 1))
self.currentIndex = 0
def __init__(self, url):
from pychess.System.uistuff import keepWindowSize
self.window = Gtk.Window()
keepWindowSize("webkitbrowser", self.window, (800, 600))
self.vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.window.add(self.vbox)
self.box = Gtk.Box()
self.toolbar = Gtk.Toolbar()
self.box.pack_start(self.toolbar, False, False, 0)
self.go_back_button = Gtk.ToolButton(stock_id=Gtk.STOCK_GO_BACK)
self.toolbar.insert(self.go_back_button, -1)
self.go_forward_button = Gtk.ToolButton(stock_id=Gtk.STOCK_GO_FORWARD)
self.toolbar.insert(self.go_forward_button, -1)
self.go_refresh_button = Gtk.ToolButton(stock_id=Gtk.STOCK_REFRESH)
self.toolbar.insert(self.go_refresh_button, -1)
self.url = Gtk.Entry()
self.box.pack_start(self.url, True, True, 0)
self.search_entry = Gtk.SearchEntry()
self.box.pack_start(self.search_entry, False, False, 0)
self.vbox.pack_start(self.box, False, False, 0)
self.view = WebKit.WebView()
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.add(self.view)
self.vbox.pack_start(self.scrolled_window, True, True, 0)
self.window.show_all()
self.view.connect("load-committed", self.check_buttons)
self.view.connect("title-changed", self.change_title)
self.url.connect("activate", self.go)
self.search_entry.connect("activate", self.search)
self.go_back_button.connect("clicked", self.go_back)
self.go_forward_button.connect("clicked", self.go_forward)
self.go_refresh_button.connect("clicked", self.refresh)
self.view.open(url)
self.view.show()
def initialize(widgets):
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
PanelTab(widgets)
ThemeTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences"],
defaultPosition=POSITION_GOLDEN)
def delete_event (widget, *args):
widgets["preferences"].hide()
return True
widgets["preferences"].connect("delete-event", delete_event)
widgets["preferences"].connect("key-press-event",
lambda w,e: w.event(Gdk.Event(Gdk.EventType.DELETE))
if e.keyval == Gdk.KEY_Escape else None)
def __init__(self):
self.connection = None
self.helperconn = None
self.connection_task = None
self.helperconn_task = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect(
'key-press-event',
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
self.ics = "FICS"
self.as_guest = self.widgets["logOnAsGuest"]
self.widgets["logOnAsGuest"].connect("toggled", self.on_logOnAsGuest_toggled)
def on_username_changed(widget):
conf.set("usernameEntry", self.user_name_get_value(widget), section=self.ics)
self.widgets["nameEntry"].connect("changed", on_username_changed)
def on_password_changed(widget):
conf.set("passwordEntry", widget.get_text(), section=self.ics)
self.widgets["passEntry"].connect("changed", on_password_changed)
def on_host_changed(widget):
conf.set("hostEntry", self.host_get_value(widget), section=self.ics)
self.widgets["hostEntry"].connect("changed", on_host_changed)
self.widgets["timesealCheck"].connect("toggled", self.on_timeseal_toggled)
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
# self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar, False, False,
0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def __init__ (self, widgets, connection):
self.connection = connection
self.window = Gtk.Window()
self.window.set_border_width(12)
self.window.set_icon_name("pychess")
self.window.set_title("FICS Console")
self.window.connect("delete-event", lambda w,e: w.hide() or True)
uistuff.keepWindowSize("consolewindow", self.window, defaultSize=(700,400))
self.consoleView = ConsoleView(self.connection)
self.window.add(self.consoleView)
widgets["show_console_button"].connect("clicked", self.showConsole)
connection.com.connect("consoleMessage", self.onConsoleMessage)
connection.connect("disconnected", self.onDisconnected)
def initialize(widgets):
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
PanelTab(widgets)
ThemeTab(widgets)
def delete_event (widget, *args):
widgets["preferences"].hide()
return False
widgets["preferences"].connect("delete-event", delete_event)
widgets["preferences_close_button"].connect("clicked", delete_event)
widgets["preferences"].connect("key-press-event",
lambda w,e: delete_event(w) if e.keyval == gtk.keysyms.Escape else None)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences"],
defaultPosition=POSITION_GOLDEN)
def initialize(widgets):
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
widgets["preferences_notebook"].set_name("preferences_notebook")
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
def delete_event(widget, *args):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def initialize(widgets):
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences"])
def delete_event(widget, *args):
widgets["preferences"].hide()
return True
widgets["preferences"].connect("delete-event", delete_event)
widgets["preferences"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE))
if e.keyval == Gdk.KEY_Escape else None)
def __init__(self, widgets, connection):
self.connection = connection
self.window = Gtk.Window()
self.window.set_border_width(12)
self.window.set_icon_name("pychess")
self.window.set_title("FICS Console")
self.window.connect("delete-event", lambda w, e: w.hide() or True)
uistuff.keepWindowSize("consolewindow",
self.window,
defaultSize=(700, 400))
self.consoleView = ConsoleView(self.connection)
self.window.add(self.consoleView)
widgets["show_console_button"].connect("clicked", self.showConsole)
connection.com.connect("consoleMessage", self.onConsoleMessage)
connection.connect("disconnected", self.onDisconnected)
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def _init(cls):
cls.tagToIter = {}
cls.tagToPage = {}
cls.pathToPage = {}
cls.tagToTime = {}
cls.window = Gtk.Window()
cls.window.set_title(_("PyChess Information Window"))
cls.window.set_border_width(12)
cls.window.set_icon_name("pychess")
uistuff.keepWindowSize("logdialog", cls.window, (640, 480))
mainHBox = Gtk.HBox()
mainHBox.set_spacing(6)
cls.window.add(mainHBox)
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
mainHBox.pack_start(sw, False, True, 0)
cls.treeview = Gtk.TreeView(Gtk.TreeStore(str))
cls.treeview.append_column(Gtk.TreeViewColumn("",
Gtk.CellRendererText(),
text=0))
cls.treeview.set_headers_visible(False)
cls.treeview.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
sw.add(cls.treeview)
cls.pages = Gtk.Notebook()
cls.pages.set_show_tabs(False)
cls.pages.set_show_border(False)
mainHBox.pack_start(cls.pages, True, True, 0)
mainHBox.show_all()
def selectionChanged(selection):
treestore, iter = selection.get_selected()
if iter:
child = cls.pathToPage[treestore.get_path(iter).to_string()][
"child"]
cls.pages.set_current_page(cls.pages.page_num(child))
cls.treeview.get_selection().connect("changed", selectionChanged)
def _init(cls):
cls.tagToIter = {}
cls.tagToPage = {}
cls.pathToPage = {}
cls.tagToTime = {}
cls.window = Gtk.Window()
cls.window.set_title(_("PyChess Information Window"))
cls.window.set_border_width(12)
cls.window.set_icon_name("pychess")
uistuff.keepWindowSize("logdialog", cls.window, (640, 480))
mainHBox = Gtk.HBox()
mainHBox.set_spacing(6)
cls.window.add(mainHBox)
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
mainHBox.pack_start(sw, False, True, 0)
cls.treeview = Gtk.TreeView(Gtk.TreeStore(str))
cls.treeview.append_column(Gtk.TreeViewColumn("",
Gtk.CellRendererText(),
text=0))
cls.treeview.set_headers_visible(False)
cls.treeview.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
sw.add(cls.treeview)
cls.pages = Gtk.Notebook()
cls.pages.set_show_tabs(False)
cls.pages.set_show_border(False)
mainHBox.pack_start(cls.pages, True, True, 0)
mainHBox.show_all()
def selectionChanged(selection):
treestore, iter = selection.get_selected()
if iter:
child = cls.pathToPage[treestore.get_path(iter).to_string()][
"child"]
cls.pages.set_current_page(cls.pages.page_num(child))
cls.treeview.get_selection().connect("changed", selectionChanged)
def __init__(self, widgets, connection):
self.connection = connection
self.window = Gtk.Window()
self.window.set_border_width(12)
# ChatWindow uses this to check is_active() so don't touch this!
self.window.set_icon_name("pychess")
self.window.set_title("%s Console" % connection.ics_name)
self.window.connect_after("delete-event",
lambda w, e: w.hide() or True)
uistuff.keepWindowSize("console", self.window, defaultSize=(800, 400))
self.consoleView = ConsoleView(self.window, self.connection)
self.window.add(self.consoleView)
widgets["show_console_button"].connect("clicked", self.showConsole)
connection.com.connect("consoleMessage", self.onConsoleMessage)
connection.connect("disconnected", self.onDisconnected)
def _init (cls):
cls.widgets = uistuff.GladeWidgets("tipoftheday.glade")
uistuff.keepWindowSize("tipoftheday", cls.widgets["window1"],
(320,240), uistuff.POSITION_CENTER)
cls.widgets["checkbutton1"].set_active(conf.get("show_tip_at_startup", False))
cls.widgets["checkbutton1"].connect("toggled",
lambda w: conf.set("show_tip_at_startup", w.get_active()))
cls.widgets["close_button"].connect("clicked",
lambda w: cls.widgets["window1"].emit("delete-event", None))
cls.widgets["window1"].connect("delete_event",
lambda w, a: cls.widgets["window1"].hide())
cls.widgets["back_button"].connect("clicked",
lambda w: cls.set_currentIndex(cls.currentIndex-1))
cls.widgets["forward_button"].connect("clicked",
lambda w: cls.set_currentIndex(cls.currentIndex+1))
cls.currentIndex = 0
def __init__(self):
self.widgets = uistuff.GladeWidgets("tipoftheday.glade")
self.widgets["window1"].set_transient_for(mainwindow())
uistuff.keepWindowSize("tipoftheday", self.widgets["window1"],
(320, 240), uistuff.POSITION_CENTER)
self.widgets["checkbutton1"].set_active(
conf.get("show_tip_at_startup"))
self.widgets["checkbutton1"].connect(
"toggled",
lambda w: conf.set("show_tip_at_startup", w.get_active()))
self.widgets["close_button"].connect(
"clicked",
lambda w: self.widgets["window1"].emit("delete-event", None))
self.widgets["window1"].connect(
"delete_event", lambda w, a: self.widgets["window1"].destroy())
self.widgets["back_button"].connect(
"clicked", lambda w: self.set_currentIndex(self.currentIndex - 1))
self.widgets["forward_button"].connect(
"clicked", lambda w: self.set_currentIndex(self.currentIndex + 1))
self.currentIndex = 0
def _init(cls):
cls.widgets = uistuff.GladeWidgets("tipoftheday.glade")
uistuff.keepWindowSize("tipoftheday", cls.widgets["window1"],
(320, 240), uistuff.POSITION_CENTER)
cls.widgets["checkbutton1"].set_active(
conf.get("show_tip_at_startup", False))
cls.widgets["checkbutton1"].connect(
"toggled",
lambda w: conf.set("show_tip_at_startup", w.get_active()))
cls.widgets["close_button"].connect(
"clicked",
lambda w: cls.widgets["window1"].emit("delete-event", None))
cls.widgets["window1"].connect(
"delete_event", lambda w, a: cls.widgets["window1"].hide())
cls.widgets["back_button"].connect(
"clicked", lambda w: cls.set_currentIndex(cls.currentIndex - 1))
cls.widgets["forward_button"].connect(
"clicked", lambda w: cls.set_currentIndex(cls.currentIndex + 1))
cls.currentIndex = 0
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
global general_tab
general_tab = GeneralTab(widgets)
# All side panels can be show/hide from View menu now, so no need to do the same from preferences
# We can re enable this after implementing install/uninstall functionality in the future...
# PanelTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
notebook = widgets["preferences_notebook"]
def switch_page(widget, page, page_num):
global hint_tab, theme_tab, sound_tab, save_tab
if page_num == 1 and hint_tab is None:
hint_tab = HintTab(widgets)
elif page_num == 3 and theme_tab is None:
theme_tab = ThemeTab(widgets)
elif page_num == 4 and sound_tab is None:
sound_tab = SoundTab(widgets)
elif page_num == 5 and save_tab is None:
save_tab = SaveTab(widgets)
notebook.connect("switch_page", switch_page)
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
# All side panels can be show/hide from View menu now, so no need to do the same from preferences
# We can re enable this after implementing install/uninstall functionality in the future...
# PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow", self.dialog)
# Put engines into tree store
self.allstore = Gtk.ListStore(Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(self.allstore)
self.tv.append_column(
Gtk.TreeViewColumn("Flag", Gtk.CellRendererPixbuf(), pixbuf=0))
name_renderer = Gtk.CellRendererText()
name_renderer.set_property("editable", False)
self.tv.append_column(Gtk.TreeViewColumn("Name", name_renderer,
text=1))
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
protocol_combo.set_name("engine_protocol_combo")
cell = Gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = Gtk.ListStore(str, str, GObject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(
Gtk.TreeViewColumn(" ", Gtk.CellRendererText(), text=0))
optv.append_column(
Gtk.TreeViewColumn(_("Option"), Gtk.CellRendererText(), text=1))
optv.append_column(
Gtk.TreeViewColumn(_("Value"),
KeyValueCellRenderer(self.options_store),
data=2))
self.update_store()
def do_update_store(self, *args):
GLib.idle_add(engine_dialog.update_store)
discoverer.connect_after("engine_discovered", do_update_store)
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
discoverer.removeEngine(self.cur_engine)
selection = self.tv.get_selection()
result = selection.get_selected()
if result is not None:
model, ts_iter = result
model.remove(ts_iter)
if model.iter_n_children() == 0:
clearView()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = Gtk.FileChooserDialog(
_("Select engine"), mainwindow(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
filter = Gtk.FileFilter()
filter.set_name(_("Executable files"))
filter.add_mime_type("application/x-executable")
filter.add_mime_type("application/x-sharedlib")
filter.add_mime_type("application/x-ms-dos-executable")
filter.add_mime_type("application/x-msdownload")
filter.add_pattern("*.exe")
for vm in VM_LIST:
filter.add_pattern("*%s" % vm.ext)
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
binname = os.path.split(new_engine)[1]
ext = os.path.splitext(new_engine)[1]
# Verify if the engine already exists under the same name
if new_engine != "":
for eng in discoverer.getEngines():
if eng["command"] == new_engine:
msg_dia = Gtk.MessageDialog(
mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("The engine is already installed under the same name"
))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
# Detect the host application
if new_engine != "":
vm_name = None
vm_args = None
vmpath = ""
# Scripting
for vm in VM_LIST:
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
break
# Wine for Windows application under Linux
if vm_name is None and new_engine.lower().endswith(
".exe") and sys.platform != "win32":
vm_name = "wine"
# Check that the interpreter is available
if vm_name is not None:
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(
mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
# Next checks
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(
new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>%s is not marked executable in the filesystem</b></big>"
% new_engine))
msg_dia.format_secondary_text(
_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command += vm_args
engine_command.append(new_engine)
# Search the engines based on the most expectable protocol
refeng = discoverer.getReferencedEngine(binname)
if refeng is not None and refeng[
"protocol"] == "xboard":
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
msg_dia = Gtk.MessageDialog(
mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"
))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol,
vm_name, vm_args)
self.cur_engine = binname
self.add = False
discoverer.discover()
except Exception:
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
# add in mass button
################################################################
def addInMass(button):
# Ask the user to select a folder
folder_dlg = Gtk.FileChooserDialog(
_("Choose a folder"), None,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
answer = folder_dlg.run()
path = folder_dlg.get_filename()
folder_dlg.destroy()
# Search for the engines
if answer != Gtk.ResponseType.OK:
return False
possibleFiles = listEnginesFromPath(path)
# Remove the existing engines from the list
def isNewEngine(path):
sfn = os.path.basename(path)
for engine in discoverer.getEngines():
if sfn in engine.get(
"command"): # The short name must be unique
return False
return True
possibleFiles = [fn for fn in possibleFiles if isNewEngine(fn)]
if len(possibleFiles) == 0:
return False
# Prepare the result in a dialog
mass_dialog = self.widgets["engine_list_dialog"]
self.widgets["mass_path_label"].set_text(path)
mass_list = self.widgets["mass_list_treeview"]
if len(mass_list.get_columns()) == 0: # Not initialized yet
mass_store = Gtk.ListStore(bool, str)
mass_list.set_model(mass_store)
def checkbox_renderer_cb(cell, path, model):
model[path][0] = not model[path][0]
return
checkbox_renderer = Gtk.CellRendererToggle()
checkbox_renderer.set_property("activatable", True)
checkbox_renderer.connect("toggled", checkbox_renderer_cb,
mass_store)
mass_list.append_column(
Gtk.TreeViewColumn(_("Import"),
checkbox_renderer,
active=0))
mass_list.append_column(
Gtk.TreeViewColumn(_("File name"),
Gtk.CellRendererText(),
text=1))
else:
mass_store = mass_list.get_model()
mass_store.clear()
for fn in possibleFiles:
mass_store.append([False, fn[len(path):]])
# Show the dialog
answer = mass_dialog.run()
mass_dialog.hide()
if answer != Gtk.ResponseType.OK.real:
return False
# Add the new engines
self.add = True
found = False
for entry in mass_store:
if entry[0]:
newengine = discoverer.getReferencedEngine(path + entry[1])
if newengine is not None:
discoverer.addEngineFromReference(newengine)
found = True
self.add = False
if found:
discoverer.discover()
return True
self.widgets["mass_engine_button"].connect("clicked", addInMass)
################################################################
def clearView():
self.selection = True
self.cur_engine = None
self.widgets["vm_command_entry"].set_text("")
self.widgets["vm_args_entry"].set_text("")
self.widgets["engine_command_entry"].set_text("")
self.widgets["engine_args_entry"].set_text("")
self.widgets["engine_protocol_combo"].set_active(0)
self.widgets["engine_country_combo"].set_active(0)
self.widgets["engine_comment_entry"].set_text("")
self.widgets["engine_level_scale"].set_value(ENGINE_DEFAULT_LEVEL)
self.options_store.clear()
self.selection = False
################################################################
# vm args
################################################################
def vm_args_changed(widget):
if self.cur_engine is not None and not self.selection:
new_args = self.widgets["vm_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("vm_args")
if new_args != old_args:
engine["vm_args"] = new_args.split()
self.widgets["vm_args_entry"].connect("changed", vm_args_changed)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None and not self.selection:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = Gtk.FileChooserDialog(
_("Select working directory"), mainwindow(),
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
dir_chooser_button = Gtk.FileChooserButton.new_with_dialog(
dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active == 0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
command = engine.get("command")
engine_command = []
vm_command = engine.get("vm_command")
if vm_command is not None:
engine_command.append(vm_command)
vm_args = engine.get("vm_args")
if vm_args is not None:
engine_command.append(", ".join(vm_args))
engine_command.append(command)
# is the new protocol supported by the engine?
if new_protocol == "uci":
check_ok = is_uci(engine_command)
else:
check_ok = is_cecp(engine_command)
if check_ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
discoverer.discover()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(
0 if old_protocol == "uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed",
protocol_changed)
################################################################
# engine country
################################################################
def country_changed(widget):
if self.cur_engine is not None and not self.selection:
engine = discoverer.getEngineByName(self.cur_engine)
old_country = discoverer.getCountry(engine)
new_country = ISO3166_LIST[widget.get_active()].iso2
if old_country != new_country:
engine["country"] = new_country
# Refresh the flag in the tree view
path = addDataPrefix("flags/%s.png" % new_country)
if not os.path.isfile(path):
path = addDataPrefix("flags/unknown.png")
item = self.tv.get_selection().get_selected()
if item is not None:
model, ts_iter = item
model[ts_iter][0] = get_pixbuf(path)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["engine_country_combo"].connect("changed",
country_changed)
def country_keypressed(widget, event):
idx = 0
for iso in ISO3166_LIST:
if (idx != 0) and (
(ord(iso.country[0].lower()) == event.keyval) or
(ord(iso.country[0].upper()) == event.keyval)):
widget.set_active(idx)
break
idx += 1
self.widgets["engine_country_combo"].connect("key-press-event",
country_keypressed)
################################################################
# comment changed
################################################################
def comment_changed(widget):
if self.cur_engine is not None and not self.selection:
new_comment = self.widgets["engine_comment_entry"].get_text(
).strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_comment = engine.get("comment")
if new_comment != old_comment:
engine["comment"] = new_comment
self.widgets["engine_comment_entry"].connect("changed",
comment_changed)
################################################################
# level changed
################################################################
def level_changed(widget):
if self.cur_engine is not None and not self.selection:
new_level = widget.get_value()
engine = discoverer.getEngineByName(self.cur_engine)
old_level = engine.get("level")
if new_level != old_level:
engine["level"] = int(new_level)
self.widgets["engine_level_scale"].connect("value-changed",
level_changed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, tv_iter = self.tv.get_selection().get_selected()
if tv_iter:
self.selection = True
path = store.get_path(tv_iter)
indices = path.get_indices()
row = indices[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(
engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
vm = engine.get("vm_command")
self.widgets["vm_command_entry"].set_text(
vm if vm is not None else "")
args = [] if engine.get("vm_args") is None else engine.get(
"vm_args")
self.widgets["vm_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
dir_choice = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(dir_choice)
self.widgets["engine_protocol_combo"].set_active(
0 if engine["protocol"] == "uci" else 1)
self.widgets["engine_country_combo"].set_active(0)
country = discoverer.getCountry(engine)
idx = 0
for iso in ISO3166_LIST:
if iso.iso2 == country:
self.widgets["engine_country_combo"].set_active(idx)
break
idx += 1
comment = engine.get("comment")
self.widgets["engine_comment_entry"].set_text(
comment if comment is not None else "")
level = engine.get("level")
try:
level = int(level)
except Exception:
level = ENGINE_DEFAULT_LEVEL
self.widgets["engine_level_scale"].set_value(level)
self.update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0, ))
selection_changed(tree_selection)
################################################################
# restore the default options of the engine
################################################################
def engine_default_options(button):
if self.cur_engine is not None and not self.selection:
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
dialog = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(
_("Do you really want to restore the default options of the engine ?"
))
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
for option in options:
if "default" in option:
option["value"] = option["default"]
self.update_options()
self.widgets["engine_default_options_button"].connect(
"clicked", engine_default_options)
def initGlade(self, log_viewer):
# Init glade and the 'GladeHandlers'
self.widgets = widgets = uistuff.GladeWidgets("PyChess.glade")
self.glade_handlers = GladeHandlers(self)
widgets.getGlade().connect_signals(self.glade_handlers)
self.window = widgets["main_window"]
# new_game_tasker, internet_game_tasker = NewGameTasker(
# ), InternetGameTasker()
# tasker.packTaskers(new_game_tasker, internet_game_tasker)
# widgets["Background"].add(tasker)
# Redirect widgets
gamewidget.setWidgets(widgets)
# The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode")
uistuff.keep(widgets["spy_mode"], "spy_mode")
uistuff.keep(widgets["show_sidepanels"], "show_sidepanels")
uistuff.keep(widgets["auto_call_flag"], "autoCallFlag")
# Show main window and init d'n'd
widgets["main_window"].set_title('%s - PyChess' % _('Welcome'))
widgets["main_window"].connect("delete-event", self.glade_handlers.on_quit1_activate)
widgets["main_window"].connect("key-press-event", self.glade_handlers.on_window_key_press)
uistuff.keepWindowSize("main", widgets["main_window"], None, uistuff.POSITION_GOLDEN)
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
widgets["menubar1"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST, DRAG_ACTION)
widgets["box2"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST, DRAG_ACTION)
widgets["perspectives_notebook"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST, DRAG_ACTION)
# Init 'minor' dialogs
# Log dialog
if log_viewer:
from pychess.widgets import LogDialog
LogDialog.add_destroy_notify(
lambda: widgets["log_viewer1"].set_active(0))
else:
widgets["log_viewer1"].set_property('sensitive', False)
# About dialog
self.aboutdialog = widgets["aboutdialog1"]
self.aboutdialog.set_program_name(NAME)
self.aboutdialog.set_copyright("Copyright © 2006-2018")
self.aboutdialog.set_version(VERSION_NAME + " " + VERSION)
if os.path.isdir(prefix.addDataPrefix(".git")):
try:
label = subprocess.check_output(["git", "describe"])
except subprocess.CalledProcessError:
label = ""
if label:
comments = self.aboutdialog.get_comments()
self.git_rev = label
self.aboutdialog.set_comments("git %s\n%s" %
(self.git_rev, comments))
with open(prefix.addDataPrefix("ARTISTS"), encoding="utf-8") as f:
self.aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS"), encoding="utf-8") as f:
self.aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS"), encoding="utf-8") as f:
self.aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS"), encoding="utf-8") as f:
self.aboutdialog.set_translator_credits(f.read())
with open(prefix.addDataPrefix("LICENSE"), encoding="utf-8") as f:
self.aboutdialog.set_license(f.read())
widgets["load_recent_game1"].set_submenu(recent_menu)
if conf.get("autoLogin"):
internet_game_tasker.connectClicked(None)
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow", self.dialog, defaultSize=(1, 500))
# Put engines into tree store
allstore = Gtk.ListStore(Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(allstore)
self.tv.append_column(Gtk.TreeViewColumn(
"Flag", Gtk.CellRendererPixbuf(), pixbuf=0))
name_renderer = Gtk.CellRendererText()
name_renderer.set_property("editable", True)
self.tv.append_column(Gtk.TreeViewColumn("Name", name_renderer, text=1))
def name_edited(renderer, path, new_name):
if self.cur_engine is not None:
old_name = self.cur_engine
if new_name and new_name != old_name:
names = [engine["name"] for engine in discoverer.getEngines()]
if new_name not in names:
engine = discoverer.getEngineByName(self.cur_engine)
engine["name"] = new_name
discoverer.save()
self.cur_engine = new_name
update_store()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
name_renderer.connect("edited", name_edited)
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
cell = Gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = Gtk.ListStore(str, GObject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(Gtk.TreeViewColumn(
"Option", Gtk.CellRendererText(), text=0))
optv.append_column(Gtk.TreeViewColumn(
"Data", KeyValueCellRenderer(self.options_store), data=1))
def update_options(*args):
if self.cur_engine is not None:
engines = discoverer.getEngines()
names = [engine["name"] for engine in engines]
# After deleting an engine we will select first
if self.cur_engine not in names:
self.cur_engine = engines[0]["name"]
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
self.options_store.clear()
for option in options:
key = option["name"]
val = option
if option["type"] != "button":
val["default"] = option.get("default")
val["value"] = option.get("value", val["default"])
self.options_store.append([key, val])
def update_store(*args):
newGameDialog.createPlayerUIGlobals(discoverer)
engine_names = [row[1] for row in allstore]
new_items = []
# don't add the very first (Human) player to engine store
for item in newGameDialog.playerItems[0][1:]:
if item[1] not in engine_names:
new_items.append(item)
iter = None
for item in new_items:
iter = allstore.append(item)
if iter is not None:
ts = self.tv.get_selection()
ts.select_iter(iter)
update_options()
update_store()
def do_update_store(*args):
GLib.idle_add(update_store)
discoverer.connect_after("engine_discovered", do_update_store)
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
engine = discoverer.getEngineByName(self.cur_engine)
discoverer.removeEngine(self.cur_engine)
discoverer.save()
selection = self.tv.get_selection()
result = selection.get_selected()
if result is not None:
model, iter = result
model.remove(iter)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = Gtk.FileChooserDialog(_("Select engine"), None, Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK))
filter = Gtk.FileFilter()
filter.set_name(_("Executable files"))
filter.add_mime_type("application/x-executable")
filter.add_mime_type("application/x-ms-dos-executable")
filter.add_mime_type("application/x-msdownload")
filter.add_pattern("*.exe")
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = searchPath(vm_name, access=os.R_OK|os.X_OK)
if vmpath is None:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("wine not installed"))
d.run()
d.hide()
new_engine = ""
else:
vmpath += " "
else:
vm_name = None
vmpath = ""
if new_engine:
try:
# Some engines support CECP and UCI, but variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True for e in variant_engines if e in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
ok = checker(vmpath + new_engine)
if ok:
uci = checker is is_uci
break
else:
continue
if not ok:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
engine_chooser_dialog.hide()
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
discoverer.addEngine(binname, new_engine, protocol, vm_name)
self.cur_engine = binname
self.add = False
discoverer.discover()
except:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
discoverer.save()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = Gtk.FileChooserDialog(_("Select working directory"), None, Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK))
dir_chooser_button = Gtk.FileChooserButton.new_with_dialog(dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
discoverer.save()
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active==0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
engine_command = engine_chooser_dialog.get_filename()
# is the new protocol supported by the engine?
if new_protocol == "uci":
ok = is_uci(engine_command)
else:
ok = is_cecp(engine_command)
if ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
discoverer.discover()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(0 if old_protocol=="uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed", protocol_changed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, iter = self.tv.get_selection().get_selected()
if iter:
self.selection = True
path = store.get_path(iter)
indices = path.get_indices()
row = indices[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
self.widgets['copy_engine_button'].set_sensitive(True)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
d = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(d)
self.widgets["engine_protocol_combo"].set_active(0 if engine["protocol"]=="uci" else 1)
update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0,))
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow", self.dialog, defaultSize=(600, 500))
# Put engines into tree store
allstore = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(allstore)
self.tv.append_column(gtk.TreeViewColumn(
"Flag", gtk.CellRendererPixbuf(), pixbuf=0))
name_renderer = gtk.CellRendererText()
name_renderer.set_property("editable", True)
self.tv.append_column(gtk.TreeViewColumn("Name", name_renderer, text=1))
def name_edited(renderer, path, new_name):
if self.cur_engine is not None:
old_name = self.cur_engine
if new_name and new_name != old_name:
names = [engine["name"] for engine in discoverer.getEngines()]
if new_name not in names:
engine = discoverer.getEngineByName(self.cur_engine)
engine["name"] = new_name
discoverer.save()
self.cur_engine = new_name
update_store()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
name_renderer.connect("edited", name_edited)
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
cell = gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = gtk.ListStore(str, gobject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(gtk.TreeViewColumn(
"Option", gtk.CellRendererText(), text=0))
optv.append_column(gtk.TreeViewColumn(
"Data", KeyValueCellRenderer(self.options_store), data=1))
def update_options(*args):
if self.cur_engine is not None:
engines = discoverer.getEngines()
names = [engine["name"] for engine in engines]
# After deleting an engine we will select first
if self.cur_engine not in names:
self.cur_engine = engines[0]["name"]
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
self.options_store.clear()
for option in options:
key = option["name"]
val = option
if option["type"] != "button":
val["default"] = option.get("default")
val["value"] = option.get("value", val["default"])
self.options_store.append([key, val])
def update_store(*args):
allstore.clear()
newGameDialog.createPlayerUIGlobals(discoverer)
# don't add the very first (Human) player to engine store
for item in newGameDialog.playerItems[0][1:]:
allstore.append(item)
update_options()
update_store()
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
engine = discoverer.getEngineByName(self.cur_engine)
discoverer.removeEngine(self.cur_engine)
discoverer.save()
update_store(discoverer)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
ts = self.tv.get_selection()
ts.select_path((0,))
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = gtk.FileChooserDialog(_("Select engine"), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
filter = gtk.FileFilter()
filter.set_name(_("Chess engines"))
filter.add_mime_type("application/x-executable")
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == gtk.RESPONSE_OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine:
try:
uci = is_uci(new_engine)
if not uci:
if not is_cecp(new_engine):
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
print "Maybe not a chess engine"
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_name_entry"].set_text(binname)
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
name = self.widgets["engine_name_entry"].get_text().strip()
active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if active==0 else "xboard"
discoverer.addEngine(name, new_engine, protocol)
self.cur_engine = name
glock_connect_after(discoverer, "engine_discovered", update_store)
self.add = False
discoverer.start()
except:
print "There is something wrong with this executable"
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
discoverer.save()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = gtk.FileChooserDialog(_("Select working directory"), None, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dir_chooser_button = gtk.FileChooserButton(dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
discoverer.save()
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active==0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
engine_command = engine_chooser_dialog.get_filename()
# is the new protocol supported by the engine?
if new_protocol == "uci":
ok = is_uci(engine_command)
else:
ok = is_cecp(engine_command)
if ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
glock_connect_after(discoverer, "engine_discovered", update_options)
discoverer.start()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(0 if old_protocol=="uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed", protocol_changed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, iter = self.tv.get_selection().get_selected()
if iter:
self.selection = True
row = store.get_path(iter)[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
self.widgets['copy_engine_button'].set_sensitive(True)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
d = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(d)
self.widgets["engine_protocol_combo"].set_active(0 if engine["protocol"]=="uci" else 1)
update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0,))
def initGlade(self, log_viewer):
# Init glade and the 'GladeHandlers'
widgets = uistuff.GladeWidgets("PyChess.glade")
widgets.getGlade().connect_signals(GladeHandlers())
tasker = TaskerManager()
new_game_tasker, internet_game_tasker = NewGameTasker(
), InternetGameTasker()
tasker.packTaskers(new_game_tasker, internet_game_tasker)
widgets["Background"].add(tasker)
# Redirect widgets
gamewidget.setWidgets(widgets)
# Main.py still needs a minimum of information
ionest.handler.connect("gmwidg_created",
GladeHandlers.__dict__["on_gmwidg_created"])
# The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode", first_value=True)
uistuff.keep(widgets["spy_mode"], "spy_mode", first_value=True)
uistuff.keep(widgets["show_sidepanels"],
"show_sidepanels",
first_value=True)
uistuff.keep(widgets["auto_call_flag"],
"autoCallFlag",
first_value=True)
# Show main window and init d'n'd
widgets["window1"].set_title('%s - PyChess' % _('Welcome'))
widgets["window1"].connect("delete-event",
GladeHandlers.__dict__["on_quit1_activate"])
widgets["window1"].connect(
"key-press-event", GladeHandlers.__dict__["on_window_key_press"])
uistuff.keepWindowSize("main", widgets["window1"], None,
POSITION_GOLDEN)
widgets["window1"].show()
widgets["Background"].show_all()
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
widgets["menubar1"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST, DRAG_ACTION)
widgets["Background"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST, DRAG_ACTION)
# Init 'minor' dialogs
# Log dialog
if log_viewer:
from pychess.widgets import LogDialog
LogDialog.add_destroy_notify(
lambda: widgets["log_viewer1"].set_active(0))
else:
widgets["log_viewer1"].set_property('sensitive', False)
# About dialog
self.aboutdialog = widgets["aboutdialog1"]
self.aboutdialog.set_program_name(NAME)
self.aboutdialog.set_copyright("Copyright © 2006-2016")
self.aboutdialog.set_version(VERSION_NAME + " " + VERSION)
if os.path.isdir(prefix.addDataPrefix(".git")):
try:
label = subprocess.check_output(["git", "describe"])
except subprocess.CalledProcessError:
label = ""
if label:
comments = self.aboutdialog.get_comments()
self.git_rev = label
self.aboutdialog.set_comments("git %s\n%s" %
(self.git_rev, comments))
with open(prefix.addDataPrefix("ARTISTS"), encoding="utf-8") as f:
self.aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS"), encoding="utf-8") as f:
self.aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS"), encoding="utf-8") as f:
self.aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS"), encoding="utf-8") as f:
self.aboutdialog.set_translator_credits(f.read())
with open(prefix.addDataPrefix("LICENSE"), encoding="utf-8") as f:
self.aboutdialog.set_license(f.read())
# RecentChooser
def recent_item_activated(self):
uri = self.get_current_uri()
try:
urlopen(unquote(uri)).close()
newGameDialog.LoadFileExtension.run(self.get_current_uri())
except (IOError, OSError):
# shomething wrong whit the uri
recentManager.remove_item(uri)
self.menu_recent = Gtk.RecentChooserMenu()
self.menu_recent.set_show_tips(True)
self.menu_recent.set_sort_type(Gtk.RecentSortType.MRU)
self.menu_recent.set_limit(10)
self.menu_recent.set_name("menu_recent")
self.file_filter = Gtk.RecentFilter()
self.file_filter.add_mime_type("application/x-chess-pgn")
self.menu_recent.set_filter(self.file_filter)
self.menu_recent.connect("item-activated", recent_item_activated)
widgets["load_recent_game1"].set_submenu(self.menu_recent)
# Discoverer dialog
def discovering_started(discoverer, binnames):
GLib.idle_add(DiscovererDialog.show, discoverer,
widgets["window1"], binnames)
discoverer.connect("discovering_started", discovering_started)
DiscovererDialog.init(discoverer)
discoverer.discover()
# Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
if conf.get("autoLogin", False):
internet_game_tasker.connectClicked(None)
def initGlade(self):
#=======================================================================
# Init glade and the 'GladeHandlers'
#=======================================================================
gtk.about_dialog_set_url_hook(self.website)
widgets = uistuff.GladeWidgets("PyChess.glade")
widgets.getGlade().connect_signals(GladeHandlers.__dict__)
tasker = TaskerManager()
tasker.packTaskers (NewGameTasker(), InternetGameTasker())
widgets["Background"].add(tasker)
#------------------------------------------------------ Redirect widgets
gamewidget.setWidgets(widgets)
def on_sensitive_changed (widget, prop):
name = widget.get_property('name')
sensitive = widget.get_property('sensitive')
#print "'%s' changed to '%s'" % (name, sensitive)
widgets['pause1'].connect("notify::sensitive", on_sensitive_changed)
widgets['resume1'].connect("notify::sensitive", on_sensitive_changed)
#-------------------------- Main.py still needs a minimum of information
ionest.handler.connect("gmwidg_created",
GladeHandlers.__dict__["on_gmwidg_created"])
#---------------------- The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode")
uistuff.keep(widgets["spy_mode"], "spy_mode")
uistuff.keep(widgets["show_sidepanels"], "show_sidepanels")
uistuff.keep(widgets["auto_call_flag"], "autoCallFlag")
#=======================================================================
# Show main window and init d'n'd
#=======================================================================
widgets["window1"].set_title('%s - PyChess' % _('Welcome'))
widgets["window1"].connect("key-press-event",
GladeHandlers.__dict__["on_window_key_press"])
uistuff.keepWindowSize("main", widgets["window1"], (575,479), POSITION_GOLDEN)
widgets["window1"].show()
widgets["Background"].show_all()
flags = DEST_DEFAULT_MOTION | DEST_DEFAULT_HIGHLIGHT | DEST_DEFAULT_DROP
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
widgets["menubar1"].drag_dest_set(flags, dnd_list, gtk.gdk.ACTION_COPY)
widgets["Background"].drag_dest_set(flags, dnd_list, gtk.gdk.ACTION_COPY)
# TODO: http://code.google.com/p/pychess/issues/detail?id=737
# The following two should really be set in the glade file
#widgets["menubar1"].set_events(widgets["menubar1"].get_events() | gtk.gdk.DRAG_STATUS)
#widgets["Background"].set_events(widgets["Background"].get_events() | gtk.gdk.DRAG_STATUS)
#=======================================================================
# Init 'minor' dialogs
#=======================================================================
#------------------------------------------------------------ Log dialog
LogDialog.add_destroy_notify(lambda: widgets["log_viewer1"].set_active(0))
#---------------------------------------------------------- About dialog
aboutdialog = widgets["aboutdialog1"]
clb = aboutdialog.get_child().get_children()[1].get_children()[2]
aboutdialog.set_name(NAME)
#aboutdialog.set_position(gtk.WIN_POS_CENTER)
#aboutdialog.set_website_label(_("PyChess Homepage"))
link = aboutdialog.get_website()
aboutdialog.set_copyright("Copyright © 2006-2013")
aboutdialog.set_version(VERSION_NAME+" "+VERSION)
if os.path.isdir(prefix.addDataPrefix(".hg")):
cmd = ["hg", "tip", "--cwd", prefix.getDataPrefix(), "--template", "{node|short} {date|isodate}"]
process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
out = process.stdout.readline().split()
if len(out)>=2:
comments = aboutdialog.get_comments()
self.hg_rev = out[0]
self.hg_date = out[1]
aboutdialog.set_comments("rev. %s\n%s\n%s" % (self.hg_rev, self.hg_date, comments))
with open(prefix.addDataPrefix("ARTISTS")) as f:
aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS")) as f:
aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS")) as f:
aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS")) as f:
aboutdialog.set_translator_credits(f.read())
def callback(button, *args):
aboutdialog.hide()
return True
clb.connect("activate", callback)
clb.connect("clicked", callback)
aboutdialog.connect("delete-event", callback)
#---------------------------------------------------- RecentChooser
def recent_item_activated (self):
uri = self.get_current_uri()
try:
urllib.urlopen(uri).close()
newGameDialog.LoadFileExtension.run(self.get_current_uri())
except (IOError, OSError):
#shomething wrong whit the uri
recentManager.remove_item(uri)
self.menu_recent = gtk.RecentChooserMenu(recentManager)
self.menu_recent.set_show_tips(True)
self.menu_recent.set_sort_type(gtk.RECENT_SORT_MRU)
self.menu_recent.set_limit(10)
self.menu_recent.set_name("menu_recent")
self.file_filter = gtk.RecentFilter()
self.file_filter.add_mime_type("application/x-chess-pgn")
self.menu_recent.set_filter(self.file_filter)
self.menu_recent.connect("item-activated", recent_item_activated)
widgets["load_recent_game1"].set_submenu(self.menu_recent)
#----------------------------------------------------- Discoverer dialog
def discovering_started (discoverer, binnames):
gobject.idle_add(DiscovererDialog.show, discoverer, widgets["window1"])
discoverer.connect("discovering_started", discovering_started)
DiscovererDialog.init(discoverer)
discoverer.start()
#------------------------------------------------- Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow", self.dialog)
# Put engines into tree store
allstore = Gtk.ListStore(Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(allstore)
self.tv.append_column(Gtk.TreeViewColumn("Flag",
Gtk.CellRendererPixbuf(),
pixbuf=0))
name_renderer = Gtk.CellRendererText()
name_renderer.set_property("editable", False)
self.tv.append_column(Gtk.TreeViewColumn("Name",
name_renderer,
text=1))
def name_edited(renderer, path, new_name):
if self.cur_engine is not None:
old_name = self.cur_engine
if new_name and new_name != old_name:
names = [engine["name"]
for engine in discoverer.getEngines()]
if new_name not in names:
engine = discoverer.getEngineByName(self.cur_engine)
engine["name"] = new_name
discoverer.save()
self.cur_engine = new_name
update_store()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
name_renderer.connect("edited", name_edited)
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
protocol_combo.set_name("engine_protocol_combo")
cell = Gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = Gtk.ListStore(str, GObject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(Gtk.TreeViewColumn("Option",
Gtk.CellRendererText(),
text=0))
optv.append_column(Gtk.TreeViewColumn("Data",
KeyValueCellRenderer(
self.options_store),
data=1))
def update_options(*args):
if self.cur_engine is not None:
engines = discoverer.getEngines()
names = [engine["name"] for engine in engines]
# After deleting an engine we will select first
if self.cur_engine not in names:
self.cur_engine = engines[0]["name"]
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
self.options_store.clear()
if options:
options.sort(key=lambda obj: obj['name'].lower() if 'name' in obj else '')
for option in options:
key = option["name"]
val = option
if option["type"] != "button":
val["default"] = option.get("default")
val["value"] = option.get("value", val["default"])
self.options_store.append([key, val])
def update_store(*args):
newGameDialog.createPlayerUIGlobals(discoverer)
engine_names = [row[1] for row in allstore]
new_items = []
# don't add the very first (Human) player to engine store
for item in newGameDialog.allEngineItems:
if item[1] not in engine_names:
new_items.append(item)
ts_iter = None
for item in new_items:
ts_iter = allstore.append(item)
if ts_iter is not None:
text_select = self.tv.get_selection()
text_select.select_iter(ts_iter)
update_options()
update_store()
def do_update_store(*args):
GLib.idle_add(update_store)
discoverer.connect_after("engine_discovered", do_update_store)
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
# engine = discoverer.getEngineByName(self.cur_engine)
discoverer.removeEngine(self.cur_engine)
discoverer.save()
selection = self.tv.get_selection()
result = selection.get_selected()
if result is not None:
model, ts_iter = result
model.remove(ts_iter)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = Gtk.FileChooserDialog(
_("Select engine"), mainwindow(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
filter = Gtk.FileFilter()
filter.set_name(_("Executable files"))
filter.add_mime_type("application/x-executable")
filter.add_mime_type("application/x-sharedlib")
filter.add_mime_type("application/x-ms-dos-executable")
filter.add_mime_type("application/x-msdownload")
filter.add_pattern("*.exe")
for vm in VM_LIST:
filter.add_pattern("*%s" % vm.ext)
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
vm_name = None
vm_args = None
vmpath = ""
if new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("wine not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
for vm in VM_LIST:
ext = os.path.splitext(new_engine)[1]
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>%s is not marked executable in the filesystem</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command.append(vm_args)
engine_command.append(new_engine)
# Some engines support CECP and UCI, but main variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True
for eng in variant_engines
if eng in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(engine[
"command"])
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_(
"There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
binname = os.path.split(new_engine)[1]
for eng in discoverer.getEngines():
if eng["name"] == binname:
binname = eng["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
if vm_args is not None:
vm_args = vm_args.split(",")
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol, vm_name, vm_args, "unknown")
self.cur_engine = binname
self.add = False
discoverer.discover()
except Exception:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_(
"There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
# vm args
################################################################
def vm_args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["vm_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("vm_args")
if new_args != old_args:
engine["vm_args"] = new_args.split()
discoverer.save()
self.widgets["vm_args_entry"].connect("changed", vm_args_changed)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
discoverer.save()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = Gtk.FileChooserDialog(
_("Select working directory"), mainwindow(),
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
dir_chooser_button = Gtk.FileChooserButton.new_with_dialog(
dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
discoverer.save()
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active == 0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
command = engine.get("command")
engine_command = []
vm_command = engine.get("vm_command")
if vm_command is not None:
engine_command.append(vm_command)
vm_args = engine.get("vm_args")
if vm_args is not None:
engine_command.append(", ".join(vm_args))
engine_command.append(command)
# is the new protocol supported by the engine?
if new_protocol == "uci":
check_ok = is_uci(engine_command)
else:
check_ok = is_cecp(engine_command)
if check_ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
discoverer.discover()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(
0 if old_protocol == "uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed",
protocol_changed)
################################################################
# engine country
################################################################
def country_changed(widget):
if self.cur_engine is not None and not self.selection:
engine = discoverer.getEngineByName(self.cur_engine)
old_country = discoverer.getCountry(engine)
new_country = ISO3166_LIST[widget.get_active()].iso2
if old_country != new_country:
engine["country"] = new_country
discoverer.save()
# Refresh the flag in the tree view
path = addDataPrefix("flags/%s.png" % new_country)
if not os.path.isfile(path):
path = addDataPrefix("flags/unknown.png")
item = self.tv.get_selection().get_selected()
if item is not None:
model, ts_iter = item
model[ts_iter][0] = get_pixbuf(path)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["engine_country_combo"].connect("changed", country_changed)
def country_keypressed(widget, event):
idx = 0
for iso in ISO3166_LIST:
if (idx != 0) and ((ord(iso.country[0].lower()) == event.keyval) or
(ord(iso.country[0].upper()) == event.keyval)):
widget.set_active(idx)
break
idx += 1
self.widgets["engine_country_combo"].connect("key-press-event", country_keypressed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, tv_iter = self.tv.get_selection().get_selected()
if tv_iter:
self.selection = True
path = store.get_path(tv_iter)
indices = path.get_indices()
row = indices[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
self.widgets['copy_engine_button'].set_sensitive(True)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
vm = engine.get("vm_command")
self.widgets["vm_command_entry"].set_text(vm if vm is not None else "")
args = [] if engine.get("vm_args") is None else engine.get("vm_args")
self.widgets["vm_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
dir_choice = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(dir_choice)
self.widgets["engine_protocol_combo"].set_active(0 if engine["protocol"] == "uci" else 1)
self.widgets["engine_country_combo"].set_active(0)
country = discoverer.getCountry(engine)
idx = 0
for iso in ISO3166_LIST:
if iso.iso2 == country:
self.widgets["engine_country_combo"].set_active(idx)
break
idx += 1
update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0, ))
selection_changed(tree_selection)
################################################################
# restore the default options of the engine
################################################################
def engine_default_options(button):
if self.cur_engine is not None and not self.selection:
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
dialog = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(_("Do you really want to restore the default options of the engine ?"))
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
for option in options:
if "default" in option:
option["value"] = option["default"]
discoverer.save()
update_options()
self.widgets["engine_default_options_button"].connect("clicked", engine_default_options)
def initGlade(self, log_viewer):
# Init glade and the 'GladeHandlers'
widgets = uistuff.GladeWidgets("PyChess.glade")
widgets.getGlade().connect_signals(GladeHandlers())
tasker = TaskerManager()
new_game_tasker, internet_game_tasker = NewGameTasker(
), InternetGameTasker()
tasker.packTaskers(new_game_tasker, internet_game_tasker)
widgets["Background"].add(tasker)
# Redirect widgets
gamewidget.setWidgets(widgets)
# Main.py still needs a minimum of information
game_handler.connect("gmwidg_created", self.on_gmwidg_created)
# The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode", first_value=True)
uistuff.keep(widgets["spy_mode"], "spy_mode", first_value=True)
uistuff.keep(widgets["show_sidepanels"],
"show_sidepanels",
first_value=True)
uistuff.keep(widgets["auto_call_flag"],
"autoCallFlag",
first_value=True)
# Show main window and init d'n'd
widgets["window1"].set_title('%s - PyChess' % _('Welcome'))
widgets["window1"].connect("delete-event",
GladeHandlers.__dict__["on_quit1_activate"])
widgets["window1"].connect(
"key-press-event", GladeHandlers.__dict__["on_window_key_press"])
uistuff.keepWindowSize("main", widgets["window1"], None,
POSITION_GOLDEN)
widgets["window1"].show()
widgets["Background"].show_all()
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
widgets["menubar1"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST,
DRAG_ACTION)
widgets["Background"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST,
DRAG_ACTION)
# Init 'minor' dialogs
# Log dialog
if log_viewer:
from pychess.widgets import LogDialog
LogDialog.add_destroy_notify(
lambda: widgets["log_viewer1"].set_active(0))
else:
widgets["log_viewer1"].set_property('sensitive', False)
# About dialog
self.aboutdialog = widgets["aboutdialog1"]
self.aboutdialog.set_program_name(NAME)
self.aboutdialog.set_copyright("Copyright © 2006-2016")
self.aboutdialog.set_version(VERSION_NAME + " " + VERSION)
if os.path.isdir(prefix.addDataPrefix(".git")):
try:
label = subprocess.check_output(["git", "describe"])
except subprocess.CalledProcessError:
label = ""
if label:
comments = self.aboutdialog.get_comments()
self.git_rev = label
self.aboutdialog.set_comments("git %s\n%s" %
(self.git_rev, comments))
with open(prefix.addDataPrefix("ARTISTS"), encoding="utf-8") as f:
self.aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS"), encoding="utf-8") as f:
self.aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS"), encoding="utf-8") as f:
self.aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS"), encoding="utf-8") as f:
self.aboutdialog.set_translator_credits(f.read())
with open(prefix.addDataPrefix("LICENSE"), encoding="utf-8") as f:
self.aboutdialog.set_license(f.read())
# RecentChooser
def recent_item_activated(self):
uri = self.get_current_uri()
try:
urlopen(unquote(uri)).close()
newGameDialog.LoadFileExtension.run(self.get_current_uri())
except (IOError, OSError):
# shomething wrong whit the uri
recentManager.remove_item(uri)
self.menu_recent = Gtk.RecentChooserMenu()
self.menu_recent.set_show_tips(True)
self.menu_recent.set_sort_type(Gtk.RecentSortType.MRU)
self.menu_recent.set_limit(10)
self.menu_recent.set_name("menu_recent")
self.file_filter = Gtk.RecentFilter()
self.file_filter.add_mime_type("application/x-chess-pgn")
self.menu_recent.set_filter(self.file_filter)
self.menu_recent.connect("item-activated", recent_item_activated)
widgets["load_recent_game1"].set_submenu(self.menu_recent)
# Discoverer dialog
def discovering_started(discoverer, binnames):
GLib.idle_add(DiscovererDialog.show, discoverer,
widgets["window1"], binnames)
discoverer.connect("discovering_started", discovering_started)
DiscovererDialog.init(discoverer)
discoverer.discover()
# Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
if conf.get("autoLogin", False):
internet_game_tasker.connectClicked(None)
def initGlade(self, log_viewer):
# Init glade and the 'GladeHandlers'
self.widgets = widgets = uistuff.GladeWidgets("PyChess.glade")
self.glade_handlers = GladeHandlers(self)
widgets.getGlade().connect_signals(self.glade_handlers)
self.window = widgets["main_window"]
# new_game_tasker, internet_game_tasker = NewGameTasker(
# ), InternetGameTasker()
# tasker.packTaskers(new_game_tasker, internet_game_tasker)
# widgets["Background"].add(tasker)
# Redirect widgets
gamewidget.setWidgets(widgets)
# The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode")
uistuff.keep(widgets["spy_mode"], "spy_mode")
uistuff.keep(widgets["show_sidepanels"], "show_sidepanels")
uistuff.keep(widgets["auto_call_flag"], "autoCallFlag")
# Show main window and init d'n'd
widgets["main_window"].set_title('%s - PyChess' % _('Welcome'))
widgets["main_window"].connect("delete-event",
self.glade_handlers.on_quit1_activate)
widgets["main_window"].connect("key-press-event",
self.glade_handlers.on_window_key_press)
uistuff.keepWindowSize("main", widgets["main_window"], None,
uistuff.POSITION_GOLDEN)
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
widgets["menubar1"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST,
DRAG_ACTION)
widgets["box2"].drag_dest_set(Gtk.DestDefaults.ALL, DND_LIST,
DRAG_ACTION)
widgets["perspectives_notebook"].drag_dest_set(Gtk.DestDefaults.ALL,
DND_LIST, DRAG_ACTION)
# Init 'minor' dialogs
# Log dialog
if log_viewer:
from pychess.widgets import LogDialog
LogDialog.add_destroy_notify(
lambda: widgets["log_viewer1"].set_active(0))
else:
widgets["log_viewer1"].set_property('sensitive', False)
# About dialog
self.aboutdialog = widgets["aboutdialog1"]
self.aboutdialog.set_program_name(NAME)
self.aboutdialog.set_copyright("Copyright © 2006-2020")
self.aboutdialog.set_version(VERSION_NAME + " " + VERSION)
if isgit():
try:
self.git_rev = subprocess.check_output(
["git", "describe", "--tags"]).decode().strip()
self.aboutdialog.set_version('%s Git %s' %
(VERSION_NAME, self.git_rev))
except subprocess.CalledProcessError:
pass
self.aboutdialog.set_comments(self.aboutdialog.get_comments())
with open(prefix.addDataPrefix("ARTISTS"), encoding="utf-8") as f:
self.aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS"), encoding="utf-8") as f:
self.aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS"), encoding="utf-8") as f:
self.aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS"), encoding="utf-8") as f:
self.aboutdialog.set_translator_credits(f.read())
with open(prefix.addDataPrefix("LICENSE"), encoding="utf-8") as f:
self.aboutdialog.set_license(f.read())
widgets["load_recent_game1"].set_submenu(recent_menu)
if conf.get("autoLogin"):
internet_game_tasker.connectClicked(None)
def initGlade(self, log_viewer):
#=======================================================================
# Init glade and the 'GladeHandlers'
#=======================================================================
#Gtk.about_dialog_set_url_hook(self.website)
widgets = uistuff.GladeWidgets("PyChess.glade")
widgets.getGlade().connect_signals(GladeHandlers())
tasker = TaskerManager()
tasker.packTaskers(NewGameTasker(), InternetGameTasker())
widgets["Background"].add(tasker)
#------------------------------------------------------ Redirect widgets
gamewidget.setWidgets(widgets)
def on_sensitive_changed(widget, prop):
name = widget.get_property('name')
sensitive = widget.get_property('sensitive')
#print "'%s' changed to '%s'" % (name, sensitive)
widgets['pause1'].connect("notify::sensitive", on_sensitive_changed)
widgets['resume1'].connect("notify::sensitive", on_sensitive_changed)
#-------------------------- Main.py still needs a minimum of information
ionest.handler.connect("gmwidg_created",
GladeHandlers.__dict__["on_gmwidg_created"])
#---------------------- The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode", first_value=True)
uistuff.keep(widgets["spy_mode"], "spy_mode", first_value=True)
uistuff.keep(widgets["show_sidepanels"],
"show_sidepanels",
first_value=True)
uistuff.keep(widgets["auto_call_flag"],
"autoCallFlag",
first_value=True)
#=======================================================================
# Show main window and init d'n'd
#=======================================================================
widgets["window1"].set_title('%s - PyChess' % _('Welcome'))
widgets["window1"].connect("delete-event",
GladeHandlers.__dict__["on_quit1_activate"])
widgets["window1"].connect(
"key-press-event", GladeHandlers.__dict__["on_window_key_press"])
uistuff.keepWindowSize("main", widgets["window1"], None,
POSITION_GOLDEN)
widgets["window1"].show()
widgets["Background"].show_all()
flags = Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
#widgets["menubar1"].drag_dest_set(flags, dnd_list, Gdk.DragAction.COPY)
#widgets["Background"].drag_dest_set(flags, dnd_list, Gdk.DragAction.COPY)
# TODO: http://code.google.com/p/pychess/issues/detail?id=737
# The following two should really be set in the glade file
#widgets["menubar1"].set_events(widgets["menubar1"].get_events() | Gdk.DRAG_STATUS)
#widgets["Background"].set_events(widgets["Background"].get_events() | Gdk.DRAG_STATUS)
#=======================================================================
# Init 'minor' dialogs
#=======================================================================
#------------------------------------------------------------ Log dialog
if log_viewer:
from pychess.widgets import LogDialog
LogDialog.add_destroy_notify(
lambda: widgets["log_viewer1"].set_active(0))
else:
widgets["log_viewer1"].set_property('sensitive', False)
#---------------------------------------------------------- About dialog
self.aboutdialog = widgets["aboutdialog1"]
self.aboutdialog.set_program_name(NAME)
link = self.aboutdialog.get_website()
self.aboutdialog.set_copyright("Copyright © 2006-2015")
self.aboutdialog.set_version(VERSION_NAME + " " + VERSION)
if os.path.isdir(prefix.addDataPrefix(".git")):
try:
label = subprocess.check_output(["git", "describe"])
except subprocess.CalledProcessError:
label = ""
if label:
comments = self.aboutdialog.get_comments()
self.git_rev = label
self.aboutdialog.set_comments("git %s\n%s" %
(self.git_rev, comments))
with open(prefix.addDataPrefix("ARTISTS"), encoding="utf-8") as f:
self.aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS"), encoding="utf-8") as f:
self.aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS"), encoding="utf-8") as f:
self.aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS"), encoding="utf-8") as f:
self.aboutdialog.set_translator_credits(f.read())
def on_about_response(dialog, response, *args):
# system-defined GtkDialog responses are always negative, in which
# case we want to hide it
if response < 0:
self.aboutdialog.hide()
self.aboutdialog.emit_stop_by_name('response')
def on_about_close(widget, event=None):
self.aboutdialog.hide()
return True
self.aboutdialog.connect("response", on_about_response)
self.aboutdialog.connect("close", on_about_close)
self.aboutdialog.connect("delete-event", on_about_close)
#---------------------------------------------------- RecentChooser
def recent_item_activated(self):
uri = self.get_current_uri()
try:
urlopen(unquote(uri)).close()
newGameDialog.LoadFileExtension.run(self.get_current_uri())
except (IOError, OSError):
#shomething wrong whit the uri
recentManager.remove_item(uri)
#self.menu_recent = Gtk.RecentChooserMenu(recentManager)
self.menu_recent = Gtk.RecentChooserMenu()
self.menu_recent.set_show_tips(True)
self.menu_recent.set_sort_type(Gtk.RecentSortType.MRU)
self.menu_recent.set_limit(10)
self.menu_recent.set_name("menu_recent")
self.file_filter = Gtk.RecentFilter()
self.file_filter.add_mime_type("application/x-chess-pgn")
self.menu_recent.set_filter(self.file_filter)
self.menu_recent.connect("item-activated", recent_item_activated)
widgets["load_recent_game1"].set_submenu(self.menu_recent)
#----------------------------------------------------- Discoverer dialog
def discovering_started(discoverer, binnames):
GLib.idle_add(DiscovererDialog.show, discoverer,
widgets["window1"], binnames)
discoverer.connect("discovering_started", discovering_started)
DiscovererDialog.init(discoverer)
discoverer.discover()
#------------------------------------------------- Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow", self.dialog)
# Put engines into tree store
self.allstore = Gtk.ListStore(Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(self.allstore)
self.tv.append_column(Gtk.TreeViewColumn("Flag", Gtk.CellRendererPixbuf(), pixbuf=0))
name_renderer = Gtk.CellRendererText()
name_renderer.set_property("editable", False)
self.tv.append_column(Gtk.TreeViewColumn("Name", name_renderer, text=1))
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
protocol_combo.set_name("engine_protocol_combo")
cell = Gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = Gtk.ListStore(str, str, GObject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(Gtk.TreeViewColumn(" ", Gtk.CellRendererText(), text=0))
optv.append_column(Gtk.TreeViewColumn(_("Option"), Gtk.CellRendererText(), text=1))
optv.append_column(Gtk.TreeViewColumn(_("Value"), KeyValueCellRenderer(self.options_store), data=2))
self.update_store()
def do_update_store(self, *args):
GLib.idle_add(engine_dialog.update_store)
discoverer.connect_after("engine_discovered", do_update_store)
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
discoverer.removeEngine(self.cur_engine)
selection = self.tv.get_selection()
result = selection.get_selected()
if result is not None:
model, ts_iter = result
model.remove(ts_iter)
if model.iter_n_children() == 0:
clearView()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = Gtk.FileChooserDialog(
_("Select engine"), mainwindow(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
filter = Gtk.FileFilter()
filter.set_name(_("Executable files"))
filter.add_mime_type("application/x-executable")
filter.add_mime_type("application/x-sharedlib")
filter.add_mime_type("application/x-ms-dos-executable")
filter.add_mime_type("application/x-msdownload")
filter.add_pattern("*.exe")
for vm in VM_LIST:
filter.add_pattern("*%s" % vm.ext)
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
binname = os.path.split(new_engine)[1]
ext = os.path.splitext(new_engine)[1]
# Verify if the engine already exists under the same name
if new_engine != "":
for eng in discoverer.getEngines():
if eng["command"] == new_engine:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
msg_dia.format_secondary_text(_("The engine is already installed under the same name"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
# Detect the host application
if new_engine != "":
vm_name = None
vm_args = None
vmpath = ""
# Scripting
for vm in VM_LIST:
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
break
# Wine for Windows application under Linux
if vm_name is None and new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
# Check that the interpreter is available
if vm_name is not None:
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
msg_dia.format_secondary_text(vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
# Next checks
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>%s is not marked executable in the filesystem</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command.append(vm_args)
engine_command.append(new_engine)
# Search the engines based on the most expectable protocol
refeng = discoverer.getReferencedEngine(binname)
if refeng is not None and refeng["protocol"] == "xboard":
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
if vm_args is not None:
vm_args = vm_args.split(",")
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol, vm_name, vm_args)
self.cur_engine = binname
self.add = False
discoverer.discover()
except Exception:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
msg_dia.format_secondary_text(_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
def clearView():
self.selection = True
self.cur_engine = None
self.widgets["vm_command_entry"].set_text("")
self.widgets["vm_args_entry"].set_text("")
self.widgets["engine_command_entry"].set_text("")
self.widgets["engine_args_entry"].set_text("")
self.widgets["engine_protocol_combo"].set_active(0)
self.widgets["engine_country_combo"].set_active(0)
self.widgets["engine_comment_entry"].set_text("")
self.widgets["engine_level_scale"].set_value(defaultEngineLevel)
self.options_store.clear()
self.selection = False
################################################################
# vm args
################################################################
def vm_args_changed(widget):
if self.cur_engine is not None and not self.selection:
new_args = self.widgets["vm_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("vm_args")
if new_args != old_args:
engine["vm_args"] = new_args.split()
self.widgets["vm_args_entry"].connect("changed", vm_args_changed)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None and not self.selection:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = Gtk.FileChooserDialog(
_("Select working directory"), mainwindow(),
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
dir_chooser_button = Gtk.FileChooserButton.new_with_dialog(
dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active == 0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
command = engine.get("command")
engine_command = []
vm_command = engine.get("vm_command")
if vm_command is not None:
engine_command.append(vm_command)
vm_args = engine.get("vm_args")
if vm_args is not None:
engine_command.append(", ".join(vm_args))
engine_command.append(command)
# is the new protocol supported by the engine?
if new_protocol == "uci":
check_ok = is_uci(engine_command)
else:
check_ok = is_cecp(engine_command)
if check_ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
discoverer.discover()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(
0 if old_protocol == "uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed",
protocol_changed)
################################################################
# engine country
################################################################
def country_changed(widget):
if self.cur_engine is not None and not self.selection:
engine = discoverer.getEngineByName(self.cur_engine)
old_country = discoverer.getCountry(engine)
new_country = ISO3166_LIST[widget.get_active()].iso2
if old_country != new_country:
engine["country"] = new_country
# Refresh the flag in the tree view
path = addDataPrefix("flags/%s.png" % new_country)
if not os.path.isfile(path):
path = addDataPrefix("flags/unknown.png")
item = self.tv.get_selection().get_selected()
if item is not None:
model, ts_iter = item
model[ts_iter][0] = get_pixbuf(path)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["engine_country_combo"].connect("changed", country_changed)
def country_keypressed(widget, event):
idx = 0
for iso in ISO3166_LIST:
if (idx != 0) and ((ord(iso.country[0].lower()) == event.keyval) or
(ord(iso.country[0].upper()) == event.keyval)):
widget.set_active(idx)
break
idx += 1
self.widgets["engine_country_combo"].connect("key-press-event", country_keypressed)
################################################################
# comment changed
################################################################
def comment_changed(widget):
if self.cur_engine is not None and not self.selection:
new_comment = self.widgets["engine_comment_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_comment = engine.get("comment")
if new_comment != old_comment:
engine["comment"] = new_comment
self.widgets["engine_comment_entry"].connect("changed", comment_changed)
################################################################
# level changed
################################################################
def level_changed(widget):
if self.cur_engine is not None and not self.selection:
new_level = widget.get_value()
engine = discoverer.getEngineByName(self.cur_engine)
old_level = engine.get("level")
if new_level != old_level:
engine["level"] = int(new_level)
self.widgets["engine_level_scale"].connect("value-changed", level_changed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, tv_iter = self.tv.get_selection().get_selected()
if tv_iter:
self.selection = True
path = store.get_path(tv_iter)
indices = path.get_indices()
row = indices[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
vm = engine.get("vm_command")
self.widgets["vm_command_entry"].set_text(vm if vm is not None else "")
args = [] if engine.get("vm_args") is None else engine.get("vm_args")
self.widgets["vm_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
dir_choice = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(dir_choice)
self.widgets["engine_protocol_combo"].set_active(0 if engine["protocol"] == "uci" else 1)
self.widgets["engine_country_combo"].set_active(0)
country = discoverer.getCountry(engine)
idx = 0
for iso in ISO3166_LIST:
if iso.iso2 == country:
self.widgets["engine_country_combo"].set_active(idx)
break
idx += 1
comment = engine.get("comment")
self.widgets["engine_comment_entry"].set_text(comment if comment is not None else "")
level = engine.get("level")
try:
level = int(level) if level else defaultEngineLevel
except Exception:
level = defaultEngineLevel
self.widgets["engine_level_scale"].set_value(level)
self.update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0, ))
selection_changed(tree_selection)
################################################################
# restore the default options of the engine
################################################################
def engine_default_options(button):
if self.cur_engine is not None and not self.selection:
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
dialog = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(_("Do you really want to restore the default options of the engine ?"))
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
for option in options:
if "default" in option:
option["value"] = option["default"]
self.update_options()
self.widgets["engine_default_options_button"].connect("clicked", engine_default_options)
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow",
self.dialog,
defaultSize=(1, 500))
# Put engines into tree store
allstore = Gtk.ListStore(Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(allstore)
self.tv.append_column(
Gtk.TreeViewColumn("Flag", Gtk.CellRendererPixbuf(), pixbuf=0))
name_renderer = Gtk.CellRendererText()
name_renderer.set_property("editable", True)
self.tv.append_column(Gtk.TreeViewColumn("Name", name_renderer,
text=1))
def name_edited(renderer, path, new_name):
if self.cur_engine is not None:
old_name = self.cur_engine
if new_name and new_name != old_name:
names = [
engine["name"] for engine in discoverer.getEngines()
]
if new_name not in names:
engine = discoverer.getEngineByName(self.cur_engine)
engine["name"] = new_name
discoverer.save()
self.cur_engine = new_name
update_store()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
name_renderer.connect("edited", name_edited)
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
protocol_combo.set_name("engine_protocol_combo")
cell = Gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = Gtk.ListStore(str, GObject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(
Gtk.TreeViewColumn("Option", Gtk.CellRendererText(), text=0))
optv.append_column(
Gtk.TreeViewColumn("Data",
KeyValueCellRenderer(self.options_store),
data=1))
def update_options(*args):
if self.cur_engine is not None:
engines = discoverer.getEngines()
names = [engine["name"] for engine in engines]
# After deleting an engine we will select first
if self.cur_engine not in names:
self.cur_engine = engines[0]["name"]
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
self.options_store.clear()
for option in options:
key = option["name"]
val = option
if option["type"] != "button":
val["default"] = option.get("default")
val["value"] = option.get("value", val["default"])
self.options_store.append([key, val])
def update_store(*args):
newGameDialog.createPlayerUIGlobals(discoverer)
engine_names = [row[1] for row in allstore]
new_items = []
# don't add the very first (Human) player to engine store
for item in newGameDialog.playerItems[0][1:]:
if item[1] not in engine_names:
new_items.append(item)
ts_iter = None
for item in new_items:
ts_iter = allstore.append(item)
if ts_iter is not None:
text_select = self.tv.get_selection()
text_select.select_iter(ts_iter)
update_options()
update_store()
def do_update_store(*args):
GLib.idle_add(update_store)
discoverer.connect_after("engine_discovered", do_update_store)
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
# engine = discoverer.getEngineByName(self.cur_engine)
discoverer.removeEngine(self.cur_engine)
discoverer.save()
selection = self.tv.get_selection()
result = selection.get_selected()
if result is not None:
model, ts_iter = result
model.remove(ts_iter)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = Gtk.FileChooserDialog(
_("Select engine"), None, Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
filter = Gtk.FileFilter()
filter.set_name(_("Executable files"))
filter.add_mime_type("application/x-executable")
filter.add_mime_type("application/x-ms-dos-executable")
filter.add_mime_type("application/x-msdownload")
filter.add_pattern("*.exe")
for vm in VM_LIST:
filter.add_pattern("*%s" % vm.ext)
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
vm_name = None
vm_args = None
vmpath = ""
if new_engine.lower().endswith(
".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("wine not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
for vm in VM_LIST:
ext = os.path.splitext(new_engine)[1]
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(
new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>%s is not marked executable in the filesystem</b></big>"
% new_engine))
msg_dia.format_secondary_text(
_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command.append(vm_args)
engine_command.append(new_engine)
# Some engines support CECP and UCI, but main variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True for eng in variant_engines
if eng in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
msg_dia = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"
))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
binname = os.path.split(new_engine)[1]
for eng in discoverer.getEngines():
if eng["name"] == binname:
binname = eng["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
if vm_args is not None:
vm_args = vm_args.split(",")
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol,
vm_name, vm_args)
self.cur_engine = binname
self.add = False
discoverer.discover()
except:
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
# vm args
################################################################
def vm_args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["vm_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("vm_args")
if new_args != old_args:
engine["vm_args"] = new_args.split()
discoverer.save()
self.widgets["vm_args_entry"].connect("changed", vm_args_changed)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
discoverer.save()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = Gtk.FileChooserDialog(
_("Select working directory"), None,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
dir_chooser_button = Gtk.FileChooserButton.new_with_dialog(
dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
discoverer.save()
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active == 0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
command = engine.get("command")
engine_command = []
vm_command = engine.get("vm_command")
if vm_command is not None:
engine_command.append(vm_command)
vm_args = engine.get("vm_args")
if vm_args is not None:
engine_command.append(", ".join(vm_args))
engine_command.append(command)
# is the new protocol supported by the engine?
if new_protocol == "uci":
check_ok = is_uci(engine_command)
else:
check_ok = is_cecp(engine_command)
if check_ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
discoverer.discover()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(
0 if old_protocol == "uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed",
protocol_changed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, tv_iter = self.tv.get_selection().get_selected()
if tv_iter:
self.selection = True
path = store.get_path(tv_iter)
indices = path.get_indices()
row = indices[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
self.widgets['copy_engine_button'].set_sensitive(True)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(
engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
vm = engine.get("vm_command")
self.widgets["vm_command_entry"].set_text(
vm if vm is not None else "")
args = [] if engine.get("vm_args") is None else engine.get(
"vm_args")
self.widgets["vm_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
dir_choice = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(dir_choice)
self.widgets["engine_protocol_combo"].set_active(
0 if engine["protocol"] == "uci" else 1)
update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0, ))
def __init__(self):
self.widgets = uistuff.GladeWidgets("tipoftheday.glade")
self.widgets["window1"].set_transient_for(mainwindow())
uistuff.keepWindowSize("tipoftheday", self.widgets["window1"], (320, 240), uistuff.POSITION_CENTER)
self.widgets["checkbutton1"].set_active(conf.get("show_tip_at_startup"))
self.widgets["checkbutton1"].connect("toggled", lambda w: conf.set("show_tip_at_startup", w.get_active()))
self.widgets["close_button"].connect("clicked", lambda w: self.widgets["window1"].emit("delete-event", None))
self.widgets["window1"].connect("delete_event", lambda w, a: self.widgets["window1"].destroy())
self.widgets["back_button"].connect("clicked", lambda w: self.set_currentIndex(self.tips_curindex - 1))
self.widgets["forward_button"].connect("clicked", lambda w: self.set_currentIndex(self.tips_curindex + 1))
self.tips_fixed = 2
self.tips = [
# PyChess facts -- The first tips_fixed messages are always displayed first
_("PyChess is an open-source chess application that can be enhanced by any chess enthusiasts: bug reports, source code, documentation, translations, feature requests, user assistance... Let's get in touch at <b>http://www.pychess.org</b>"),
_("PyChess supports a wide range of chess engines, variants, Internet servers and lessons. It is a perfect desktop application to increase your chess skills very conveniently."),
_("The releases of PyChess hold the name of historical world chess champions. Do you know the name of the current world chess champion?"),
_("Do you know that you can help to translate PyChess into your language, <b>Help</b> > <b>Translate PyChess</b>."),
_("A game is made of an opening, a middle-game and an end-game. PyChess is able to train you thanks to its opening book, its supported chess engines and its training module."),
# Chess facts
_("Do you know that it is possible to finish a chess game in just 2 turns?"),
_("Do you know that a knight is better placed in the center of the board?"),
_("Do you know that moving the queen at the very beginning of a game does not offer any particular advantage?"),
_("Do you know that having two-colored bishops working together is very powerful?"),
_("Do you know that the rooks are generally engaged late in game?"),
_("Do you know that the king can move across two cells under certain conditions? This is called ""castling""."),
_("Do you know that the number of possible chess games exceeds the number of atoms in the Universe?"),
# General UI
_("You can start a new game by <b>Game</b> > <b>New Game</b>, then choose the <b>Players</b>, <b>Time Control</b> and <b>Chess Variants</b>."),
_("You can choose from 20 different difficulties to play against the computer. It will mainly affect the available time to think."),
_("The level 20 gives a full autonomy to the chess engine in managing its own time during the game."),
_("To save a game <b>Game</b> > <b>Save Game As</b>, give the filename and choose where you want to be saved. At the bottom choose extension type of the file, and <b>Save</b>."),
_("Calling the flag is the termination of the current game when the time of your opponent is over. If the clock is with you, click on the menu item <b>Actions</b> > <b>Call Flag</b> to claim the victory."),
_("Press <b>Ctrl+Z</b> to ask your opponent to rollback the last played move. Against a computer or for an unrated game, undoing is generally automatically accepted."),
_("To play on <b>Fullscreen mode</b>, just press the key <b>F11</b>. Press it again to exit this mode."),
_("Many sounds are emitted by PyChess while you are playing if you activate them in the preferences: <b>Settings</b> > <b>Preferences</b> > <b>Sound tab</b> > <b>Use sounds in PyChess</b>."),
_("Do you know that a game is generally finished after 20 to 40 moves per player? The estimated duration of a game is displayed when you configure a new game."),
_("The standard file format to manage chess games is <b>PGN</b>. It stands for ""Portable Game Notation"". Do not get confused with PNG which is a usual file format to store drawings and pictures."),
_("You can share a position by using the exchange format <b>FEN</b>, which stands for ""Forsyth-Edwards Notation"". This format is also adapted for the chess variants."),
# Analysis
_("You must define a chess engine in the preferences in order to use the local chess analysis. By default, PyChess recommends you to use the free engine named Stockfish which is renown to be the strongest engine in the world."),
_("<b>Hint mode</b> analyzes your game to show you the best current move. Enable it with the shortcut <b>Ctrl+H</b> from the menu <b>View</b>."),
_("<b>Spy mode</b> analyzes the threats, so the best move that your opponent would play as if it was his turn. Enable it with the shortcut <b>Ctrl+H</b> from the menu <b>View</b>."),
_("<b>Ponder</b> is an option available in some chess engines that allows thinking when it is not the turn of the engine. It will then consume more resources on your computer."),
_("<b>MultiPV</b> is an option of some chess engines that shows other possible good moves. They are displayed in the panel <b>Hints</b>. The value can be adapted from that panel with a double-click on the displayed figure."),
_("You cannot use the local chess analysis mode while you are playing an unterminated game over Internet. Else you would be a cheater."),
_("An evaluation of +2.3 is an advantage for White of more than 2 pawns, even if White and Black have the same number of pawns. The position of all the pieces and their mobility are some of the factors that contribute to the score."),
_("PyChess includes a chess engine that offers an evaluation for any chess position. Winning against PyChess engine is a coherent way to succeed in chess and improve your skills."),
_("The rating is your strength: 1500 is a good average player, 2000 is a national champion and 2800 is the best human chess champion. From the properties of the game in the menu <b>Game</b>, the difference of points gives you your chance to win and the projected evolution of your rating. If your rating is provisional, append a question mark '?' to your level, like ""1399?""."),
_("Several rating systems exist to evaluate your skills in chess. The most common one is ELO (from its creator Arpad Elo) established on 1970. Schematically, the concept is to engage +/- 20 points for a game and that you will win or lose proportionally to the difference of ELO points you have with your opponent."),
_("Each chess engine has its own evaluation function. It is normal to get different scores for a same position."),
# Opening book and EGDB
_("The opening book gives you the moves that are considered to be good from a theoretical perspective. You are free to play any other legal move."),
_("The <b>Gaviota tables</b> are precalculated positions that tell the final outcome of the current game in terms of win, loss or draw."),
_("Do you know that your computer is too small to store a 7-piece endgame database? That's why the Gaviota tablebase is limited to 5 pieces."),
_("A tablebase can be connected either to PyChess, or to a compatible chess engine."),
_("The <b>DTZ</b> is the ""distance to zero"", so the remaining possible moves to end into a tie as soon as possible."),
# Variant chess
_("The chess variants consist in changing the start position, the rules of the game, the types of the pieces... The gameplay is totally modified, so you must use dedicated chess engines to play against the computer."),
_("In Chess960, the lines of the main pieces are shuffled in a precise order. Therefore, you cannot use the booking book and you should change your tactical habits."),
_("When playing crazyhouse chess, the captured pieces change of ownership and can reappear on the board at a later turn."),
_("Suicide chess, giveaway chess or antichess are all the same variant: you must give your pieces to your opponent by forcing the captures like at draughts. The outcome of the game can change completely if you make an incorrect move."),
_("Playing horde in PyChess consists in destroying a flow of 36 white pawns with a normal set of black pieces."),
_("You might be interested in playing ""King of the hill"" if you target to place your king in the middle of the board, instead of protecting it in a corner of the board as usual."),
_("A lot of fun is offered by atomic chess that destroys all the surrounding main pieces at each capture move."),
_("The experienced chess players can use blind pieces by starting a new variant game."),
# Internet chess
_("You should sign up online to play on an Internet chess server, so that you can find your games later and see the evolution of your rating. In the preferences, PyChess still have the possibility to save your played games locally."),
_("The time compensation is a feature that doesn't waste your clock time because of the latency of your Internet connection. The module can be downloaded from the menu <b>Edit</b> > <b>Externals</b>."),
_("You can play against chess engines on an Internet chess server. Use the filter to include or exclude them from the available players."),
_("The communication with an Internet chess server is not standardized. Therefore you can only connect to the supported chess servers in PyChess, like freechess.org or chessclub.com"),
# Externals
_("PyChess uses the external module Scoutfish to evaluate the chess databases. For example, it is possible to extract the games where some pieces are in precise count or positions."),
_("Parser/ChessDB is an external module used by PyChess to show the expected outcome for a given position."),
_("SQLite is an internal module used to describe the loaded PGN files, so that PyChess can retrieve the games very fast during a search."),
_("PyChess generates 3 information files when a PGN file is opened : .sqlite (description), scout (positions), .bin (book and outcomes). These files can be removed manually if necessary."),
# Lessons
_("PyChess uses offline lessons to learn chess. You will be then never disappointed if you have no Internet connection."),
_("To start Learning, click on the <b>Book icon</b> available on the welcome screen. Or choose the category next to that button to start the activity directly."),
_("The <b>lectures</b> are commented games to learn step-by-step the strategy and principles of some chess techniques. Just watch and read."),
_("Whatever the number of pawns, an <b>end-game</b> starts when the board is made of certain main pieces : 1 rook vs 1 bishop, 1 queen versus 2 rooks, etc... Knowing the moves will help you to not miss the checkmate!"),
_("A <b>puzzle</b> is a set of simple positions classified by theme for which you should guess the best moves. It helps you to understand the patterns to drive an accurate attack or defense."),
_("A <b>lesson</b> is a complex study that explains the tactics for a given position. It is common to view circles and arrows over the board to focus on the behavior of the pieces, the threats, etc...")
]
self.tips_seed = conf.get("tips_seed")
if self.tips_seed == 0: # Forbidden value
self.tips_seed = 123456789 + randrange(876543210)
conf.set("tips_seed", self.tips_seed)
self.tips_curindex = conf.get("tips_index")
self.shuffleTips()
def __init__(self, widgets):
self.widgets = widgets
self.dialog = self.widgets["manage_engines_dialog"]
self.cur_engine = None
self.default_workdir = getEngineDataPrefix()
uistuff.keepWindowSize("engineswindow",
self.dialog,
defaultSize=(600, 500))
# Put engines into tree store
allstore = Gtk.ListStore(Pixbuf, str)
self.tv = self.widgets["engines_treeview"]
self.tv.set_model(allstore)
self.tv.append_column(
Gtk.TreeViewColumn("Flag", Gtk.CellRendererPixbuf(), pixbuf=0))
name_renderer = Gtk.CellRendererText()
name_renderer.set_property("editable", True)
self.tv.append_column(Gtk.TreeViewColumn("Name", name_renderer,
text=1))
def name_edited(renderer, path, new_name):
if self.cur_engine is not None:
old_name = self.cur_engine
if new_name and new_name != old_name:
names = [
engine["name"] for engine in discoverer.getEngines()
]
if new_name not in names:
engine = discoverer.getEngineByName(self.cur_engine)
engine["name"] = new_name
discoverer.save()
self.cur_engine = new_name
update_store()
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
name_renderer.connect("edited", name_edited)
# Add cell renderer to protocol combo column
protocol_combo = self.widgets["engine_protocol_combo"]
cell = Gtk.CellRendererText()
protocol_combo.pack_start(cell, True)
protocol_combo.add_attribute(cell, "text", 0)
# Add columns and cell renderers to options treeview
self.options_store = Gtk.ListStore(str, GObject.TYPE_PYOBJECT)
optv = self.widgets["options_treeview"]
optv.set_model(self.options_store)
optv.append_column(
Gtk.TreeViewColumn("Option", Gtk.CellRendererText(), text=0))
optv.append_column(
Gtk.TreeViewColumn("Data",
KeyValueCellRenderer(self.options_store),
data=1))
def update_options(*args):
if self.cur_engine is not None:
engines = discoverer.getEngines()
names = [engine["name"] for engine in engines]
# After deleting an engine we will select first
if self.cur_engine not in names:
self.cur_engine = engines[0]["name"]
engine = discoverer.getEngineByName(self.cur_engine)
options = engine.get("options")
if options:
self.options_store.clear()
for option in options:
key = option["name"]
val = option
if option["type"] != "button":
val["default"] = option.get("default")
val["value"] = option.get("value", val["default"])
self.options_store.append([key, val])
def update_store(*args):
allstore.clear()
newGameDialog.createPlayerUIGlobals(discoverer)
# don't add the very first (Human) player to engine store
for item in newGameDialog.playerItems[0][1:]:
allstore.append(item)
update_options()
update_store()
################################################################
# remove button
################################################################
def remove(button):
if self.cur_engine is not None:
self.widgets['remove_engine_button'].set_sensitive(False)
engine = discoverer.getEngineByName(self.cur_engine)
discoverer.removeEngine(self.cur_engine)
discoverer.save()
update_store(discoverer)
# Notify playerCombos in NewGameTasker
discoverer.emit("all_engines_discovered")
ts = self.tv.get_selection()
ts.select_path((0, ))
self.widgets["remove_engine_button"].connect("clicked", remove)
################################################################
# add button
################################################################
engine_chooser_dialog = Gtk.FileChooserDialog(
_("Select engine"), None, Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
filter = Gtk.FileFilter()
filter.set_name(_("Chess engines"))
filter.add_mime_type("application/x-executable")
engine_chooser_dialog.add_filter(filter)
self.add = False
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine:
try:
uci = is_uci(new_engine)
if not uci:
if not is_cecp(new_engine):
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
print("Maybe not a chess engine")
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets[
"engine_protocol_combo"].get_active()
protocol = "uci" if active == 0 else "xboard"
discoverer.addEngine(binname, new_engine, protocol)
self.cur_engine = binname
glock_connect_after(discoverer, "engine_discovered",
update_store)
self.add = False
discoverer.discover()
except:
print("There is something wrong with this executable")
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
self.widgets["add_engine_button"].connect("clicked", add)
################################################################
# engine args
################################################################
def args_changed(widget):
if self.cur_engine is not None:
new_args = self.widgets["engine_args_entry"].get_text().strip()
engine = discoverer.getEngineByName(self.cur_engine)
old_args = engine.get("args")
if new_args != old_args:
engine["args"] = new_args.split()
discoverer.save()
self.widgets["engine_args_entry"].connect("changed", args_changed)
################################################################
# engine working directory
################################################################
dir_chooser_dialog = Gtk.FileChooserDialog(
_("Select working directory"), None,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
dir_chooser_button = Gtk.FileChooserButton.new_with_dialog(
dir_chooser_dialog)
self.widgets["dirChooserDock"].add(dir_chooser_button)
dir_chooser_button.show()
def select_dir(button):
new_directory = dir_chooser_dialog.get_filename()
engine = discoverer.getEngineByName(self.cur_engine)
old_directory = engine.get("workingDirectory")
if new_directory != old_directory and new_directory != self.default_workdir:
engine["workingDirectory"] = new_directory
discoverer.save()
dir_chooser_button.connect("current-folder-changed", select_dir)
################################################################
# engine protocol
################################################################
def protocol_changed(widget):
if self.cur_engine is not None and not self.add and not self.selection:
active = self.widgets["engine_protocol_combo"].get_active()
new_protocol = "uci" if active == 0 else "xboard"
engine = discoverer.getEngineByName(self.cur_engine)
old_protocol = engine["protocol"]
if new_protocol != old_protocol:
engine_command = engine_chooser_dialog.get_filename()
# is the new protocol supported by the engine?
if new_protocol == "uci":
ok = is_uci(engine_command)
else:
ok = is_cecp(engine_command)
if ok:
# discover engine options for new protocol
engine["protocol"] = new_protocol
engine["recheck"] = True
glock_connect_after(discoverer, "engine_discovered",
update_options)
discoverer.discover()
else:
# restore the original protocol
widgets["engine_protocol_combo"].set_active(
0 if old_protocol == "uci" else 1)
self.widgets["engine_protocol_combo"].connect("changed",
protocol_changed)
################################################################
# engine tree
################################################################
self.selection = False
def selection_changed(treeselection):
store, iter = self.tv.get_selection().get_selected()
if iter:
self.selection = True
row = store.get_path(iter)[0]
name = store[row][1]
self.cur_engine = name
engine = discoverer.getEngineByName(name)
self.widgets['copy_engine_button'].set_sensitive(True)
if "PyChess.py" in engine["command"]:
self.widgets['remove_engine_button'].set_sensitive(False)
else:
self.widgets['remove_engine_button'].set_sensitive(True)
self.widgets["engine_command_entry"].set_text(
engine["command"])
engine_chooser_dialog.set_filename(engine["command"])
args = [] if engine.get("args") is None else engine.get("args")
self.widgets["engine_args_entry"].set_text(' '.join(args))
directory = engine.get("workingDirectory")
d = directory if directory is not None else self.default_workdir
dir_chooser_dialog.set_current_folder(d)
self.widgets["engine_protocol_combo"].set_active(
0 if engine["protocol"] == "uci" else 1)
update_options()
self.selection = False
tree_selection = self.tv.get_selection()
tree_selection.connect('changed', selection_changed)
tree_selection.select_path((0, ))
def __init__(self):
self.connection = None
self.helperconn = None
self.lounge = None
self.canceled = False
self.cids = defaultdict(list)
self.widgets = uistuff.GladeWidgets("fics_logon.glade")
uistuff.keepWindowSize("fics_logon",
self.widgets["fics_logon"],
defaultPosition=uistuff.POSITION_GOLDEN)
self.widgets["fics_logon"].connect(
'key-press-event',
lambda w, e: e.keyval == Gdk.KEY_Escape and w.hide())
def on_logOnAsGuest_toggled(check):
names = get_user_names()
self.widgets["nameEntry"].set_text(names[1] if check.get_active()
else names[0])
self.widgets["passwordLabel"].set_sensitive(not check.get_active())
self.widgets["passEntry"].set_sensitive(not check.get_active())
self.widgets["logOnAsGuest"].connect("toggled",
on_logOnAsGuest_toggled)
uistuff.keep(self.widgets["logOnAsGuest"], "asGuestCheck")
as_guest = self.widgets["logOnAsGuest"]
def user_name_get_value(entry):
names = get_user_names()
if as_guest.get_active():
text = "%s|%s" % (names[0], entry.get_text())
else:
text = "%s|%s" % (entry.get_text(), names[1])
return text
def user_name_set_value(entry, value):
names = get_user_names(value=value)
if as_guest.get_active():
entry.set_text(names[1])
else:
entry.set_text(names[0])
uistuff.keep(self.widgets["nameEntry"], "usernameEntry", user_name_get_value, user_name_set_value)
# workaround to FICS Password input doesnt handle strings starting with a number
# https://github.com/pychess/pychess/issues/1375
def password_set_value(entry, value):
entry.set_text(str(value))
uistuff.keep(self.widgets["passEntry"], "passwordEntry", set_value_=password_set_value)
# workaround to Can't type IP to FICS login dialog
# https://github.com/pychess/pychess/issues/1360
def host_get_value(entry):
return entry.get_text().replace(".", "|")
def host_set_value(entry, value):
entry.set_text(str(value).replace("|", "."))
uistuff.keep(self.widgets["hostEntry"], "hostEntry", host_get_value, host_set_value)
uistuff.keep(self.widgets["autoLogin"], "autoLogin")
self.infobar = Gtk.InfoBar()
self.infobar.set_message_type(Gtk.MessageType.WARNING)
# self.widgets["messagePanelHBox"].pack_start(self.infobar,
# expand=False, fill=False)
self.widgets["messagePanelHBox"].pack_start(self.infobar, False, False,
0)
self.widgets["cancelButton"].connect("clicked", self.onCancel, True)
self.widgets["stopButton"].connect("clicked", self.onCancel, False)
self.widgets["createNewButton"].connect("clicked", self.onCreateNew)
self.widgets["connectButton"].connect("clicked", self.onConnectClicked)
self.widgets["progressbar"].set_show_text(True)
def initGlade(self, log_viewer):
#=======================================================================
# Init glade and the 'GladeHandlers'
#=======================================================================
#Gtk.about_dialog_set_url_hook(self.website)
widgets = uistuff.GladeWidgets("PyChess.glade")
widgets.getGlade().connect_signals(GladeHandlers())
tasker = TaskerManager()
tasker.packTaskers (NewGameTasker(), InternetGameTasker())
widgets["Background"].add(tasker)
#------------------------------------------------------ Redirect widgets
gamewidget.setWidgets(widgets)
def on_sensitive_changed (widget, prop):
name = widget.get_property('name')
sensitive = widget.get_property('sensitive')
#print "'%s' changed to '%s'" % (name, sensitive)
widgets['pause1'].connect("notify::sensitive", on_sensitive_changed)
widgets['resume1'].connect("notify::sensitive", on_sensitive_changed)
#-------------------------- Main.py still needs a minimum of information
ionest.handler.connect("gmwidg_created",
GladeHandlers.__dict__["on_gmwidg_created"])
#---------------------- The only menuitems that need special initing
for widget in ("hint_mode", "spy_mode"):
widgets[widget].set_sensitive(False)
uistuff.keep(widgets["hint_mode"], "hint_mode", first_value=True)
uistuff.keep(widgets["spy_mode"], "spy_mode")
uistuff.keep(widgets["show_sidepanels"], "show_sidepanels")
uistuff.keep(widgets["auto_call_flag"], "autoCallFlag", first_value=True)
#=======================================================================
# Show main window and init d'n'd
#=======================================================================
widgets["window1"].set_title('%s - PyChess' % _('Welcome'))
widgets["window1"].connect("delete-event",
GladeHandlers.__dict__["on_quit1_activate"])
widgets["window1"].connect("key-press-event",
GladeHandlers.__dict__["on_window_key_press"])
uistuff.keepWindowSize("main", widgets["window1"], (575,479), POSITION_GOLDEN)
widgets["window1"].show()
widgets["Background"].show_all()
flags = Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP
# To get drag in the whole window, we add it to the menu and the
# background. If it can be gotten to work, the drag_dest_set_proxy
# method is very interesting.
#widgets["menubar1"].drag_dest_set(flags, dnd_list, Gdk.DragAction.COPY)
#widgets["Background"].drag_dest_set(flags, dnd_list, Gdk.DragAction.COPY)
# TODO: http://code.google.com/p/pychess/issues/detail?id=737
# The following two should really be set in the glade file
#widgets["menubar1"].set_events(widgets["menubar1"].get_events() | Gdk.DRAG_STATUS)
#widgets["Background"].set_events(widgets["Background"].get_events() | Gdk.DRAG_STATUS)
#=======================================================================
# Init 'minor' dialogs
#=======================================================================
#------------------------------------------------------------ Log dialog
if log_viewer:
from pychess.widgets import LogDialog
LogDialog.add_destroy_notify(lambda: widgets["log_viewer1"].set_active(0))
else:
widgets["log_viewer1"].set_property('sensitive', False)
#---------------------------------------------------------- About dialog
self.aboutdialog = widgets["aboutdialog1"]
self.aboutdialog.set_program_name(NAME)
link = self.aboutdialog.get_website()
self.aboutdialog.set_copyright("Copyright © 2006-2015")
self.aboutdialog.set_version(VERSION_NAME+" "+VERSION)
if os.path.isdir(prefix.addDataPrefix(".git")):
try:
label = subprocess.check_output(["git", "describe"])
except subprocess.CalledProcessError:
label = ""
if label:
comments = self.aboutdialog.get_comments()
self.git_rev = label
self.aboutdialog.set_comments("git %s\n%s" % (self.git_rev, comments))
with open(prefix.addDataPrefix("ARTISTS"), encoding="utf-8") as f:
self.aboutdialog.set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS"), encoding="utf-8") as f:
self.aboutdialog.set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS"), encoding="utf-8") as f:
self.aboutdialog.set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS"), encoding="utf-8") as f:
self.aboutdialog.set_translator_credits(f.read())
def on_about_response(dialog, response, *args):
# system-defined GtkDialog responses are always negative, in which
# case we want to hide it
if response < 0:
self.aboutdialog.hide()
self.aboutdialog.emit_stop_by_name('response')
def on_about_close(widget, event=None):
self.aboutdialog.hide()
return True
self.aboutdialog.connect("response", on_about_response)
self.aboutdialog.connect("close", on_about_close)
self.aboutdialog.connect("delete-event", on_about_close)
#---------------------------------------------------- RecentChooser
def recent_item_activated (self):
uri = self.get_current_uri()
try:
urlopen(unquote(uri)).close()
newGameDialog.LoadFileExtension.run(self.get_current_uri())
except (IOError, OSError):
#shomething wrong whit the uri
recentManager.remove_item(uri)
#self.menu_recent = Gtk.RecentChooserMenu(recentManager)
self.menu_recent = Gtk.RecentChooserMenu()
self.menu_recent.set_show_tips(True)
self.menu_recent.set_sort_type(Gtk.RecentSortType.MRU)
self.menu_recent.set_limit(10)
self.menu_recent.set_name("menu_recent")
self.file_filter = Gtk.RecentFilter()
self.file_filter.add_mime_type("application/x-chess-pgn")
self.menu_recent.set_filter(self.file_filter)
self.menu_recent.connect("item-activated", recent_item_activated)
widgets["load_recent_game1"].set_submenu(self.menu_recent)
#----------------------------------------------------- Discoverer dialog
def discovering_started (discoverer, binnames):
GLib.idle_add(DiscovererDialog.show, discoverer, widgets["window1"], binnames)
discoverer.connect("discovering_started", discovering_started)
DiscovererDialog.init(discoverer)
discoverer.discover()
#------------------------------------------------- Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
def initGlade(self):
#=======================================================================
# Init glade and the 'GladeHandlers'
#=======================================================================
gtk.glade.set_custom_handler(self.widgetHandler)
gtk.about_dialog_set_url_hook(self.website)
widgets = uistuff.GladeWidgets("PyChess.glade")
widgets.getGlade().signal_autoconnect(GladeHandlers.__dict__)
#------------------------------------------------------ Redirect widgets
gamewidget.setWidgets(widgets)
#-------------------------- Main.py still needs a minimum of information
ionest.handler.connect("gmwidg_created",
GladeHandlers.__dict__["on_gmwidg_created"])
#---------------------- The only menuitems that need special initing
uistuff.keep(widgets["hint_mode"], "hint_mode")
uistuff.keep(widgets["spy_mode"], "spy_mode")
uistuff.keep(widgets["show_sidepanels"], "show_sidepanels")
#=======================================================================
# Show main window and init d'n'd
#=======================================================================
widgets["window1"].set_title('%s - PyChess' % _('Welcome'))
widgets["window1"].connect("key-press-event",
GladeHandlers.__dict__["on_window_key_press"])
uistuff.keepWindowSize("main", widgets["window1"], (575,479), POSITION_GOLDEN)
widgets["window1"].show()
widgets["Background"].show_all()
flags = DEST_DEFAULT_MOTION | DEST_DEFAULT_HIGHLIGHT | DEST_DEFAULT_DROP
widgets["menubar1"].drag_dest_set(flags, dnd_list, gtk.gdk.ACTION_COPY)
widgets["Background"].drag_dest_set(flags, dnd_list, gtk.gdk.ACTION_COPY)
#=======================================================================
# Init 'minor' dialogs
#=======================================================================
#------------------------------------------------------------ Log dialog
LogDialog.add_destroy_notify(lambda: widgets["log_viewer1"].set_active(0))
#---------------------------------------------------------- About dialog
clb = widgets["aboutdialog1"].get_child().get_children()[1].get_children()[2]
widgets["aboutdialog1"].set_name(NAME)
#widgets["aboutdialog1"].set_position(gtk.WIN_POS_CENTER)
#widgets["aboutdialog1"].set_website_label(_("PyChess Homepage"))
link = widgets["aboutdialog1"].get_website()
if os.path.isfile(prefix.addDataPrefix(".svn/entries")):
f = open(prefix.addDataPrefix(".svn/entries"))
line4 = [f.next() for i in xrange(4)][-1].strip()
widgets["aboutdialog1"].set_version(VERSION_NAME+" r"+line4)
else:
widgets["aboutdialog1"].set_version(VERSION_NAME+" "+VERSION)
with open(prefix.addDataPrefix("ARTISTS")) as f:
widgets["aboutdialog1"].set_artists(f.read().splitlines())
with open(prefix.addDataPrefix("AUTHORS")) as f:
widgets["aboutdialog1"].set_authors(f.read().splitlines())
with open(prefix.addDataPrefix("DOCUMENTERS")) as f:
widgets["aboutdialog1"].set_documenters(f.read().splitlines())
with open(prefix.addDataPrefix("TRANSLATORS")) as f:
widgets["aboutdialog1"].set_translator_credits(f.read())
def callback(button, *args):
widgets["aboutdialog1"].hide()
return True
clb.connect("activate", callback)
clb.connect("clicked", callback)
widgets["aboutdialog1"].connect("delete-event", callback)
#----------------------------------------------------- Discoverer dialog
def discovering_started (discoverer, binnames):
gobject.idle_add(DiscovererDialog.show, discoverer, widgets["window1"])
discoverer.connect("discovering_started", discovering_started)
DiscovererDialog.init(discoverer)
discoverer.start()
#------------------------------------------------- Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
