def __init__(self, connection):
GObject.GObject.__init__(self)
self.connection = connection
self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
vbox = Gtk.VBox()
self.add_with_viewport(vbox)
self.get_child().set_shadow_type(Gtk.ShadowType.NONE)
self.joinedList = TextImageTree("gtk-remove")
self.joinedList.connect("activated", self.onRemove)
self.joinedList.connect("selected", self.onSelect)
vbox.pack_start(self.joinedList, True, True, 0)
expander = Gtk.Expander.new(_("More channels"))
vbox.pack_start(expander, False, True, 0)
self.channelsList = TextImageTree("gtk-add")
self.channelsList.connect("activated", self.onAdd)
self.channelsList.fixed_height_mode = True
expander.add(self.channelsList)
expander = Gtk.Expander.new(_("More players"))
vbox.pack_start(expander, False, True, 0)
self.playersList = TextImageTree("gtk-add")
self.playersList.connect("activated", self.onAdd)
self.playersList.fixed_height_mode = True
glock_connect(connection.cm,
"privateMessage",
self.onPersonMessage,
after=True)
glock_connect(connection.cm, "channelsListed", self.onChannelsListed)
expander.add(self.playersList)
self.channels = {}
def load(self, gmwidg):
self.chatView = ChatView()
self.chatView.disable("Waiting for game to load")
self.chatView.connect("messageTyped", self.onMessageSent)
self.gamemodel = gmwidg.gamemodel
glock.glock_connect(self.gamemodel, "game_started", self.onGameStarted)
return self.chatView
def __init__ (self, connection):
gtk.ScrolledWindow.__init__(self)
self.connection = connection
self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
vbox = gtk.VBox()
self.add_with_viewport(vbox)
self.child.set_shadow_type(gtk.SHADOW_NONE)
self.joinedList = TextImageTree("gtk-remove")
self.joinedList.connect("activated", self.onRemove)
self.joinedList.connect("selected", self.onSelect)
vbox.pack_start(self.joinedList)
expander = gtk.Expander(_("More channels"))
vbox.pack_start(expander, expand=False)
self.channelsList = TextImageTree("gtk-add")
self.channelsList.connect("activated", self.onAdd)
self.channelsList.fixed_height_mode = True
expander.add(self.channelsList)
expander = gtk.Expander(_("More players"))
vbox.pack_start(expander, expand=False)
self.playersList = TextImageTree("gtk-add")
self.playersList.connect("activated", self.onAdd)
self.playersList.fixed_height_mode = True
glock_connect(connection.cm, "privateMessage", self.onPersonMessage, after=True)
expander.add(self.playersList)
def load (self, gmwidg):
self.chatView = ChatView()
self.chatView.disable("Waiting for game to load")
self.chatView.connect("messageTyped", self.onMessageSent)
self.gamemodel = gmwidg.gamemodel
glock.glock_connect(self.gamemodel, "game_started", self.onGameStarted)
return self.chatView
def __init__ (self, connection):
gtk.ScrolledWindow.__init__(self)
self.connection = connection
self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
vbox = gtk.VBox()
self.add_with_viewport(vbox)
self.child.set_shadow_type(gtk.SHADOW_NONE)
self.joinedList = TextImageTree("gtk-remove")
self.joinedList.connect("activated", self.onRemove)
self.joinedList.connect("selected", self.onSelect)
vbox.pack_start(self.joinedList)
expander = gtk.Expander(_("More channels"))
vbox.pack_start(expander, expand=False)
self.channelsList = TextImageTree("gtk-add")
self.channelsList.connect("activated", self.onAdd)
self.channelsList.fixed_height_mode = True
expander.add(self.channelsList)
expander = gtk.Expander(_("More players"))
vbox.pack_start(expander, expand=False)
self.playersList = TextImageTree("gtk-add")
self.playersList.connect("activated", self.onAdd)
self.playersList.fixed_height_mode = True
glock_connect(connection.cm, "privateMessage", self.onPersonMessage, after=True)
expander.add(self.playersList)
def __init__ (self, connection):
GObject.GObject.__init__(self)
self.connection = connection
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
vbox = Gtk.VBox()
self.add_with_viewport(vbox)
self.get_child().set_shadow_type(Gtk.ShadowType.NONE)
self.joinedList = TextImageTree("gtk-remove")
self.joinedList.connect("activated", self.onRemove)
self.joinedList.connect("selected", self.onSelect)
vbox.pack_start(self.joinedList, True, True, 0)
expander = Gtk.Expander.new(_("More channels"))
vbox.pack_start(expander, False, True, 0)
self.channelsList = TextImageTree("gtk-add")
self.channelsList.connect("activated", self.onAdd)
self.channelsList.fixed_height_mode = True
expander.add(self.channelsList)
expander = Gtk.Expander.new(_("More players"))
vbox.pack_start(expander, False, True, 0)
self.playersList = TextImageTree("gtk-add")
self.playersList.connect("activated", self.onAdd)
self.playersList.fixed_height_mode = True
glock_connect(connection.cm, "privateMessage", self.onPersonMessage, after=True)
glock_connect(connection.cm, "channelsListed", self.onChannelsListed)
expander.add(self.playersList)
self.channels = {}
def players_changed(self, gamemodel):
log.debug("GameWidget.players_changed: starting %s" % repr(gamemodel))
for player in gamemodel.players:
self.name_changed(player)
# Notice that this may connect the same player many times. In
# normal use that shouldn't be a problem.
glock_connect(player, "name_changed", self.name_changed)
log.debug("GameWidget.players_changed: returning")
def players_changed (self, gamemodel):
log.debug("GameWidget.players_changed: starting %s" % repr(gamemodel))
for player in gamemodel.players:
self.name_changed(player)
# Notice that this may connect the same player many times. In
# normal use that shouldn't be a problem.
glock_connect(player, "name_changed", self.name_changed)
log.debug("GameWidget.players_changed: returning")
def onConnected (self, connection):
self.lounge = ICLounge(connection, self.helperconn, self.host)
self.hide()
self.lounge.show()
self.lounge.connect("logout", lambda iclounge: self.onDisconnected(None))
glock.glock_connect(self.lounge, "autoLogout", lambda iclounge: self.onAutologout(None))
self.showNormal()
self.widgets["messagePanel"].hide()
def __init__(self, gamemodel=None):
gtk.DrawingArea.__init__(self)
if gamemodel == None:
gamemodel = GameModel()
self.model = gamemodel
glock_connect(self.model, "game_started", self.game_started)
glock_connect_after(self.model, "game_started",
self.game_started_after)
glock_connect_after(self.model, "game_changed", self.game_changed)
glock_connect_after(self.model, "moves_undoing", self.moves_undoing)
glock_connect_after(self.model, "game_loading", self.game_loading)
glock_connect_after(self.model, "game_loaded", self.game_loaded)
glock_connect_after(self.model, "game_ended", self.game_ended)
self.connect("expose_event", self.expose)
self.connect_after("realize", self.on_realized)
conf.notify_add("showCords", self.on_show_cords)
conf.notify_add("faceToFace", self.on_face_to_face)
self.set_size_request(350, 350)
self.animationStart = time()
self.lastShown = None
self.deadlist = []
self.autoUpdateShown = True
self.padding = 0 # Set to self.pad when setcords is active
self.square = 0, 0, 8, 1 # An object global variable with the current
# board size
self.pad = 0.13 # Padding applied only when setcords is active
self._selected = None
self._hover = None
self._active = None
self._redarrow = None
self._greenarrow = None
self._bluearrow = None
self._shown = self.model.ply
self._showCords = False
self.showCords = conf.get("showCords", False)
self._showEnpassant = False
self.lastMove = None
self.matrix = cairo.Matrix()
self.matrixPi = cairo.Matrix.init_rotate(pi)
self.cordMatricesState = (0, 0)
self._rotation = 0
self.drawcount = 0
self.drawtime = 0
self.gotStarted = False
self.animationLock = RLock()
self.rotationLock = Lock()
self.draggedPiece = None # a piece being dragged by the user
def __init__(self, gamemodel=None):
gtk.DrawingArea.__init__(self)
if gamemodel == None:
gamemodel = GameModel()
self.model = gamemodel
glock_connect(self.model, "game_started", self.game_started)
glock_connect_after(self.model, "game_started", self.game_started_after)
glock_connect_after(self.model, "game_changed", self.game_changed)
glock_connect_after(self.model, "moves_undoing", self.moves_undoing)
glock_connect_after(self.model, "game_loading", self.game_loading)
glock_connect_after(self.model, "game_loaded", self.game_loaded)
glock_connect_after(self.model, "game_ended", self.game_ended)
self.connect("expose_event", self.expose)
self.connect_after("realize", self.on_realized)
conf.notify_add("showCords", self.on_show_cords)
conf.notify_add("faceToFace", self.on_face_to_face)
self.set_size_request(350,350)
self.animationStart = time()
self.lastShown = None
self.deadlist = []
self.autoUpdateShown = True
self.padding = 0 # Set to self.pad when setcords is active
self.square = 0, 0, 8, 1 # An object global variable with the current
# board size
self.pad = 0.13 # Padding applied only when setcords is active
self._selected = None
self._hover = None
self._active = None
self._redarrow = None
self._greenarrow = None
self._bluearrow = None
self._shown = self.model.ply
self._showCords = False
self.showCords = conf.get("showCords", False)
self._showEnpassant = False
self.lastMove = None
self.matrix = cairo.Matrix()
self.matrixPi = cairo.Matrix.init_rotate(pi)
self.cordMatricesState = (0, 0)
self._rotation = 0
self.drawcount = 0
self.drawtime = 0
self.gotStarted = False
self.animationLock = RLock()
self.rotationLock = Lock()
self.draggedPiece = None # a piece being dragged by the user
def onConnected(self, connection):
self.lounge = ICLounge(connection)
self.hide()
self.lounge.show()
self.lounge.connect("logout",
lambda iclounge: self.onDisconnected(None))
glock.glock_connect(self.lounge, "autoLogout",
lambda iclounge: self.onAutologout(None))
self.showNormal()
self.widgets["messagePanel"].hide()
def __init__ (self, widgets, connection):
self.connection = connection
self.window = None
widgets["show_chat_button"].connect("clicked", self.showChat)
glock_connect(connection.cm, "privateMessage",
self.onPersonMessage, after=False)
glock_connect(connection, "disconnected",
lambda c: self.window and self.window.hide())
self.viewspanel = ViewsPanel(self.connection)
self.channelspanel = ChannelsPanel(self.connection)
self.infopanel = InfoPanel(self.connection)
self.panels = [self.viewspanel, self.channelspanel, self.infopanel]
def __init__ (self, widgets, connection):
self.connection = connection
self.window = None
widgets["show_chat_button"].connect("clicked", self.showChat)
glock_connect(connection.cm, "privateMessage",
self.onPersonMessage, after=False)
glock_connect(connection, "disconnected",
lambda c: self.window and self.window.hide())
self.viewspanel = ViewsPanel(self.connection)
self.channelspanel = ChannelsPanel(self.connection)
self.infopanel = InfoPanel(self.connection)
self.panels = [self.viewspanel, self.channelspanel, self.infopanel]
def load(self, gmwidg):
self.boardview = gmwidg.board.view
self.plot = ScorePlot(self.boardview)
self.sw = __widget__ = Gtk.ScrolledWindow()
__widget__.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
port = Gtk.Viewport()
port.add(self.plot)
port.set_shadow_type(Gtk.ShadowType.NONE)
__widget__.add(port)
__widget__.show_all()
self.plot.connect("selected", self.plot_selected)
self.boardview.connect('shown_changed', self.shown_changed)
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "moves_undoing",
self.moves_undoing)
glock_connect(self.boardview.model, "analysis_changed",
self.analysis_changed)
# Add the initial board
glock_connect(self.boardview.model, "game_started", self.game_changed)
uistuff.keepDown(__widget__)
return __widget__
def onConnectClicked (self, button):
self.canceled = False
self.widgets["messagePanel"].hide()
if self.widgets["logOnAsGuest"].get_active():
username = self.widgets["nameEntry"].get_text()
password = ""
else:
username = self.widgets["nameEntry"].get_text()
password = self.widgets["passEntry"].get_text()
if port:
ports = (port,)
else:
ports = self.widgets["portsEntry"].get_text()
ports = list(map(int, re.findall("\d+", ports)))
if not 5000 in ports: ports.append(5000)
if not 23 in ports: ports.append(23)
self.showConnecting()
self.host = host if host is not None else "freechess.org"
self.connection = FICSMainConnection(self.host, ports, username, password)
self.helperconn = FICSHelperConnection(self.connection, self.host, ports)
self.helperconn.start()
for signal, callback in (("connected", self.onConnected),
("error", self.onConnectionError),
("connectingMsg", self.showMessage)):
self.cids[self.connection].append(
glock_connect(self.connection, signal, callback))
self.connection.start()
def onConnectClicked(self, button):
self.canceled = False
self.widgets["messagePanel"].hide()
if self.widgets["logOnAsGuest"].get_active():
username = self.widgets["nameEntry"].get_text()
password = ""
else:
username = self.widgets["nameEntry"].get_text()
password = self.widgets["passEntry"].get_text()
if port:
ports = (port, )
else:
ports = self.widgets["portsEntry"].get_text()
ports = list(map(int, re.findall("\d+", ports)))
if not 5000 in ports: ports.append(5000)
if not 23 in ports: ports.append(23)
self.showConnecting()
self.host = host if host is not None else "freechess.org"
self.connection = FICSMainConnection(self.host, ports, username,
password)
self.helperconn = FICSHelperConnection(self.connection, self.host,
ports)
self.helperconn.start()
for signal, callback in (("connected", self.onConnected),
("error", self.onConnectionError),
("connectingMsg", self.showMessage)):
self.cids[self.connection].append(
glock_connect(self.connection, signal, callback))
self.connection.start()
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)
glock_connect(connection, "disconnected",
lambda c: self.window and self.window.hide())
def __init__ (self, id, text, chatView, connection):
gtk.Alignment.__init__(self, xscale=1, yscale=1)
self.add(gtk.Label(_("Loading player data")))
self.fm = connection.fm
self.handle_id = glock_connect(self.fm, "fingeringFinished",
self.onFingeringFinished, text)
self.fm.finger(text)
def onConnected (self, connection):
self.lounge = ICLounge(connection, self.helperconn, self.host)
self.hide()
self.lounge.show()
self.lounge.connect("logout", lambda iclounge: self.onLogout(connection))
self.cids[self.lounge].append(glock_connect(self.lounge, "autoLogout",
lambda lounge: self.onAutologout(connection)))
self.showNormal()
self.widgets["messagePanel"].hide()
def __init__ (self, id, text, chatView, connection):
GObject.GObject.__init__(self, xscale=1, yscale=1)
self.add(Gtk.Label(label=_("Loading player data")))
playername = get_playername(text)
self.fm = connection.fm
self.handle_id = glock_connect(self.fm, "fingeringFinished",
self.onFingeringFinished, playername)
self.fm.finger(playername)
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)
glock_connect(connection, "disconnected",
lambda c: self.window and self.window.hide())
def __init__(self, id, text, chatView, connection):
GObject.GObject.__init__(self, xscale=1, yscale=1)
self.add(Gtk.Label(label=_("Loading player data")))
playername = get_playername(text)
self.fm = connection.fm
self.handle_id = glock_connect(self.fm, "fingeringFinished",
self.onFingeringFinished,
playername)
self.fm.finger(playername)
def onConnected(self, connection):
self.lounge = ICLounge(connection, self.helperconn, self.host)
self.hide()
self.lounge.show()
self.lounge.connect("logout",
lambda iclounge: self.onLogout(connection))
self.cids[self.lounge].append(
glock_connect(self.lounge, "autoLogout",
lambda lounge: self.onAutologout(connection)))
self.showNormal()
self.widgets["messagePanel"].hide()
def load (self, gmwidg):
self.plot = ScorePlot()
__widget__ = gtk.ScrolledWindow()
__widget__.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
port = gtk.Viewport()
port.add(self.plot)
port.set_shadow_type(gtk.SHADOW_NONE)
__widget__.add(port)
__widget__.show_all()
self.boardview = gmwidg.board.view
self.plot.connect("selected", self.plot_selected)
self.boardview.connect('shown_changed', self.shown_changed)
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "moves_undoing", self.moves_undoing)
# Add the initial board
glock_connect(self.boardview.model, "game_started", self.game_changed)
def changed (vadjust):
if not hasattr(vadjust, "need_scroll") or vadjust.need_scroll:
vadjust.set_value(vadjust.upper-vadjust.page_size)
vadjust.need_scroll = True
__widget__.get_vadjustment().connect("changed", changed)
def value_changed (vadjust):
vadjust.need_scroll = abs(vadjust.value + vadjust.page_size - \
vadjust.upper) < vadjust.step_increment
__widget__.get_vadjustment().connect("value-changed", value_changed)
return __widget__
def load (self, gmwidg):
# Specify whether the panel should have a horizontal layout:
horizontal = True
if horizontal:
self.box = Gtk.HBox()
else:
self.box = Gtk.VBox()
__widget__ = self.box
# Use two engine output widgets for each player color:
self.output_white = EngineOutput(True)
self.output_black = EngineOutput(False)
if horizontal:
self.output_separator = Gtk.VSeparator()
else:
self.output_separator = Gtk.HSeparator()
self.output_noengines = Gtk.TextView()
self.output_noengines.get_buffer().set_text(
_("No chess engines (computer players) are participating in this game."))
self.output_noengines.set_editable(False)
self.output_noengines.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
__widget__.pack_start(self.output_noengines, True, True, 0)
__widget__.show_all()
self.boardview = gmwidg.board.view
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "players_changed", self.players_changed)
glock_connect(self.boardview.model, "game_started", self.game_changed)
return __widget__
def onConnectClicked (self, button):
if self.widgets["logOnAsGuest"].get_active():
username = "******"
password = ""
else:
username = self.widgets["nameEntry"].get_text()
password = self.widgets["passEntry"].get_text()
if port:
ports = (port,)
else:
ports = self.widgets["portsEntry"].get_text()
ports = map(int, re.findall("\d+", ports))
if not 5000 in ports: ports.append(5000)
if not 23 in ports: ports.append(23)
self.showConnecting()
self.host = host if host is not None else "freechess.org"
self.connection = FICSConnection(self.host, ports, username, password)
self.helperconn = FICSConnection(self.host, ports, "guest", "", conn=self.connection)
self.helperconn.start()
glock.glock_connect(self.connection, "connected", self.onConnected)
glock.glock_connect(self.connection, "error", self.showError)
glock.glock_connect(self.connection, "connectingMsg", self.showMessage)
self.connection.start()
def __init__ (self, id, text, chatView, connection):
GObject.GObject.__init__(self, xscale=1, yscale=1)
self.cm = connection.cm
self.add(Gtk.Label(label=_("Receiving list of players")))
chatView.connect("messageAdded", self.onMessageAdded)
self.store = Gtk.ListStore(object, # (r,g,b) Color tuple
str, # name string
bool # is separator
)
self.handle_id = glock_connect(self.cm, "recievedNames",
self.onNamesRecieved, id)
self.cm.getPeopleInChannel(id)
def __init__ (self, id, text, chatView, connection):
gtk.Alignment.__init__(self, xscale=1, yscale=1)
self.cm = connection.cm
self.add(gtk.Label(_("Receiving list of players")))
chatView.connect("messageAdded", self.onMessageAdded)
self.store = gtk.ListStore(object, # (r,g,b) Color tuple
str, # name string
bool # is separator
)
self.handle_id = glock_connect(self.cm, "recievedNames",
self.onNamesRecieved, id)
self.cm.getPeopleInChannel(id)
def load (self, gmwidg):
self.boardview = gmwidg.board.view
self.plot = ScorePlot(self.boardview)
self.sw = __widget__ = Gtk.ScrolledWindow()
__widget__.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
port = Gtk.Viewport()
port.add(self.plot)
port.set_shadow_type(Gtk.ShadowType.NONE)
__widget__.add(port)
__widget__.show_all()
self.plot.connect("selected", self.plot_selected)
self.boardview.connect('shown_changed', self.shown_changed)
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "moves_undoing", self.moves_undoing)
glock_connect(self.boardview.model, "analysis_changed", self.analysis_changed)
# Add the initial board
glock_connect(self.boardview.model, "game_started", self.game_changed)
uistuff.keepDown(__widget__)
return __widget__
def init (cls, discoverer):
assert not hasattr(cls, "widgets"), "Show can only be called once"
cls.widgets = uistuff.GladeWidgets("discovererDialog.glade")
#=======================================================================
# Clear glade defaults
#=======================================================================
for child in cls.widgets["enginesTable"].get_children():
cls.widgets["enginesTable"].remove(child)
#=======================================================================
# Connect us to the discoverer
#=======================================================================
glock_connect(discoverer, "discovering_started", cls._onDiscoveringStarted)
glock_connect(discoverer, "engine_discovered", cls._onEngineDiscovered)
glock_connect(discoverer, "all_engines_discovered", cls._onAllEnginesDiscovered)
cls.finished = False
def init (cls, discoverer):
assert not hasattr(cls, "widgets"), "Show can only be called once"
cls.widgets = uistuff.GladeWidgets("discovererDialog.glade")
#=======================================================================
# Clear glade defaults
#=======================================================================
for child in cls.widgets["enginesTable"].get_children():
cls.widgets["enginesTable"].remove(child)
#=======================================================================
# Connect us to the discoverer
#=======================================================================
glock_connect(discoverer, "discovering_started", cls._onDiscoveringStarted)
glock_connect(discoverer, "engine_discovered", cls._onEngineDiscovered)
glock_connect(discoverer, "all_engines_discovered", cls._onAllEnginesDiscovered)
cls.finished = False
cls.throbber = None
def onConnectClicked(self, button):
if self.widgets["logOnAsGuest"].get_active():
username = "******"
password = ""
else:
username = self.widgets["nameEntry"].get_text()
password = self.widgets["passEntry"].get_text()
ports = self.widgets["portsEntry"].get_text()
ports = map(int, re.findall("\d+", ports))
if not 23 in ports: ports.append(23)
if not 5000 in ports: ports.append(5000)
self.showConnecting()
self.connection = FICSConnection("freechess.org", ports, username,
password)
glock.glock_connect(self.connection, "connected", self.onConnected)
glock.glock_connect(self.connection, "error", self.showError)
glock.glock_connect(self.connection, "connectingMsg", self.showMessage)
self.connection.start()
def addItem (self, id, name, type, chatView):
chatView.connect("messageTyped", self.onMessageTyped, id, name, type)
glock_connect(self.connection.cm, "channelMessage",
self.onChannelMessage, id, chatView)
glock_connect(self.connection.cm, "privateMessage",
self.onPersonMessage, get_playername(name), chatView)
if type == TYPE_CHANNEL:
glock_connect(self.connection.cm, "channelLog",
self.onChannelLog, id, chatView)
self.connection.cm.getChannelLog(id)
if not self.connection.cm.mayTellChannel(id):
chatView.disable(_("Only registered users may talk to this channel"))
elif type == TYPE_PERSONAL:
if name in self.messageBuffer:
for title, isadmin, messagetext in self.messageBuffer[name]:
chatView.addMessage(name, messagetext)
del self.messageBuffer[name]
self.addPage(chatView, id)
def addItem (self, id, name, type, chatView):
chatView.connect("messageTyped", self.onMessageTyped, id, name, type)
glock_connect(self.connection.cm, "channelMessage",
self.onChannelMessage, id, chatView)
glock_connect(self.connection.cm, "privateMessage",
self.onPersonMessage, name, chatView)
if type == TYPE_CHANNEL:
glock_connect(self.connection.cm, "channelLog",
self.onChannelLog, id, chatView)
self.connection.cm.getChannelLog(id)
if not self.connection.cm.mayTellChannel(id):
chatView.disable(_("Only registered users may talk to this channel"))
elif type == TYPE_PERSONAL:
if name in self.messageBuffer:
for title, isadmin, messagetext in self.messageBuffer[name]:
chatView.addMessage(name, messagetext)
del self.messageBuffer[name]
self.addPage(chatView, id)
def load(self, gmwidg):
# Specify whether the panel should have a horizontal layout:
horizontal = True
if horizontal:
self.box = Gtk.HBox()
else:
self.box = Gtk.VBox()
__widget__ = self.box
# Use two engine output widgets for each player color:
self.output_white = EngineOutput(True)
self.output_black = EngineOutput(False)
if horizontal:
self.output_separator = Gtk.VSeparator()
else:
self.output_separator = Gtk.HSeparator()
self.output_noengines = Gtk.TextView()
self.output_noengines.get_buffer().set_text(
_("No chess engines (computer players) are participating in this game."
))
self.output_noengines.set_editable(False)
self.output_noengines.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
__widget__.pack_start(self.output_noengines, True, True, 0)
__widget__.show_all()
self.boardview = gmwidg.board.view
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "players_changed",
self.players_changed)
glock_connect(self.boardview.model, "game_started", self.game_changed)
return __widget__
def load(self, gmwidg):
__widget__ = Gtk.ScrolledWindow()
__widget__.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
__widget__.add(self.textview)
self.boardview = gmwidg.board.view
self.boardview.connect("shown_changed", self.shown_changed)
self.gamemodel = gmwidg.board.view.model
glock_connect(self.gamemodel, "game_loaded", self.update)
glock_connect(self.gamemodel, "game_changed", self.game_changed)
glock_connect(self.gamemodel, "game_started", self.update)
glock_connect(self.gamemodel, "game_ended", self.update)
glock_connect(self.gamemodel, "moves_undoing", self.moves_undoing)
glock_connect(self.gamemodel, "opening_changed", self.update)
glock_connect(self.gamemodel, "players_changed", self.players_changed)
glock_connect(self.gamemodel, "variation_added", self.variation_added)
glock_connect(self.gamemodel, "variation_extended", self.variation_extended)
glock_connect(self.gamemodel, "analysis_changed", self.analysis_changed)
# Connect to preferences
self.fan = conf.get("figuresInNotation", False)
def figuresInNotationCallback(none):
self.fan = conf.get("figuresInNotation", False)
self.update()
conf.notify_add("figuresInNotation", figuresInNotationCallback)
# Elapsed move time
self.showEmt = conf.get("showEmt", False)
def showEmtCallback(none):
self.showEmt = conf.get("showEmt", False)
self.update()
conf.notify_add("showEmt", showEmtCallback)
# Blunders
self.showBlunder = conf.get("showBlunder", False)
def showBlunderCallback(none):
self.showBlunder = conf.get("showBlunder", False)
self.update()
conf.notify_add("showBlunder", showBlunderCallback)
# Eval values
self.showEval = conf.get("showEval", False)
def showEvalCallback(none):
self.showEval = conf.get("showEval", False)
self.update()
conf.notify_add("showEval", showEvalCallback)
return __widget__
def load(self, gmwidg):
widgets = gtk.glade.XML(addDataPrefix("sidepanel/history.glade"))
__widget__ = widgets.get_widget("panel")
__widget__.unparent()
self.board = gmwidg.board.view
glock_connect(self.board.model, "game_changed", self.game_changed)
glock_connect(self.board.model, "game_started", self.game_changed)
glock_connect(self.board.model, "moves_undoing", self.moves_undoing)
self.board.connect("shown_changed", self.shown_changed)
# Initialize treeviews
self.numbers = widgets.get_widget("treeview1")
self.left = widgets.get_widget("treeview2")
self.right = widgets.get_widget("treeview3")
def fixList(list, xalign=0):
list.set_model(gtk.ListStore(str))
renderer = gtk.CellRendererText()
renderer.set_property("xalign", xalign)
list.append_column(gtk.TreeViewColumn(None, renderer, text=0))
list.get_selection().set_mode(gtk.SELECTION_SINGLE)
fixList(self.numbers, 1)
fixList(self.left, 0)
fixList(self.right, 0)
self.left.get_selection().connect('changed', self.on_selection_changed,
self.left, 0)
self.right.get_selection().connect('changed',
self.on_selection_changed,
self.right, 1)
widgets.signal_autoconnect({
"on_treeview2_key_press_event":
lambda w, e: self.key_press_event(1, e),
"on_treeview3_key_press_event":
lambda w, e: self.key_press_event(2, e)
})
# Lock scrolling
scrollwin = widgets.get_widget("panel")
def changed(vadjust):
if not hasattr(vadjust, "need_scroll") or vadjust.need_scroll:
vadjust.set_value(vadjust.upper - vadjust.page_size)
vadjust.need_scroll = True
scrollwin.get_vadjustment().connect("changed", changed)
def value_changed(vadjust):
vadjust.need_scroll = abs(vadjust.value + vadjust.page_size - \
vadjust.upper) < vadjust.step_increment
scrollwin.get_vadjustment().connect("value-changed", value_changed)
# Connect to preferences
def figuresInNotationCallback(none):
game = self.board.model
for board, move in zip(game.boards, game.moves):
if conf.get("figuresInNotation", False):
notat = toFAN(board, move)
else:
notat = toSAN(board, move, True)
row, col, other = self._ply_to_row_col_other(board.ply + 1)
iter = col.get_model().get_iter((row, ))
col.get_model().set(iter, 0, notat)
conf.notify_add("figuresInNotation", figuresInNotationCallback)
# Return
return __widget__
def load(self, gmwidg):
widgets = Gtk.Builder()
widgets.add_from_file(addDataPrefix("sidepanel/history.glade"))
__widget__ = widgets.get_object("panel")
__widget__.unparent()
self.boardview = gmwidg.board.view
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "game_started", self.game_changed)
glock_connect(self.boardview.model, "moves_undoing",
self.moves_undoing)
self.boardview.connect("shown_changed", self.shown_changed)
# Initialize treeviews
self.numbers = widgets.get_object("treeview1")
self.left = widgets.get_object("treeview2")
self.right = widgets.get_object("treeview3")
def fixList(list, xalign=0):
list.set_model(Gtk.ListStore(str))
renderer = Gtk.CellRendererText()
renderer.set_property("xalign", xalign)
list.append_column(Gtk.TreeViewColumn(None, renderer, text=0))
list.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
fixList(self.numbers, 1)
fixList(self.left, 0)
fixList(self.right, 0)
self.left.get_selection().connect('changed', self.on_selection_changed,
self.left, 0)
self.right.get_selection().connect('changed',
self.on_selection_changed,
self.right, 1)
# Lock scrolling
scrollwin = widgets.get_object("panel")
def changed(vadjust):
if not hasattr(vadjust, "need_scroll") or vadjust.need_scroll:
vadjust.set_value(vadjust.get_upper() -
vadjust.get_page_size())
vadjust.need_scroll = True
scrollwin.get_vadjustment().connect("changed", changed)
def value_changed(vadjust):
vadjust.need_scroll = abs(vadjust.get_value() + vadjust.get_page_size() - \
vadjust.get_upper()) < vadjust.get_step_increment()
scrollwin.get_vadjustment().connect("value-changed", value_changed)
# Connect to preferences
def figuresInNotationCallback(none):
game = self.boardview.model
for board, move in zip(game.variations[0], game.moves):
if conf.get("figuresInNotation", False):
notat = toFAN(board, move)
else:
notat = toSAN(board, move, True)
row, col, other = self._ply_to_row_col_other(board.ply + 1)
iter = col.get_model().get_iter((row, ))
col.get_model().set(iter, 0, notat)
conf.notify_add("figuresInNotation", figuresInNotationCallback)
# Return
return __widget__
def load (self, gmwidg):
widgets = Gtk.Builder()
widgets.add_from_file(addDataPrefix("sidepanel/history.glade"))
__widget__ = widgets.get_object("panel")
__widget__.unparent()
self.boardview = gmwidg.board.view
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "game_started", self.game_changed)
glock_connect(self.boardview.model, "moves_undoing", self.moves_undoing)
self.boardview.connect("shown_changed", self.shown_changed)
# Initialize treeviews
self.numbers = widgets.get_object("treeview1")
self.left = widgets.get_object("treeview2")
self.right = widgets.get_object("treeview3")
def fixList (list, xalign=0):
list.set_model(Gtk.ListStore(str))
renderer = Gtk.CellRendererText()
renderer.set_property("xalign",xalign)
list.append_column(Gtk.TreeViewColumn(None, renderer, text=0))
list.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
fixList(self.numbers, 1)
fixList(self.left, 0)
fixList(self.right, 0)
self.left.get_selection().connect('changed', self.on_selection_changed,
self.left, 0)
self.right.get_selection().connect('changed', self.on_selection_changed,
self.right, 1)
# Lock scrolling
scrollwin = widgets.get_object("panel")
def changed (vadjust):
if not hasattr(vadjust, "need_scroll") or vadjust.need_scroll:
vadjust.set_value(vadjust.get_upper()-vadjust.get_page_size())
vadjust.need_scroll = True
scrollwin.get_vadjustment().connect("changed", changed)
def value_changed (vadjust):
vadjust.need_scroll = abs(vadjust.get_value() + vadjust.get_page_size() - \
vadjust.get_upper()) < vadjust.get_step_increment()
scrollwin.get_vadjustment().connect("value-changed", value_changed)
# Connect to preferences
def figuresInNotationCallback (none):
game = self.boardview.model
for board, move in zip(game.variations[0], game.moves):
if conf.get("figuresInNotation", False):
notat = toFAN(board, move)
else: notat = toSAN(board, move, True)
row, col, other = self._ply_to_row_col_other(board.ply+1)
iter = col.get_model().get_iter((row,))
col.get_model().set(iter, 0, notat)
conf.notify_add("figuresInNotation", figuresInNotationCallback)
# Return
return __widget__
def load (self, gmwidg):
widgets = gtk.glade.XML(addDataPrefix("sidepanel/history.glade"))
__widget__ = widgets.get_widget("panel")
__widget__.unparent()
self.board = gmwidg.board.view
glock_connect(self.board.model, "game_changed", self.game_changed)
glock_connect(self.board.model, "game_started", self.game_changed)
glock_connect(self.board.model, "moves_undoing", self.moves_undoing)
self.board.connect("shown_changed", self.shown_changed)
# Initialize treeviews
self.numbers = widgets.get_widget("treeview1")
self.left = widgets.get_widget("treeview2")
self.right = widgets.get_widget("treeview3")
def fixList (list, xalign=0):
list.set_model(gtk.ListStore(str))
renderer = gtk.CellRendererText()
renderer.set_property("xalign",xalign)
list.append_column(gtk.TreeViewColumn(None, renderer, text=0))
list.get_selection().set_mode(gtk.SELECTION_SINGLE)
fixList(self.numbers, 1)
fixList(self.left, 0)
fixList(self.right, 0)
self.left.get_selection().connect('changed', self.on_selection_changed,
self.left, 0)
self.right.get_selection().connect('changed', self.on_selection_changed,
self.right, 1)
widgets.signal_autoconnect ({
"on_treeview2_key_press_event":lambda w,e:self.key_press_event(1,e),
"on_treeview3_key_press_event":lambda w,e:self.key_press_event(2,e)
})
# Lock scrolling
scrollwin = widgets.get_widget("panel")
def changed (vadjust):
if not hasattr(vadjust, "need_scroll") or vadjust.need_scroll:
vadjust.set_value(vadjust.upper-vadjust.page_size)
vadjust.need_scroll = True
scrollwin.get_vadjustment().connect("changed", changed)
def value_changed (vadjust):
vadjust.need_scroll = abs(vadjust.value + vadjust.page_size - \
vadjust.upper) < vadjust.step_increment
scrollwin.get_vadjustment().connect("value-changed", value_changed)
# Connect to preferences
def figuresInNotationCallback (none):
game = self.board.model
for board, move in zip(game.boards, game.moves):
if conf.get("figuresInNotation", False):
notat = toFAN(board, move)
else: notat = toSAN(board, move, True)
row, col, other = self._ply_to_row_col_other(board.ply+1)
iter = col.get_model().get_iter((row,))
col.get_model().set(iter, 0, notat)
conf.notify_add("figuresInNotation", figuresInNotationCallback)
# Return
return __widget__
