def on_gmwidg_closed(gmwidg):
log.debug("GladeHandlers.on_gmwidg_closed")
del gameDic[gmwidg]
if not gameDic:
for widget in MENU_ITEMS:
gamewidget.getWidgets()[widget].set_property('sensitive',
False)
def on_gmwidg_created (handler, gmwidg, gamemodel):
gameDic[gmwidg] = gamemodel
# Bring playing window to the front
gamewidget.getWidgets()["window1"].present()
# Make sure we can remove gamewidgets from gameDic later
gmwidg.connect("closed", GladeHandlers.__dict__["on_gmwidg_closed"])
def on_gmwidg_created(self, gamehandler, gmwidg):
log.debug("GladeHandlers.on_gmwidg_created: starting")
# Bring playing window to the front
gamewidget.getWidgets()["main_window"].present()
self.loaded_cids[gmwidg.gamemodel] = gmwidg.gamemodel.connect("game_loaded", self.update_recent)
self.saved_cids[gmwidg.gamemodel] = gmwidg.gamemodel.connect("game_saved", self.update_recent)
self.terminated_cids[gmwidg.gamemodel] = gmwidg.gamemodel.connect("game_terminated", self.on_terminated)
log.debug("GladeHandlers.on_gmwidg_created: returning")
def test1(self):
""" Open several dialogs """
enginesDialog.run(gamewidget.getWidgets())
newGameDialog.SetupPositionExtension.run(FEN_START)
dd = DiscovererDialog(discoverer)
self.dd_task = asyncio.async(dd.start())
preferencesDialog.run(gamewidget.getWidgets())
def on_gmwidg_created (handler, gmwidg, gamemodel):
log.debug("GladeHandlers.on_gmwidg_created: starting")
gameDic[gmwidg] = gamemodel
# Bring playing window to the front
gamewidget.getWidgets()["window1"].present()
gamemodel.connect("game_loaded", GladeHandlers.__dict__["on_recent_game_activated"])
gamemodel.connect("game_saved", GladeHandlers.__dict__["on_recent_game_activated"])
# Make sure we can remove gamewidgets from gameDic later
gmwidg.connect("closed", GladeHandlers.__dict__["on_gmwidg_closed"])
log.debug("GladeHandlers.on_gmwidg_created: returning")
def test0(self):
""" Open engines dialogs """
# engines dialog
enginesDialog.run(gamewidget.getWidgets())
engines = [item[1] for item in enginesDialog.engine_dialog.allstore]
self.assertTrue("PyChess.py" in engines)
def get_open_dialog():
mainwindow = gamewidget.getWidgets()["main_window"]
opendialog = Gtk.FileChooserDialog(
_("Open chess file"), mainwindow, Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
opendialog.set_show_hidden(True)
opendialog.set_select_multiple(True)
# All chess files filter
all_filter = Gtk.FileFilter()
all_filter.set_name(_("All Chess Files"))
opendialog.add_filter(all_filter)
opendialog.set_filter(all_filter)
# Specific filters and save formats
for ending, saver in enddir.items():
label = saver.__label__
endstr = "(%s)" % ending
f = Gtk.FileFilter()
f.set_name(label + " " + endstr)
if hasattr(saver, "load"):
f.add_pattern("*." + ending)
all_filter.add_pattern("*." + ending)
opendialog.add_filter(f)
return opendialog
def get_save_dialog(export=False):
mainwindow = gamewidget.getWidgets()["main_window"]
savedialog = Gtk.FileChooserDialog(
"", mainwindow, Gtk.FileChooserAction.SAVE,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE,
Gtk.ResponseType.ACCEPT))
savedialog.set_current_folder(os.path.expanduser("~"))
# Add widgets to the savedialog
savecombo = Gtk.ComboBox()
savecombo.set_name("savecombo")
crt = Gtk.CellRendererText()
savecombo.pack_start(crt, True)
savecombo.add_attribute(crt, 'text', 0)
crt = Gtk.CellRendererText()
savecombo.pack_start(crt, False)
savecombo.add_attribute(crt, 'text', 1)
if export:
savecombo.set_model(exportformats)
else:
savecombo.set_model(saveformats)
savecombo.set_active(1) # pgn
savedialog.set_extra_widget(savecombo)
return savedialog, savecombo
def do_activate(self):
# asyncio.async(self.print_tasks())
self.add_window(self.window)
self.window.show_all()
gamewidget.getWidgets()["player_rating1"].hide()
gamewidget.getWidgets()["leave_fullscreen1"].hide()
# Externals download dialog
if not conf.get("dont_show_externals_at_startup", False):
externals_dialog.show()
# Tip of the day dialog
if conf.get("show_tip_at_startup", False):
tipOfTheDay.TipOfTheDay.show()
dd = DiscovererDialog(discoverer)
self.dd_task = asyncio.async(dd.start())
def __init__(self):
GObject.GObject.__init__(self)
Perspective.__init__(self, "database", _("Database"))
self.widgets = gamewidget.getWidgets()
self.chessfile = None
self.chessfiles = []
self.gamelists = []
self.filter_panels = []
self.notebooks = {}
self.connect("chessfile_opened0", self.on_chessfile_opened0)
def on_set_up_position_activate(self, widget):
rotate_menu = gamewidget.getWidgets()["rotate_board1"]
rotate_menu.set_sensitive(True)
persp = perspective_manager.get_perspective("games")
gmwidg = persp.cur_gmwidg()
if gmwidg is not None:
ply = gmwidg.board.view.shown
variation = gmwidg.board.view.shown_variation_idx
fen = gmwidg.gamemodel.getBoardAtPly(ply, variation).asFen()
else:
fen = None
newGameDialog.SetupPositionExtension.run(fen)
def attachGameWidget(self, gmwidg):
log.debug("attachGameWidget: %s" % gmwidg)
if self.first_run:
self.init_layout()
self.first_run = False
perspective_manager.activate_perspective("games")
gmwidg.panels = [panel.Sidepanel().load(gmwidg) for panel in self.sidePanels]
self.key2gmwidg[gmwidg.notebookKey] = gmwidg
headbook = self.getheadbook()
headbook.append_page(gmwidg.notebookKey, gmwidg.tabcontent)
gmwidg.notebookKey.show_all()
if hasattr(headbook, "set_tab_reorderable"):
headbook.set_tab_reorderable(gmwidg.notebookKey, True)
def callback(notebook, gpointer, page_num, gmwidg):
if notebook.get_nth_page(page_num) == gmwidg.notebookKey:
gmwidg.infront()
if gmwidg.gamemodel.players and gmwidg.gamemodel.isObservationGame():
gmwidg.light_on_off(False)
text = gmwidg.game_info_label.get_text()
gmwidg.game_info_label.set_markup(
'<span color="black" weight="bold">%s</span>' % text)
self.key2cid[gmwidg.notebookKey] = headbook.connect_after("switch-page", callback, gmwidg)
gmwidg.infront()
align = gamewidget.createAlignment(0, 0, 0, 0)
align.show()
align.add(gmwidg.infobar)
self.notebooks["messageArea"].append_page(align, None)
self.notebooks["board"].append_page(gmwidg.boardvbox, None)
gmwidg.boardvbox.show_all()
for panel, instance in zip(self.sidePanels, gmwidg.panels):
self.notebooks[panel_name(panel.__name__)].append_page(instance, None)
instance.show_all()
self.notebooks["buttons"].append_page(gmwidg.stat_hbox, None)
gmwidg.stat_hbox.show_all()
if headbook.get_n_pages() == 1:
self.show_tabs(not conf.get("hideTabs"))
else:
# We should always show tabs if more than one exists
self.show_tabs(True)
headbook.set_current_page(-1)
widgets = gamewidget.getWidgets()
if headbook.get_n_pages() == 1 and not widgets["show_sidepanels"].get_active():
self.zoomToBoard(True)
def on_set_up_position_activate(self, widget):
rotate_menu = gamewidget.getWidgets()["rotate_board1"]
rotate_menu.set_sensitive(True)
gmwidg = gamewidget.cur_gmwidg()
if gmwidg is not None:
if len(gmwidg.gamemodel.boards) == 1:
ply = 0
else:
ply = gmwidg.board.view.shown
fen = gmwidg.gamemodel.boards[ply].asFen()
else:
fen = None
newGameDialog.SetupPositionExtension.run(fen)
def set_sensitives(self, on):
self.import_button.set_sensitive(on)
self.widgets["import_chessfile"].set_sensitive(on)
self.widgets["database_save_as"].set_sensitive(on)
self.widgets["create_book"].set_sensitive(on)
self.widgets["import_endgame_nl"].set_sensitive(on)
self.widgets["import_twic"].set_sensitive(on)
if on:
gamewidget.getWidgets()["copy_pgn"].set_property('sensitive', on)
gamewidget.getWidgets()["copy_fen"].set_property('sensitive', on)
else:
persp = perspective_manager.get_perspective("games")
if persp.cur_gmwidg() is None:
gamewidget.getWidgets()["copy_pgn"].set_property('sensitive', on)
gamewidget.getWidgets()["copy_fen"].set_property('sensitive', on)
def on_set_up_position_activate(self, widget):
rotate_menu = gamewidget.getWidgets()["rotate_board1"]
rotate_menu.set_sensitive(True)
persp = perspective_manager.get_perspective("games")
gmwidg = persp.cur_gmwidg()
if gmwidg is not None:
ply = gmwidg.board.view.shown
variation = gmwidg.board.view.shown_variation_idx
board = gmwidg.gamemodel.getBoardAtPly(ply, variation)
fen = board.asFen()
variant = board.variant
else:
fen = None
variant = NORMALCHESS
newGameDialog.SetupPositionExtension.run(fen, variant)
def __init__(self):
GObject.GObject.__init__(self)
Perspective.__init__(self, "database", _("Database"))
self.widgets = gamewidget.getWidgets()
self.first_run = True
self.chessfile = None
self.chessfiles = []
self.importer = None
self.gamelists = []
self.filter_panels = []
self.opening_tree_panels = []
self.preview_panels = []
self.notebooks = {}
self.page_dict = {}
self.connect("chessfile_opened0", self.on_chessfile_opened0)
self.dockLocation = addUserConfigPrefix("pydock-database.xml")
def __init__(self):
GObject.GObject.__init__(self)
Perspective.__init__(self, "database", _("Database"))
self.widgets = gamewidget.getWidgets()
self.first_run = True
self.chessfile = None
self.chessfiles = []
self.importer = None
self.gamelists = []
self.filter_panels = []
self.opening_tree_panels = []
self.preview_panels = []
self.notebooks = {}
self.page_dict = {}
self.connect("chessfile_opened0", self.on_chessfile_opened0)
self.dockLocation = addUserConfigPrefix("pydock-database.xml")
def set_sensitives(self, on):
self.import_button.set_sensitive(on)
self.widgets["import_chessfile"].set_sensitive(on)
self.widgets["database_save_as"].set_sensitive(on)
self.widgets["create_book"].set_sensitive(on)
self.widgets["import_endgame_nl"].set_sensitive(on)
self.widgets["import_twic"].set_sensitive(on)
if on:
gamewidget.getWidgets()["copy_pgn"].set_property('sensitive', on)
gamewidget.getWidgets()["copy_fen"].set_property('sensitive', on)
else:
persp = perspective_manager.get_perspective("games")
if persp.cur_gmwidg() is None:
gamewidget.getWidgets()["copy_pgn"].set_property(
'sensitive', on)
gamewidget.getWidgets()["copy_fen"].set_property(
'sensitive', on)
def test4(self):
""" Open preferences dialog """
widgets = gamewidget.getWidgets()
preferencesDialog.run(widgets)
notebook = widgets["preferences_notebook"]
self.assertIsNotNone(preferencesDialog.general_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.hint_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.theme_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.sound_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.save_tab)
def test4(self):
""" Open preferences dialog """
widgets = gamewidget.getWidgets()
preferencesDialog.run(widgets)
notebook = widgets["preferences_notebook"]
self.assertIsNotNone(preferencesDialog.general_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.hint_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.theme_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.sound_tab)
notebook.next_page()
self.assertIsNotNone(preferencesDialog.save_tab)
def delGameWidget(self, gmwidg):
""" Remove the widget from the GUI after the game has been terminated """
log.debug("Games.delGameWidget: starting %s" % repr(gmwidg))
gmwidg.closed = True
gmwidg.emit("closed")
called_from_preferences = False
window_list = Gtk.Window.list_toplevels()
widgets = gamewidget.getWidgets()
for window in window_list:
if window.is_active() and window == widgets["preferences"]:
called_from_preferences = True
break
pageNum = gmwidg.getPageNumber()
headbook = self.getheadbook()
if gmwidg.notebookKey in self.key2gmwidg:
del self.key2gmwidg[gmwidg.notebookKey]
if gmwidg.notebookKey in self.key2cid:
headbook.disconnect(self.key2cid[gmwidg.notebookKey])
del self.key2cid[gmwidg.notebookKey]
headbook.remove_page(pageNum)
for notebook in self.notebooks.values():
notebook.remove_page(pageNum)
if headbook.get_n_pages() == 1 and conf.get("hideTabs"):
self.show_tabs(False)
if headbook.get_n_pages() == 0:
if not called_from_preferences:
# If the last (but not the designGW) gmwidg was closed
# and we are FICS-ing, present the FICS lounge
perspective_manager.disable_perspective("games")
gmwidg._del()
def delGameWidget(self, gmwidg):
""" Remove the widget from the GUI after the game has been terminated """
log.debug("Games.delGameWidget: starting %s" % repr(gmwidg))
gmwidg.closed = True
gmwidg.emit("closed")
called_from_preferences = False
window_list = Gtk.Window.list_toplevels()
widgets = gamewidget.getWidgets()
for window in window_list:
if window.is_active() and window == widgets["preferences"]:
called_from_preferences = True
break
pageNum = gmwidg.getPageNumber()
headbook = self.getheadbook()
if gmwidg.notebookKey in self.key2gmwidg:
del self.key2gmwidg[gmwidg.notebookKey]
if gmwidg.notebookKey in self.key2cid:
headbook.disconnect(self.key2cid[gmwidg.notebookKey])
del self.key2cid[gmwidg.notebookKey]
headbook.remove_page(pageNum)
for notebook in self.notebooks.values():
notebook.remove_page(pageNum)
if headbook.get_n_pages() == 1 and conf.get("hideTabs", False):
self.show_tabs(False)
if headbook.get_n_pages() == 0:
if not called_from_preferences:
# If the last (but not the designGW) gmwidg was closed
# and we are FICS-ing, present the FICS lounge
perspective_manager.disable_perspective("games")
gmwidg._del()
def do_activate(self):
# create_task(self.print_tasks())
self.add_window(self.window)
self.window.show_all()
gamewidget.getWidgets()["player_rating1"].hide()
gamewidget.getWidgets()["leave_fullscreen1"].hide()
# Externals download dialog
if not conf.get("dont_show_externals_at_startup"):
externals_dialog = ExternalsDialog()
externals_dialog.show()
# Tip of the day dialog
if conf.get("show_tip_at_startup"):
tip_of_the_day = TipOfTheDay()
tip_of_the_day.show()
preferencesDialog.run(gamewidget.getWidgets())
def on_all_engine_discovered(discoverer):
engine = discoverer.getEngineByName(discoverer.getEngineLearn())
if engine is None:
engine = discoverer.getEngineN(-1)
default_engine = engine.get("md5")
conf.set("ana_combobox", default_engine)
conf.set("inv_ana_combobox", default_engine)
# Try to set conf analyzer engine on very first start of pychess
if conf.get("ana_combobox") == 0:
discoverer.connect_after("all_engines_discovered",
on_all_engine_discovered)
dd = DiscovererDialog(discoverer)
self.dd_task = create_task(dd.start())
style_ctxt = gamewidget.getWidgets()["main_window"].get_style_context()
LIGHT = hexcol(style_ctxt.lookup_color("p_light_color")[1])
DARK = hexcol(style_ctxt.lookup_color("p_dark_color")[1])
conf.DEFAULTS["General"]["lightcolour"] = LIGHT
conf.DEFAULTS["General"]["darkcolour"] = DARK
self.splash.destroy()
def do_activate(self):
# create_task(self.print_tasks())
self.add_window(self.window)
self.window.show_all()
gamewidget.getWidgets()["player_rating1"].hide()
gamewidget.getWidgets()["leave_fullscreen1"].hide()
# Externals download dialog
if not conf.get("dont_show_externals_at_startup"):
externals_dialog = ExternalsDialog()
externals_dialog.show()
# Tip of the day dialog
if conf.get("show_tip_at_startup"):
tip_of_the_day = TipOfTheDay()
tip_of_the_day.show()
preferencesDialog.run(gamewidget.getWidgets())
def on_all_engine_discovered(discoverer):
engine = discoverer.getEngineByName(discoverer.getEngineLearn())
if engine is None:
engine = discoverer.getEngineN(-1)
default_engine = engine.get("md5")
conf.set("ana_combobox", default_engine)
conf.set("inv_ana_combobox", default_engine)
# Try to set conf analyzer engine on very first start of pychess
if conf.get("ana_combobox") == 0:
discoverer.connect_after("all_engines_discovered", on_all_engine_discovered)
dd = DiscovererDialog(discoverer)
self.dd_task = create_task(dd.start())
style_ctxt = gamewidget.getWidgets()["main_window"].get_style_context()
LIGHT = hexcol(style_ctxt.lookup_color("p_light_color")[1])
DARK = hexcol(style_ctxt.lookup_color("p_dark_color")[1])
conf.set("lightcolour", LIGHT)
conf.set("darkcolour", DARK)
def do_activate(self):
self.add_window(self.window)
self.window.show_all()
gamewidget.getWidgets()["player_rating1"].hide()
gamewidget.getWidgets()["leave_fullscreen1"].hide()
def on_player_rating1_activate(self, widget):
playerinfoDialog.run(gamewidget.getWidgets())
def closeGame(self, gmwidg):
log.debug("Games.closeGame")
response = None
if not gmwidg.gamemodel.isChanged():
response = Gtk.ResponseType.OK
else:
markup = "<b><big>" + _("Save the current game before you close it?") + "</big></b>"
if conf.get("autoSave", False):
x = self.saveGamePGN(gmwidg.gamemodel)
if x:
response = Gtk.ResponseType.OK
else:
markup = "<b><big>" + _("Unable to save to configured file. \
Save the current game before you close it?") + "</big></b>"
if response is None:
d = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.WARNING)
d.add_button(_("Close _without Saving"), Gtk.ResponseType.OK)
d.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
if gmwidg.gamemodel.uri:
d.add_button(Gtk.STOCK_SAVE, Gtk.ResponseType.YES)
else:
d.add_button(Gtk.STOCK_SAVE_AS, Gtk.ResponseType.YES)
gmwidg.bringToFront()
d.set_markup(markup)
d.format_secondary_text(_(
"It is not possible later to continue the game,\nif you don't save it."))
response = d.run()
d.destroy()
if response == Gtk.ResponseType.YES:
# Test if cancel was pressed in the save-file-dialog
if self.saveGame(gmwidg.gamemodel) != Gtk.ResponseType.ACCEPT:
response = Gtk.ResponseType.CANCEL
if response not in (Gtk.ResponseType.DELETE_EVENT,
Gtk.ResponseType.CANCEL):
if gmwidg.gamemodel.status in UNFINISHED_STATES:
gmwidg.gamemodel.end(ABORTED, ABORTED_AGREEMENT)
gmwidg.disconnect(self.gmwidg_cids[gmwidg])
del self.gmwidg_cids[gmwidg]
for cid in self.notify_cids[gmwidg]:
conf.notify_remove(cid)
del self.notify_cids[gmwidg]
if gmwidg.board in self.board_cids:
gmwidg.board.disconnect(self.board_cids[gmwidg.board])
del self.board_cids[gmwidg.board]
self.delGameWidget(gmwidg)
self.gamewidgets.remove(gmwidg)
gmwidg.gamemodel.terminate()
if len(self.gamewidgets) == 0:
for widget in MENU_ITEMS:
gamewidget.getWidgets()[widget].set_property('sensitive', False)
return response
def on_properties1_activate(widget):
gameinfoDialog.run(gamewidget.getWidgets(), gameDic)
def on_gmwidg_closed(gmwidg):
del gameDic[gmwidg]
if not gameDic:
for widget in gamewidget.MENU_ITEMS:
gamewidget.getWidgets()[widget].set_property(
'sensitive', False)
def on_leave_fullscreen1_activate(self, widget):
gamewidget.getWidgets()["main_window"].unfullscreen()
gamewidget.getWidgets()["leave_fullscreen1"].hide()
gamewidget.getWidgets()["fullscreen1"].show()
def on_manage_engines_activate(self, widget):
enginesDialog.run(gamewidget.getWidgets())
def on_fullscreen1_activate(self, widget):
gamewidget.getWidgets()["window1"].fullscreen()
gamewidget.getWidgets()["fullscreen1"].hide()
gamewidget.getWidgets()["leave_fullscreen1"].show()
def init_layout(self):
perspective_widget = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
perspective_manager.set_perspective_widget("database",
perspective_widget)
self.switcher_panel = SwitcherPanel(self)
self.notebooks["gamelist"] = new_notebook()
self.notebooks["opening_tree"] = new_notebook()
self.notebooks["filter"] = new_notebook()
self.notebooks["preview"] = new_notebook()
self.spinner = Gtk.Spinner()
self.spinner.set_size_request(50, 50)
self.progressbar0 = Gtk.ProgressBar(show_text=True)
self.progressbar1 = Gtk.ProgressBar(show_text=True)
mainwindow = gamewidget.getWidgets()["main_window"]
self.progress_dialog = Gtk.Dialog(
"", mainwindow, 0, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
self.progress_dialog.get_content_area().pack_start(
self.spinner, True, True, 0)
self.progress_dialog.get_content_area().pack_start(
self.progressbar0, True, True, 0)
self.progress_dialog.get_content_area().pack_start(
self.progressbar1, True, True, 0)
self.progress_dialog.get_content_area().show_all()
perspective = perspective_manager.get_perspective("database")
self.dock = PyDockTop("database", perspective)
align = Gtk.Alignment()
align.show()
align.add(self.dock)
self.dock.show()
perspective_widget.pack_start(align, True, True, 0)
dockLocation = addUserConfigPrefix("pydock-database.xml")
docks = {
"gamelist":
(Gtk.Label(label="gamelist"), self.notebooks["gamelist"]),
"switcher":
(dock_panel_tab(_("Databases"), "",
addDataPrefix("glade/panel_docker.svg")),
self.switcher_panel.alignment),
"openingtree":
(dock_panel_tab(_("Openings"), "",
addDataPrefix("glade/panel_docker.svg")),
self.notebooks["opening_tree"]),
"filter": (dock_panel_tab(_("Filters"), "",
addDataPrefix("glade/panel_docker.svg")),
self.notebooks["filter"]),
"preview":
(dock_panel_tab(_("Preview"), "",
addDataPrefix("glade/panel_docker.svg")),
self.notebooks["preview"]),
}
if os.path.isfile(dockLocation):
try:
self.dock.loadFromXML(dockLocation, docks)
except Exception as e:
stringio = StringIO()
traceback.print_exc(file=stringio)
error = stringio.getvalue()
log.error("Dock loading error: %s\n%s" % (e, error))
msg_dia = Gtk.MessageDialog(None,
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.CLOSE)
msg_dia.set_markup(
_("<b><big>PyChess was unable to load your panel settings</big></b>"
))
msg_dia.format_secondary_text(
_("Your panel settings have been reset. If this problem repeats, \
you should report it to the developers"))
msg_dia.run()
msg_dia.hide()
os.remove(dockLocation)
for title, panel in docks.values():
title.unparent()
panel.unparent()
if not os.path.isfile(dockLocation):
leaf = self.dock.dock(docks["gamelist"][1], CENTER,
docks["gamelist"][0], "gamelist")
leaf.setDockable(False)
leaf.dock(docks["switcher"][1], NORTH, docks["switcher"][0],
"switcher")
leaf = leaf.dock(docks["filter"][1], EAST, docks["filter"][0],
"filter")
leaf = leaf.dock(docks["openingtree"][1], SOUTH,
docks["openingtree"][0], "openingtree")
leaf.dock(docks["preview"][1], SOUTH, docks["preview"][0],
"preview")
def unrealize(dock):
dock.saveToXML(dockLocation)
dock._del()
self.dock.connect("unrealize", unrealize)
self.dock.show_all()
perspective_widget.show_all()
perspective_manager.set_perspective_toolbuttons(
"database", [self.import_button, self.close_button])
self.switcher_panel.connect("chessfile_switched",
self.on_chessfile_switched)
def on_about1_activate(self, widget):
gamewidget.getWidgets()["aboutdialog1"].show()
def on_window_key_press(self, window, event):
log.debug('on_window_key_press: %s %s' % (window.get_title(), event))
# debug leaking memory
if Gdk.keyval_name(event.keyval) == "F12":
from pychess.System.debug import print_obj_referrers, print_muppy_sumary
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
print_muppy_sumary()
else:
print_obj_referrers()
# Tabbing related shortcuts
persp = perspective_manager.get_perspective("games")
if not persp.getheadbook():
pagecount = 0
else:
pagecount = persp.getheadbook().get_n_pages()
if pagecount > 1:
if event.get_state() & Gdk.ModifierType.CONTROL_MASK:
page_num = persp.getheadbook().get_current_page()
# Move selected
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
child = persp.getheadbook().get_nth_page(page_num)
if event.keyval == Gdk.KEY_Page_Up:
persp.getheadbook().reorder_child(child, (
page_num - 1) % pagecount)
return True
elif event.keyval == Gdk.KEY_Page_Down:
persp.getheadbook().reorder_child(child, (
page_num + 1) % pagecount)
return True
# Change selected
else:
if event.keyval == Gdk.KEY_Page_Up:
persp.getheadbook().set_current_page(
(page_num - 1) % pagecount)
return True
elif event.keyval == Gdk.KEY_Page_Down:
persp.getheadbook().set_current_page(
(page_num + 1) % pagecount)
return True
gmwidg = persp.cur_gmwidg()
if gmwidg is not None:
# Let default handler work if typing inside entry widgets
current_focused_widget = gamewidget.getWidgets()["main_window"].get_focus()
if current_focused_widget is not None and isinstance(current_focused_widget, Gtk.Entry):
return False
# Prevent moving in game while lesson not finished
if gmwidg.gamemodel.lesson_game:
return
# Navigate on boardview with arrow keys
if event.keyval in leftkeys:
if event.get_state() & Gdk.ModifierType.CONTROL_MASK:
gmwidg.board.view.backToMainLine()
return True
else:
gmwidg.board.view.showPrev()
return True
elif event.keyval in rightkeys:
gmwidg.board.view.showNext()
return True
elif event.keyval in upkeys:
gmwidg.board.view.showPrev(step=2)
return True
elif event.keyval in downkeys:
gmwidg.board.view.showNext(step=2)
return True
elif event.keyval in homekeys:
gmwidg.board.view.showFirst()
return True
elif event.keyval in endkeys:
gmwidg.board.view.showLast()
return True
if (not event.get_state() & Gdk.ModifierType.CONTROL_MASK) and \
(not event.get_state() & Gdk.ModifierType.MOD1_MASK) and \
(event.keyval != Gdk.KEY_Escape) and \
(event.keyval not in functionkeys):
# Enter moves with keyboard
board_control = gmwidg.board
keyname = Gdk.keyval_name(event.keyval)
board_control.key_pressed(keyname)
print(board_control.keybuffer)
return True
return False
def on_notebook2_switch_page(self, widget, page, page_num):
gamewidget.getWidgets()["notebook3"].set_current_page(page_num)
def on_preferences_activate(self, widget):
preferencesDialog.run(gamewidget.getWidgets())
def on_about1_activate(self, widget):
gamewidget.getWidgets()["aboutdialog1"].show()
def on_properties1_activate(self, widget):
gameinfoDialog.run(gamewidget.getWidgets())
def on_gmwidg_closed(self, gmwidg):
perspective = perspective_manager.get_perspective("games")
if len(perspective.key2gmwidg) == 1:
getWidgets()['main_window'].set_title('%s - PyChess' %
_('Welcome'))
return False
def on_player_rating1_activate(self, widget):
playerinfoDialog.run(gamewidget.getWidgets())
def on_gmwidg_title_changed(self, gmwidg, new_title):
# log.debug("gamenanny.on_gmwidg_title_changed: starting %s" % repr(gmwidg))
if gmwidg.isInFront():
getWidgets()['main_window'].set_title('%s - PyChess' % new_title)
# log.debug("gamenanny.on_gmwidg_title_changed: returning")
return False
def on_about1_activate(self, widget):
about_dialog = gamewidget.getWidgets()["aboutdialog1"]
response = about_dialog.run()
if response == Gtk.ResponseType.DELETE_EVENT or response == Gtk.ResponseType.CANCEL:
gamewidget.getWidgets()["aboutdialog1"].hide()
def closeGame(self, gmwidg):
log.debug("Games.closeGame")
response = None
if not gmwidg.gamemodel.isChanged():
response = Gtk.ResponseType.OK
else:
markup = "<b><big>" + _("Save the current game before you close it?") + "</big></b>"
if conf.get("autoSave"):
x = self.saveGamePGN(gmwidg.gamemodel)
if x:
response = Gtk.ResponseType.OK
else:
markup = "<b><big>" + _("Unable to save to configured file. \
Save the current game before you close it?") + "</big></b>"
if response is None:
d = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.WARNING)
d.add_button(_("Close _without Saving"), Gtk.ResponseType.OK)
d.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
if gmwidg.gamemodel.uri:
d.add_button(Gtk.STOCK_SAVE, Gtk.ResponseType.YES)
else:
d.add_button(Gtk.STOCK_SAVE_AS, Gtk.ResponseType.YES)
gmwidg.bringToFront()
d.set_markup(markup)
d.format_secondary_text(_(
"It is not possible later to continue the game,\nif you don't save it."))
response = d.run()
d.destroy()
if response == Gtk.ResponseType.YES:
# Test if cancel was pressed in the save-file-dialog
if self.saveGame(gmwidg.gamemodel) != Gtk.ResponseType.ACCEPT:
response = Gtk.ResponseType.CANCEL
if response not in (Gtk.ResponseType.DELETE_EVENT,
Gtk.ResponseType.CANCEL):
if gmwidg.gamemodel.status in UNFINISHED_STATES:
gmwidg.gamemodel.end(ABORTED, ABORTED_AGREEMENT)
gmwidg.disconnect(self.gmwidg_cids[gmwidg])
del self.gmwidg_cids[gmwidg]
for cid in self.notify_cids[gmwidg]:
conf.notify_remove(cid)
del self.notify_cids[gmwidg]
if gmwidg.board in self.board_cids:
gmwidg.board.disconnect(self.board_cids[gmwidg.board])
del self.board_cids[gmwidg.board]
self.delGameWidget(gmwidg)
self.gamewidgets.remove(gmwidg)
gmwidg.gamemodel.terminate()
db_persp = perspective_manager.get_perspective("database")
if len(self.gamewidgets) == 0:
for widget in MENU_ITEMS:
if widget in ("copy_pgn", "copy_fen") and db_persp.preview_panel is not None:
continue
gamewidget.getWidgets()[widget].set_property('sensitive', False)
return response
def on_preferences_activate(self, widget):
preferencesDialog.run(gamewidget.getWidgets())
def on_gmwidg_closed (gmwidg):
log.debug("GladeHandlers.on_gmwidg_closed")
del gameDic[gmwidg]
if not gameDic:
for widget in gamewidget.MENU_ITEMS:
gamewidget.getWidgets()[widget].set_property('sensitive', False)
def on_window_key_press(self, window, event):
log.debug('on_window_key_press: %s %s' % (window.get_title(), event))
# debug leaking memory
if Gdk.keyval_name(event.keyval) == "F12":
from pychess.System.debug import print_obj_referrers, print_muppy_sumary
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
print_muppy_sumary()
else:
print_obj_referrers()
# Tabbing related shortcuts
persp = perspective_manager.get_perspective("games")
if not persp.getheadbook():
pagecount = 0
else:
pagecount = persp.getheadbook().get_n_pages()
if pagecount > 1:
if event.get_state() & Gdk.ModifierType.CONTROL_MASK:
page_num = persp.getheadbook().get_current_page()
# Move selected
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
child = persp.getheadbook().get_nth_page(page_num)
if event.keyval == Gdk.KEY_Page_Up:
persp.getheadbook().reorder_child(
child, (page_num - 1) % pagecount)
return True
elif event.keyval == Gdk.KEY_Page_Down:
persp.getheadbook().reorder_child(
child, (page_num + 1) % pagecount)
return True
# Change selected
else:
if event.keyval == Gdk.KEY_Page_Up:
persp.getheadbook().set_current_page(
(page_num - 1) % pagecount)
return True
elif event.keyval == Gdk.KEY_Page_Down:
persp.getheadbook().set_current_page(
(page_num + 1) % pagecount)
return True
gmwidg = persp.cur_gmwidg()
if gmwidg is not None:
# Let default handler work if typing inside entry widgets
current_focused_widget = gamewidget.getWidgets(
)["main_window"].get_focus()
if current_focused_widget is not None and isinstance(
current_focused_widget, Gtk.Entry):
return False
# Prevent moving in game while lesson not finished
if gmwidg.gamemodel.lesson_game:
return
# Navigate on boardview with arrow keys
if event.keyval in leftkeys:
if event.get_state() & Gdk.ModifierType.CONTROL_MASK:
gmwidg.board.view.backToMainLine()
return True
else:
gmwidg.board.view.showPrev()
return True
elif event.keyval in rightkeys:
gmwidg.board.view.showNext()
return True
elif event.keyval in upkeys:
gmwidg.board.view.showPrev(step=2)
return True
elif event.keyval in downkeys:
gmwidg.board.view.showNext(step=2)
return True
elif event.keyval in homekeys:
gmwidg.board.view.showFirst()
return True
elif event.keyval in endkeys:
gmwidg.board.view.showLast()
return True
if (not event.get_state() & Gdk.ModifierType.CONTROL_MASK) and \
(not event.get_state() & Gdk.ModifierType.MOD1_MASK) and \
(event.keyval != Gdk.KEY_Escape) and \
(event.keyval not in functionkeys):
# Enter moves with keyboard
board_control = gmwidg.board
keyname = Gdk.keyval_name(event.keyval)
board_control.key_pressed(keyname)
print(board_control.keybuffer)
return True
return False
def _init(cls):
cls.widgets = uistuff.GladeWidgets("newInOut.glade")
cls.widgets["newgamedialog"].set_transient_for(
gamewidget.getWidgets()["main_window"])
uistuff.createCombo(cls.widgets["whitePlayerCombobox"],
name="whitePlayerCombobox")
uistuff.createCombo(cls.widgets["blackPlayerCombobox"],
name="blackPlayerCombobox")
cls.widgets["playersIcon"].set_from_pixbuf(big_people)
cls.widgets["timeIcon"].set_from_pixbuf(big_time)
def on_playerCombobox_changed(widget, skill_hbox):
skill_hbox.props.visible = widget.get_active() > 0
cls.widgets["whitePlayerCombobox"].connect("changed",
on_playerCombobox_changed,
cls.widgets["skillHbox1"])
cls.widgets["blackPlayerCombobox"].connect("changed",
on_playerCombobox_changed,
cls.widgets["skillHbox2"])
cls.widgets["whitePlayerCombobox"].set_active(0)
cls.widgets["blackPlayerCombobox"].set_active(1)
def on_skill_changed(scale, image):
image.set_from_pixbuf(skillToIcon[int(scale.get_value())])
cls.widgets["skillSlider1"].connect("value-changed", on_skill_changed,
cls.widgets["skillIcon1"])
cls.widgets["skillSlider2"].connect("value-changed", on_skill_changed,
cls.widgets["skillIcon2"])
cls.widgets["skillSlider1"].set_value(3)
cls.widgets["skillSlider2"].set_value(3)
cls.__initTimeRadio(_("Blitz"), "ngblitz", cls.widgets["blitzRadio"],
cls.widgets["configImageBlitz"], 5, 0, 0)
cls.__initTimeRadio(_("Rapid"), "ngrapid", cls.widgets["rapidRadio"],
cls.widgets["configImageRapid"], 15, 5, 0)
cls.__initTimeRadio(_("Normal"), "ngnormal",
cls.widgets["normalRadio"],
cls.widgets["configImageNormal"], 40, 15, 0)
cls.__initTimeRadio(_("Classical"), "ngclassical",
cls.widgets["classicalRadio"],
cls.widgets["configImageClassical"], 3, 0, 40)
cls.__initVariantRadio("ngvariant1", cls.widgets["playVariant1Radio"],
cls.widgets["configImageVariant1"],
FISCHERRANDOMCHESS)
cls.__initVariantRadio("ngvariant2", cls.widgets["playVariant2Radio"],
cls.widgets["configImageVariant2"], LOSERSCHESS)
# @idle_add
def updateCombos(*args):
if cls.widgets["playNormalRadio"].get_active():
variant = NORMALCHESS
elif cls.widgets["playVariant1Radio"].get_active():
variant = conf.get("ngvariant1", FISCHERRANDOMCHESS)
else:
variant = conf.get("ngvariant2", LOSERSCHESS)
variant1 = conf.get("ngvariant1", FISCHERRANDOMCHESS)
cls.widgets["playVariant1Radio"].set_tooltip_text(
variants[variant1].__desc__)
variant2 = conf.get("ngvariant2", LOSERSCHESS)
cls.widgets["playVariant2Radio"].set_tooltip_text(
variants[variant2].__desc__)
data = [(item[0], item[1]) for item in playerItems[variant]]
uistuff.updateCombo(cls.widgets["blackPlayerCombobox"], data)
uistuff.updateCombo(cls.widgets["whitePlayerCombobox"], data)
discoverer.connect_after("all_engines_discovered", updateCombos)
updateCombos(discoverer)
conf.notify_add("ngvariant1", updateCombos)
conf.notify_add("ngvariant2", updateCombos)
cls.widgets["playNormalRadio"].connect("toggled", updateCombos)
cls.widgets["playNormalRadio"].set_tooltip_text(
variants[NORMALCHESS].__desc__)
cls.widgets["playVariant1Radio"].connect("toggled", updateCombos)
variant1 = conf.get("ngvariant1", FISCHERRANDOMCHESS)
cls.widgets["playVariant1Radio"].set_tooltip_text(
variants[variant1].__desc__)
cls.widgets["playVariant2Radio"].connect("toggled", updateCombos)
variant2 = conf.get("ngvariant2", LOSERSCHESS)
cls.widgets["playVariant2Radio"].set_tooltip_text(
variants[variant2].__desc__)
# The "variant" has to come before players, because the engine positions
# in the user comboboxes can be different in different variants
for key in ("whitePlayerCombobox", "blackPlayerCombobox",
"skillSlider1", "skillSlider2", "notimeRadio",
"blitzRadio", "rapidRadio", "normalRadio",
"classicalRadio", "playNormalRadio", "playVariant1Radio",
"playVariant2Radio"):
uistuff.keep(cls.widgets[key], key)
# We don't want the dialog to deallocate when closed. Rather we hide
# it on respond
cls.widgets["newgamedialog"].connect("delete_event", lambda *a: True)
def on_properties1_activate(self, widget):
gameinfoDialog.run(gamewidget.getWidgets(), gameDic)
def on_gmwidg_title_changed(self, gmwidg, new_title):
# log.debug("gamenanny.on_gmwidg_title_changed: starting %s" % repr(gmwidg))
if gmwidg.isInFront():
getWidgets()['main_window'].set_title('%s - PyChess' % new_title)
# log.debug("gamenanny.on_gmwidg_title_changed: returning")
return False
def on_leave_fullscreen1_activate(self, widget):
gamewidget.getWidgets()["window1"].unfullscreen()
gamewidget.getWidgets()["leave_fullscreen1"].hide()
gamewidget.getWidgets()["fullscreen1"].show()
def on_fullscreen1_activate(self, widget):
gamewidget.getWidgets()["main_window"].fullscreen()
gamewidget.getWidgets()["fullscreen1"].hide()
gamewidget.getWidgets()["leave_fullscreen1"].show()
def on_manage_engines_activate(self, widget):
enginesDialog.run(gamewidget.getWidgets())
def on_about1_activate(self, widget):
about_dialog = gamewidget.getWidgets()["aboutdialog1"]
response = about_dialog.run()
if response == Gtk.ResponseType.DELETE_EVENT or response == Gtk.ResponseType.CANCEL:
gamewidget.getWidgets()["aboutdialog1"].hide()
def on_notebook2_switch_page (self, widget, page, page_num):
gamewidget.getWidgets()["notebook3"].set_current_page(page_num)
def on_gmwidg_closed(self, gmwidg):
perspective = perspective_manager.get_perspective("games")
if len(perspective.key2gmwidg) == 1:
getWidgets()["main_window"].set_title("%s - PyChess" %
_("Welcome"))
return False
