← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/gnome-games/gutsy

« back to all changes in this revision

Viewing changes to glchess/src/lib/main.py

  • Committer: Package Import Robot
  • Author(s): Aron Sisak
  • Date: 2007-08-28 11:17:57 UTC
  • mfrom: (1.1.35)
  • Revision ID: package-import@ubuntu.com-20070828111757-p1o9q24u57fbgkuq
Tags: 1:2.19.91-0ubuntu1
https://launchpad.net/bugs/94851
* New upstream release:
  - Sudoku:
    - Fix a crash when solving a sudoku, caused by a type mismatch (#470523).
  - Aisleriot:
    - Fix translation of "Autoplay" in Napoleons Tomb (#469363).
  - Gnometris:
    - Remove gaussian blur in background image to improve rendering performance.
  - Mahjongg:
    - Fix workaround for bug #353964. (LP: #94851)
* debian/patches/99_autoconf.patch:
  - Update via automagic

Show diffs side-by-side

added added

removed removed

Lines of Context:
glchess/src/lib/main.py
788
788
class Advert:
789
789
    pass
790
790
 
791
 
import xml.sax.saxutils;
 
791
import ConfigParser
 
792
 
 
793
class GGZServer:
 
794
    pass
 
795
 
 
796
class GGZConfig:
 
797
    
 
798
    def __init__(self):
 
799
        parser = ConfigParser.SafeConfigParser()
 
800
        parser.read(os.path.expanduser('~/.ggz/ggz-gtk.rc'))
 
801
        
 
802
        value = parser.get('Servers', 'profilelist')
 
803
        
 
804
        self.servers = []
 
805
        for n in value.replace('\\ ', '\x00').split(' '):
 
806
            server = GGZServer()
 
807
            server.name = n.replace('\x00', ' ')
 
808
            server.host = parser.get(server.name, 'Host')
 
809
            server.port = parser.getint(server.name, 'Port')
 
810
            server.login = parser.get(server.name, 'Login')
 
811
 
 
812
            self.servers.append(server)
 
813
            
 
814
            print (server.name, server.host, server.port, server.login)
792
815
 
793
816
class GGZConnection:
794
817
 
799
822
        self.sending = False
800
823
        self.players = {}
801
824
 
802
 
    def start(self):
803
 
        self.client.start()
 
825
    def start(self, login):
 
826
        self.client.start(login)
804
827
 
805
828
    def roomAdded(self, room):
806
829
        isChess = room.game is None or (room.game.protocol_engine == 'Chess' and room.game.protocol_version == '3')
848
871
 
849
872
    def onOutgoingData(self, data):
850
873
        print 'tx: %s' % repr(data)
851
 
        self.dialog.socket.send(data)
 
874
        self.dialog.send(data)
852
875
 
853
876
    def onChat(self, chatType, sender, text):
854
877
        self.dialog.controller.addText('%s: %s\n' % (sender, text), 'chat')
864
887
        self.protocol = ggz.Chess(self)
865
888
        self.decoder = ggz.Channel(self.protocol)
866
889
        
 
890
        self.isConnected = False
 
891
        self.buffer = ''
867
892
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
893
        self.socket.setblocking(False)
868
894
        ui.application.ioHandlers[self.socket.fileno()] = self
869
895
        ui.controller.watchFileDescriptor(self.socket.fileno())
870
 
        self.socket.connect(('gnome.ggzgamingzone.org', 5688))
871
 
        
 
896
        try:
 
897
            self.socket.connect(('localhost', 5688))
 
898
        except socket.error:
 
899
            # FIXME: Abort/retry if error
 
900
            if e.args[0] == errno.EINPROGRESS:
 
901
                print 'connecting...'
 
902
            else:
 
903
                print e
 
904
                
872
905
        self.send("<?xml version='1.0' encoding='UTF-8'?>\n<SESSION>\n<CHANNEL ID='glchess-test' /></SESSION>")
873
906
 
874
907
    def send(self, data):
875
908
        print 'tx-channel: %s' % repr(data)
876
 
        self.socket.send(data);
 
909
        origLength = len(self.buffer)
 
910
        
 
911
        self.buffer += data
 
912
        # FIXME: g_io_watch() doesn't seem to work for both read and write
 
913
        #if origLength == 0:
 
914
        #    self.ui.controller.writeFileDescriptor(self.socket.fileno())
 
915
        self.write()
 
916
        
 
917
    def write(self):
 
918
        nWritten = self.socket.send(self.buffer)
 
919
        print 'wrote %d octets' % nWritten
 
920
        self.buffer = self.buffer[nWritten:]
 
921
        return len(self.buffer) > 0
877
922
 
878
923
    def read(self):
879
 
        (data, address) = self.socket.recvfrom(65535)
880
 
        if len(data) == 0:
881
 
            # FIXME
882
 
            return False
883
 
        print 'rx-channel: %s' % repr(data)
884
 
        self.decoder.feed(data)
 
924
        try:
 
925
            (data, address) = self.socket.recvfrom(65535)
 
926
        except socket.error:
 
927
            print 'Error reading from channel'
 
928
        else:
 
929
            if len(data) == 0:
 
930
                print 'Disconnected'
 
931
                return False
 
932
            print 'rx-channel: %s' % repr(data)
 
933
            self.decoder.feed(data)
885
934
        return True
886
935
 
887
936
    def onSeat(self, seatNum, version):
941
990
    
942
991
    def __init__(self, ui):
943
992
        self.ui = ui
944
 
                
 
993
        self.buffer = ''
 
994
        self.profile = None
 
995
        self.socket = None
 
996
        
 
997
    def send(self, data):
 
998
        self.buffer += data
 
999
        try:
 
1000
            nSent = self.socket.send(self.buffer)
 
1001
        except socket.error:
 
1002
            nSent = 0
 
1003
        self.buffer = self.buffer[nSent:]
 
1004
 
 
1005
    def read(self):
 
1006
        try:
 
1007
            (data, address) = self.socket.recvfrom(65535)
 
1008
        except socket.error:
 
1009
            pass
 
1010
        else:
 
1011
            if len(data) == 0:
 
1012
                print 'disconnected'
 
1013
                return False
 
1014
            self.decoder.registerIncomingData(data)
 
1015
        return True
 
1016
    
 
1017
    def setProfile(self, profile):
 
1018
        if profile is None:
 
1019
            name = '(none)'
 
1020
        else:
 
1021
            name = profile.name
 
1022
        print 'Profile=%s' % name
 
1023
        
 
1024
        if self.socket is not None:
 
1025
            # FIXME: Unregister fd events
 
1026
            self.socket.close()
 
1027
        self.socket = None
 
1028
        
 
1029
        self.profile = profile
 
1030
        if profile is None:
 
1031
            return
 
1032
        
 
1033
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
1034
        self.socket.setblocking(False)
 
1035
        self.ui.application.ioHandlers[self.socket.fileno()] = self
 
1036
        self.ui.controller.watchFileDescriptor(self.socket.fileno())
 
1037
        try:
 
1038
            self.socket.connect((profile.host, profile.port))
 
1039
        except socket.error, e:
 
1040
            # FIXME: Abort/retry if error
 
1041
            if e.args[0] == errno.EINPROGRESS:
 
1042
                print 'connecting...'
 
1043
            else:
 
1044
                print e
 
1045
        
945
1046
        self.decoder = GGZConnection(self)
946
 
        
947
 
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
948
 
        ui.application.ioHandlers[self.socket.fileno()] = self
949
 
        ui.controller.watchFileDescriptor(self.socket.fileno())
950
 
        self.socket.connect(('gnome.ggzgamingzone.org', 5688))
951
 
        
952
 
        self.decoder.start()
953
 
        
954
 
    def read(self):
955
 
        (data, address) = self.socket.recvfrom(65535)
956
 
        self.decoder.registerIncomingData(data)
957
 
        return True
958
 
 
 
1047
        self.decoder.start(profile.login)
 
1048
    
959
1049
    def joinRoom(self, room):
960
1050
        self.decoder.client.joinRoom(room)
961
1051
    
965
1055
        
966
1056
    def startTable(self):
967
1057
        self.channel = GGZChannel(self.ui)
968
 
        self.decoder.client.startTable('30', 'glChess test game (do not join!)', 'glchess-test')
 
1058
        self.decoder.client.startTable(self.decoder.room.game.id, 'glChess test game (do not join!)', 'glchess-test')
969
1059
    
970
1060
    def sendChat(self, text):
971
1061
        self.decoder.client.sendChat(text)
984
1074
        """
985
1075
        self.controller = gtkui.GtkUI(self)
986
1076
        self.application = application
 
1077
        self.ggzConfig = GGZConfig()
987
1078
        
988
1079
        self.splashscreen = Splashscreen(self)
989
1080
        self.splashscreen.controller = self.controller.setDefaultView(self.splashscreen)
1004
1095
                self.application.ioHandlers.pop(fd)
1005
1096
            return result
1006
1097
 
 
1098
    def onWriteFileDescriptor(self, fd):
 
1099
        """Called by ui.UIFeedback"""
 
1100
        try:
 
1101
            handler = self.application.ioHandlers[fd]
 
1102
        except KeyError:
 
1103
            return False
 
1104
        else:
 
1105
            result = handler.write()
 
1106
            if result is False:
 
1107
                self.application.ioHandlers.pop(fd)
 
1108
            return result
 
1109
 
1007
1110
    def onGameStart(self, game):
1008
1111
        """Called by ui.UIFeedback"""
1009
1112
        if game.white.type == '':
1039
1142
        """Called by ui.UIFeedback"""
1040
1143
        dialog = GGZNetworkDialog(self)
1041
1144
        dialog.controller = self.controller.addNetworkDialog(dialog)
 
1145
        for server in self.ggzConfig.servers:
 
1146
            dialog.controller.addProfile(server, server.name)
1042
1147
 
1043
1148
    def onQuit(self):
1044
1149
        """Called by ui.UIFeedback"""
1110
1215
        fd = player.fileno()
1111
1216
        if fd is not None:
1112
1217
            self.ioHandlers.pop(fd)
 
1218
            
 
1219
    def addNetworkGame(self, name):
 
1220
        g = ChessGame(self, name)
 
1221
        self.__games.append(g)
 
1222
        return g
1113
1223
 
1114
1224
    def addGame(self, name, whiteName, whiteType, blackName, blackType):
1115
1225
        """Add a chess game into glChess.