Localchat chatclient Python source

#!/usr/bin/python2.6
"""Frack Open Dag 2012 - Demonstratie chat client."""
__author__ = 'Elmer de Looff <elmer@underdark.nl>'
__version__ = '0.1'

# Standard modules
import datetime
import gtk
import os
import socket
import threading

PORT = 50001


class Localchat(object):
  def __init__(self):
    """Initializes the Localchat class.

    The quotes are read and stored, and the GUI is built after that.
    """
    self.last_message = 0
    self.username = None
    self.server = None
    # Set up the socket to use for writing
    self.sender = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    self.sender.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
    # Set up the socket used for receiving
    Receiver(self.AddMessage)
    # Start application, spawn windows
    self._MainWindow()
    self._ConfigureName()

    # Start the main GTK loop. This is required.
    # This call will NOT return, any code beyond this point is inaccessible.
    self._Main()

  def _MainWindow(self):
    """Builds the GUI and opens the main window."""
    # Initiate a GTK Builder from which the GUI will be built
    self.builder = gtk.Builder()
    # Load the `client.glade` file which holds the GUI configuration. This
    # particular construct loads the file from the exact same directory this
    # file is in, regardless of the diretory from which the file is called.
    self.builder.add_from_file(os.path.join(
        os.path.dirname(__file__), 'client.glade'))
    # Connecting the signals triggered by events (buttons etc) to the methods
    # of the Localchat class.
    self.builder.connect_signals(self)
    # Grab the object `localchat` (this is the main window) and make it visible.
    self.builder.get_object('localchat').show()

  def _ConfigureName(self, *_args):
    settings = self.builder.get_object('settings')
    settings.connect('delete-event', settings.hide_on_delete)
    settings.show()

  @staticmethod
  def _Exit(*_args):
    """Gracefully exit the application."""
    raise SystemExit

  def _Main(self):
    # Start threaded operation and start the GTK main loop.
    # to user actions on the GUI.
    gtk.gdk.threads_init()
    gtk.main()

  def GetMessages(self, *_args):
    """This outputs a random quote to the display box."""
    # `random.choice` grabs a random item from a list of items.
    message_url = '%s/json/from/%s' % (self.server, self.last_message)
    messages = urllib2.urlopen(message_url).read()
    for message in cjson.decode(messages):
      self.AddMessage(message)

  def AddMessage(self, message):
    now = datetime.datetime.now()
    label = gtk.Label('%s %s' % (now.strftime('%H:%M'), message))
    msg_vbox = self.builder.get_object('messages')
    msg_vbox.pack_start(label, False, False)
    label.set_alignment(0, 0)
    label.set_line_wrap(True)
    label.show()

  def _SendMessage(self, *_args):
    message = self.builder.get_object('input_message').get_text()
    self.builder.get_object('input_message').set_text('')
    self.SendMessage('<%s> %s' % (self.username, message))

  def SendMessage(self, message):
    self.sender.sendto(message, ('<broadcast>', PORT))

  def SaveSettings(self, *_args):
    self.username = self.builder.get_object('input_username').get_text()
    self.builder.get_object('settings').hide()
    self.SendMessage('* %s joined the chat' % self.username)


class Receiver(threading.Thread):
  def __init__(self, callback):
    super(Receiver, self).__init__(name='Receiver')
    self.daemon = True
    self.callback = callback
    self.start()

  def run(self):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.settimeout(0.1)
    sock.bind(('', PORT))
    while True:
      try:
        self.callback(sock.recv(65536))
      except socket.error:
        pass


def main():
  Localchat()


if __name__ == '__main__':
  main()