Changeset 371


Ignore:
Timestamp:
04/02/12 04:48:07 (8 years ago)
Author:
sc
Message:
  • cleanup of Session breakout
Location:
trunk/Puzzlebox/Synapse
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Puzzlebox/Synapse/Interface.py

    r370 r371  
    77 
    88__changelog__ = """\ 
    9 Last Update: 2012.03.30 
     9Last Update: 2012.04.01 
    1010""" 
    1111 
     
    565565        ################################################################## 
    566566         
     567        def updateDevices(self): 
     568                 
     569                if (self.parent != None): 
     570                        source = self.parent 
     571                else: 
     572                        source = self 
     573                 
     574                model = source.comboBoxEEGHeadsetModel.currentText() 
     575                 
     576                devices = self.searchForDevices() 
     577                 
     578                source.comboBoxDeviceSelect.clear() 
     579                 
     580                if (model == 'NeuroSky MindWave' or \ 
     581                    model == 'NeuroSky MindSet' or \ 
     582                    model == 'NeuroSky MindWave Mobile'): 
     583                         
     584                        devices.insert(0, 'ThinkGear Emulator') 
     585                 
     586                elif (model == 'Emotiv EPOC'): 
     587                         
     588                        devices.insert(0, 'EmoComposer') 
     589                        devices.insert(0, 'Emotiv Control Panel') 
     590                 
     591                 
     592                for device in devices: 
     593                        source.comboBoxDeviceSelect.addItem(device) 
     594         
     595         
     596        ################################################################## 
     597         
    567598        def processPacket(self, packet): 
    568599                 
     
    777808        ################################################################## 
    778809         
    779         #def updateProfileSessionStatus(self, source=None, target=None): 
    780                  
    781                 #session_time = self.calculateSessionTime() 
    782                  
    783                 #if source == None: 
    784                         #if self.parent == None: 
    785                                 #source = self 
    786                         #else: 
    787                                 #source = self.parent 
    788                  
    789                 #if target == None: 
    790                         #if self.parent == None: 
    791                                 #target = self 
    792                         #else: 
    793                                 #target = self.parent 
    794                  
    795                 #target.textLabelSessionTime.setText(session_time) 
    796                  
    797                 #try: 
    798                         #target.textLabelPacketsReceived.setText( "%i" % \ 
    799                                 #source.synapseServer.protocol.packet_count) 
    800                 #except: 
    801                         #pass 
    802                  
    803                 #try: 
    804                         #target.textLabelPacketsDropped.setText( "%i" % \ 
    805                                 #source.synapseServer.protocol.bad_packets) 
    806                 #except: 
    807                         #pass 
    808          
    809          
    810         ################################################################## 
    811          
    812         #def calculateSessionTime(self): 
    813                  
    814                 #if self.parent == None: 
    815                         #server = self.synapseServer 
    816                 #else: 
    817                         #server = self.parent.synapseServer 
    818                  
    819                 #session_time = time.time() - \ 
    820                         #server.session_start_timestamp 
    821                         ##server.protocol.session_start_timestamp 
    822                  
    823                 #session_time = int(session_time) 
    824                  
    825                 #session_time = self.convert_seconds_to_datetime(session_time) 
    826                  
    827                 #return(session_time) 
    828          
    829          
    830         ################################################################## 
    831          
    832         #def enumerateSerialPorts(self): 
    833                  
    834                 #""" Uses the Win32 registry to return an 
    835                 #iterator of serial (COM) ports 
    836                 #existing on this computer. 
    837                  
    838                 #from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/ 
    839                 #""" 
    840           
    841                 #path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' 
    842                 #try: 
    843                         #key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) 
    844                 #except WindowsError: 
    845                         ##raise IterationError 
    846                         #return 
    847                  
    848                 #for i in itertools.count(): 
    849                         #try: 
    850                                 #val = winreg.EnumValue(key, i) 
    851                                 #yield str(val[1]) 
    852                         #except EnvironmentError: 
    853                                 #break 
    854          
    855          
    856         ################################################################## 
    857          
    858         #def fullPortName(self, portname): 
    859                  
    860                 #""" Given a port-name (of the form COM7, 
    861                 #COM12, CNCA0, etc.) returns a full 
    862                 #name suitable for opening with the 
    863                 #Serial class. 
    864                 #""" 
    865                  
    866                 #m = re.match('^COM(\d+)$', portname) 
    867                 #if m and int(m.group(1)) < 10: 
    868                         #return portname 
    869                  
    870                 #return '\\\\.\\' + portname 
    871          
    872          
    873         ################################################################## 
    874          
    875         #def searchForSerialDevices(self, devices=[]): 
    876                  
    877                 #if (sys.platform == 'win32'): 
    878                          
    879                         #for portname in self.enumerateSerialPorts(): 
    880                                  
    881                                 #if portname not in devices: 
    882                                         ##portname = self.fullPortName(portname) 
    883                                         #devices.append(portname) 
    884                  
    885                 #else: 
    886                          
    887                          
    888                         #if os.path.exists('/dev/tty.MindWaveMobile-SPPDev'): 
    889                                 #devices.append('/dev/tty.MindWaveMobile-SPPDev') 
    890                          
    891                         #if os.path.exists('/dev/tty.MindWave'): 
    892                                 #devices.append('/dev/tty.MindWave') 
    893                         #if os.path.exists('/dev/tty.MindWave1'): 
    894                                 #devices.append('/dev/tty.MindWave1') 
    895                         #if os.path.exists('/dev/tty.MindWave2'): 
    896                                 #devices.append('/dev/tty.MindWave2') 
    897                         #if os.path.exists('/dev/tty.MindWave3'): 
    898                                 #devices.append('/dev/tty.MindWave3') 
    899                         #if os.path.exists('/dev/tty.MindWave4'): 
    900                                 #devices.append('/dev/tty.MindWave4') 
    901                         #if os.path.exists('/dev/tty.MindWave5'): 
    902                                 #devices.append('/dev/tty.MindWave5') 
    903                          
    904                         #if os.path.exists('/dev/tty.MindSet-DevB'): 
    905                                 #devices.append('/dev/tty.MindSet-DevB') 
    906                          
    907                         #if os.path.exists('/dev/ttyUSB0'): 
    908                                 #devices.append('/dev/ttyUSB0') 
    909                         #if os.path.exists('/dev/ttyUSB1'): 
    910                                 #devices.append('/dev/ttyUSB1') 
    911                         #if os.path.exists('/dev/ttyUSB2'): 
    912                                 #devices.append('/dev/ttyUSB2') 
    913                         #if os.path.exists('/dev/ttyUSB3'): 
    914                                 #devices.append('/dev/ttyUSB3') 
    915                         #if os.path.exists('/dev/ttyUSB4'): 
    916                                 #devices.append('/dev/ttyUSB4') 
    917                         #if os.path.exists('/dev/ttyUSB5'): 
    918                                 #devices.append('/dev/ttyUSB5') 
    919                         #if os.path.exists('/dev/ttyUSB6'): 
    920                                 #devices.append('/dev/ttyUSB6') 
    921                         #if os.path.exists('/dev/ttyUSB7'): 
    922                                 #devices.append('/dev/ttyUSB7') 
    923                         #if os.path.exists('/dev/ttyUSB8'): 
    924                                 #devices.append('/dev/ttyUSB8') 
    925                         #if os.path.exists('/dev/ttyUSB9'): 
    926                                 #devices.append('/dev/ttyUSB9') 
    927                          
    928                         #if os.path.exists('/dev/rfcomm0'): 
    929                                 #devices.append('/dev/rfcomm0') 
    930                         #if os.path.exists('/dev/rfcomm1'): 
    931                                 #devices.append('/dev/rfcomm1') 
    932                         #if os.path.exists('/dev/rfcomm2'): 
    933                                 #devices.append('/dev/rfcomm2') 
    934                         #if os.path.exists('/dev/rfcomm3'): 
    935                                 #devices.append('/dev/rfcomm3') 
    936                         #if os.path.exists('/dev/rfcomm4'): 
    937                                 #devices.append('/dev/rfcomm4') 
    938                          
    939                         #if os.path.exists('/dev/ttyACM0'): 
    940                                 #devices.append('/dev/ttyACM0') 
    941                         #if os.path.exists('/dev/ttyACM1'): 
    942                                 #devices.append('/dev/ttyACM1') 
    943                         #if os.path.exists('/dev/ttyACM2'): 
    944                                 #devices.append('/dev/ttyACM2') 
    945                         #if os.path.exists('/dev/ttyACM3'): 
    946                                 #devices.append('/dev/ttyACM3') 
    947                         #if os.path.exists('/dev/ttyACM4'): 
    948                                 #devices.append('/dev/ttyACM4') 
    949                  
    950                  
    951                 #return(devices) 
    952          
    953          
    954         ################################################################## 
    955          
    956         #def hcitoolScanForRemoteDevices(self, devices=[]): 
    957                  
    958                 #bluetooth_devices = [] 
    959                  
    960                 ##command = '%s scan 2> /dev/null' % PATH_TO_HCITOOL 
    961                 #command = '%s scan' % PATH_TO_HCITOOL 
    962                  
    963                 #if self.DEBUG > 1: 
    964                         #print 'INFO: Calling "%s"' % command  
    965                  
    966                 #output = os.popen(command, 'r') 
    967                  
    968                 #try: 
    969                         #result = output.readlines() 
    970                 #except Exception, e: 
    971                         #if self.DEBUG: 
    972                                 #print "ERROR [Synapse-Interface]: Failed reading result from call to hcitool:", 
    973                                 #print e 
    974                         #result = '' 
    975                  
    976                 #if result == '': 
    977                         #return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
    978                  
    979                 #for line in result: 
    980                         #line = line.strip() 
    981                         #if line == '' or line == 'Scanning ...': 
    982                                 #continue 
    983                         #elif self.DEBUG > 1: 
    984                                 #print line 
    985                         #try: 
    986                                 #address = line.split('\t')[0] 
    987                         #except: 
    988                                 #pass 
    989                         #else: 
    990                                 #bluetooth_devices.append(address) 
    991                  
    992                  
    993                 #for address in bluetooth_devices: 
    994                          
    995                         #command = '%s name %s' % (PATH_TO_HCITOOL, address) 
    996                          
    997                         #if self.DEBUG: 
    998                                 #print 'INFO: Calling "%s"' % command 
    999                          
    1000                         #output = os.popen(command, 'r') 
    1001                          
    1002                         #for line in output.readlines(): 
    1003                                 #line = line.strip() 
    1004                                 #if line == '': 
    1005                                         #continue 
    1006                                 #elif self.DEBUG: 
    1007                                         #print '\t', 
    1008                                         #print line 
    1009                                  
    1010                                 #device_name = line.strip() 
    1011                          
    1012                                 #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    1013                                         #(address not in devices)): 
    1014                                         #devices.append(address) 
    1015                                  
    1016                                 #else: 
    1017                                         #if self.DEBUG: 
    1018                                                 #print 'INFO: Found but not recognized: [%s] %s' % \ 
    1019                                                         #(address, device_name) 
    1020                  
    1021                  
    1022                 #return (devices) 
    1023          
    1024          
    1025         ################################################################## 
    1026          
    1027         #def hcitoolGetActiveConnections(self, devices=[]): 
    1028                  
    1029                 #bluetooth_devices = [] 
    1030                  
    1031                 ##command = '%s con 2> /dev/null' % PATH_TO_HCITOOL 
    1032                 #command = '%s con' % PATH_TO_HCITOOL 
    1033                  
    1034                 #if self.DEBUG > 1: 
    1035                         #print 'INFO: Calling "%s"' % command  
    1036                  
    1037                 #output = os.popen(command, 'r') 
    1038                  
    1039                 #try: 
    1040                         #result = output.readlines() 
    1041                 #except Exception, e: 
    1042                         #if self.DEBUG: 
    1043                                 #print "ERROR [Synapse:Interface]: Failed reading result from call to hcitool:", 
    1044                                 #print e 
    1045                         #result = '' 
    1046  
    1047                 #if result == '': 
    1048                         #return([]) # Under OS X hcitool doesn't exist so we don't see any devices 
    1049  
    1050                 #for line in result: 
    1051                         #line = line.strip() 
    1052                         #if line == '' or line == 'Connections:': 
    1053                                 #continue 
    1054                         #elif self.DEBUG > 1: 
    1055                                 #print line 
    1056                         #try: 
    1057                                 #address = line.split(' ')[2] 
    1058                         #except: 
    1059                                 #pass 
    1060                         #else: 
    1061                                 #bluetooth_devices.append(address) 
    1062                  
    1063                  
    1064                 #for address in bluetooth_devices: 
    1065                          
    1066                         #command = '%s name %s' % (PATH_TO_HCITOOL, address) 
    1067                          
    1068                         #if self.DEBUG: 
    1069                                 #print 'INFO: Calling "%s":' % command 
    1070                          
    1071                         #output = os.popen(command, 'r') 
    1072                          
    1073                         #for line in output.readlines(): 
    1074                                 #line = line.strip() 
    1075                                 #if line == '': 
    1076                                         #continue 
    1077                                 #elif self.DEBUG: 
    1078                                         #print '\t', 
    1079                                         #print line 
    1080                                  
    1081                                 #device_name = line.strip() 
    1082                          
    1083                                 #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    1084                                         #(address not in devices)): 
    1085                                         #devices.append(address) 
    1086                  
    1087                  
    1088                 #return (devices) 
    1089          
    1090          
    1091         ################################################################## 
    1092          
    1093         #def searchForDevices(self): 
    1094                  
    1095                 #enable_hcitool = configuration.ENABLE_HCITOOL 
    1096                  
    1097                 #devices = [] 
    1098                  
    1099                 ##self.pushButtonBluetoothSearch.setText('Searching') 
    1100                  
    1101                 #if ((sys.platform != 'win32' and sys.platform != 'darwin') and \ 
    1102                      #configuration.THINKGEAR_BLUETOOTH_SEARCH): 
    1103                          
    1104                         ## Bluetooth module doesn't compile properly under Windows 
    1105                         ## and doesn't exist under OS X 
    1106                          
    1107                         ## PyBluez API Documentation 
    1108                         ## http://pybluez.googlecode.com/svn/www/docs-0.7/index.html 
    1109                          
    1110                         #bluetooth_devices = [] 
    1111                          
    1112                         #if not enable_hcitool: 
    1113                                  
    1114                                 #try: 
    1115                                          
    1116                                         #if self.DEBUG: 
    1117                                                 #print "INFO: Searching for Bluetooth devices using PyBluez module" 
    1118                                          
    1119                                         #bluetooth_devices = bluetooth.discover_devices( \ 
    1120                                               #duration=configuration.THINKGEAR_BLUETOOTH_DISCOVER_DEVICES_TIMEOUT, \ 
    1121                                                                #flush_cache=True, \ 
    1122                                                                #lookup_names=False) 
    1123                                          
    1124                                         #for address in bluetooth_devices: 
    1125                                                  
    1126                                                 #if self.DEBUG: 
    1127                                                         #print "INFO: Device discovered", 
    1128                                                         #print address 
    1129                                                  
    1130                                                 #device_name = bluetooth.lookup_name(address, \ 
    1131                                                                  #configuration.THINKGEAR_BLUETOOTH_LOOKUP_NAME_TIMEOUT) 
    1132                                                 #if ((device_name == 'MindSet' or device_name == 'MindWave Mobile') and \ 
    1133                                                         #(address not in devices)): 
    1134                                                         #devices.append(address) 
    1135                                          
    1136                                          
    1137                                         ## There is an issue under recent released of Linux 
    1138                                         ## in which already-connected Bluetooth ThinkGear devices 
    1139                                         ## are not appearing in a bluetooth device scan. However, 
    1140                                         ## using "hcitool" connected devices can be listed correctly. 
    1141                                         ## There does not appear to be an equivalent PyBluez feature. 
    1142                                         ## (http://pybluez.googlecode.com/svn/www/docs-0.7/index.html) 
    1143                                          
    1144                                         #if devices == []: 
    1145                                                 #if self.DEBUG: 
    1146                                                         #print "INFO: No devices found through PyBluez module. Falling back to hcitool." 
    1147                                                 #devices = self.hcitoolGetActiveConnections(devices) 
    1148                                  
    1149                                  
    1150                                 #except Exception, e: 
    1151                                         #if self.DEBUG: 
    1152                                                 #print "ERROR: Exception calling Python Bluetooth module. (Is PyBluez installed?):" 
    1153                                                 #print e 
    1154                                          
    1155                                          
    1156                                         ##if (sys.platform != 'darwin'): 
    1157                                         #enable_hcitool = True 
    1158                          
    1159                          
    1160                         #if enable_hcitool: 
    1161                                  
    1162                                 #devices = self.hcitoolScanForRemoteDevices(devices) 
    1163                                 #devices = self.hcitoolGetActiveConnections(devices) 
    1164                          
    1165                          
    1166                         #if self.DEBUG > 2: 
    1167                                 #print "Bluetooth Devices found:", 
    1168                                 #print devices 
    1169                  
    1170                  
    1171                 #devices = self.searchForSerialDevices(devices) 
    1172                  
    1173                  
    1174                 #if self.DEBUG: 
    1175                         #print "Devices found:", 
    1176                         #print devices 
    1177                  
    1178                  
    1179                 #return(devices) 
    1180          
    1181          
    1182         ################################################################## 
    1183          
    1184         def updateDevices(self): 
    1185                  
    1186                 if (self.parent != None): 
    1187                         source = self.parent 
    1188                 else: 
    1189                         source = self 
    1190                  
    1191                 model = source.comboBoxEEGHeadsetModel.currentText() 
    1192                  
    1193                 devices = self.searchForDevices() 
    1194                  
    1195                 source.comboBoxDeviceSelect.clear() 
    1196                  
    1197                 if (model == 'NeuroSky MindWave' or \ 
    1198                     model == 'NeuroSky MindSet' or \ 
    1199                     model == 'NeuroSky MindWave Mobile'): 
    1200                          
    1201                         devices.insert(0, 'ThinkGear Emulator') 
    1202                  
    1203                 elif (model == 'Emotiv EPOC'): 
    1204                          
    1205                         devices.insert(0, 'EmoComposer') 
    1206                         devices.insert(0, 'Emotiv Control Panel') 
    1207                  
    1208                  
    1209                 for device in devices: 
    1210                         source.comboBoxDeviceSelect.addItem(device) 
    1211          
    1212          
    1213         ################################################################## 
    1214          
    1215         #def collectData(self, source=None, target=None): 
    1216                  
    1217                 #if source == None: 
    1218                         #if self.parent == None: 
    1219                                 #source = self 
    1220                         #else: 
    1221                                 #source = self.parent 
    1222                  
    1223                 #if target == None: 
    1224                         #if self.parent == None: 
    1225                                 #target = self 
    1226                         #else: 
    1227                                 #target = self.parent 
    1228                  
    1229                 #data = {} 
    1230                  
    1231                 #data['rawEeg'] = source.packets['rawEeg'] 
    1232                 #data['signals'] = source.packets['signals'] 
    1233                  
    1234                 #data['sessionTime'] = self.calculateSessionTime() 
    1235                  
    1236                 #data['profileName'] = str(target.lineEditSessionProfile.text()) 
    1237                  
    1238                 #return(data) 
    1239          
    1240          
    1241         ################################################################## 
    1242          
    1243         #def parseTimeStamp(self, timestamp, local_version=False, truncate_time_zone=False): 
    1244                  
    1245                 #try: 
    1246                         #decimal = '%f' % timestamp 
    1247                         #decimal = decimal.split('.')[1] 
    1248                 #except: 
    1249                         #decimal = '0' 
    1250                  
    1251                 #localtime = time.localtime(timestamp) 
    1252                  
    1253                 #if local_version: 
    1254                         #date = time.strftime('%x', localtime) 
    1255                         #localtime = time.strftime('%X', localtime) 
    1256                  
    1257                 #elif truncate_time_zone: 
    1258                         #date = time.strftime('%Y-%m-%d', localtime) 
    1259                         #localtime = time.strftime('%H:%M:%S', localtime) 
    1260                         #localtime = '%s.%s' % (localtime, decimal[:3]) 
    1261                  
    1262                 #else: 
    1263                         #date = time.strftime('%Y-%m-%d', localtime) 
    1264                         #localtime = time.strftime('%H:%M:%S', localtime) 
    1265                         #localtime = '%s.%s %s' % (localtime, decimal, \ 
    1266                                        #time.strftime('%Z', time.localtime(timestamp))) 
    1267                  
    1268                  
    1269                 #return(date, localtime) 
    1270          
    1271          
    1272         ################################################################## 
    1273          
    1274         #def saveData(self, source=None, target=None, output_file=None, use_default=False): 
    1275                  
    1276                 #if source == None: 
    1277                         #if self.parent == None: 
    1278                                 #source = self 
    1279                         #else: 
    1280                                 #source = self.parent 
    1281                  
    1282                 #if target == None: 
    1283                         #if self.parent == None: 
    1284                                 #target = self 
    1285                         #else: 
    1286                                 #target = self.parent 
    1287                  
    1288                 #data = self.collectData(source=source, target=target) 
    1289                  
    1290                 #(date, localtime) = self.parseTimeStamp(time.time()) 
    1291                  
    1292                 #default_filename = '%s %s.synapse' % (date, \ 
    1293                                       #target.lineEditSessionProfile.text()) 
    1294                                        
    1295                 #default_filename = os.path.join(self.homepath, default_filename) 
    1296                  
    1297                 #if output_file == None: 
    1298                          
    1299                         ## use_default controls whether or not a file is automatically saves using the 
    1300                         ## default name and path (as opposed to raising a GUI file selection menu) 
    1301                         ## whenever an explicit filepath is not defined 
    1302                         #if use_default: 
    1303                                          
    1304                                         #output_file = default_filename 
    1305                          
    1306                         #else: 
    1307                          
    1308                                 #output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \ 
    1309                                                  #caption="Save Session Data to File", \ 
    1310                                                  #dir=default_filename, \ 
    1311                                                  #filter="Puzzlebox Synapse Data File (*.synapse)") 
    1312                                  
    1313                                 #try: 
    1314                                         #output_file = output_file[0] 
    1315                                 #except: 
    1316                                         #output_file = '' 
    1317                  
    1318                  
    1319                 #if output_file == '': 
    1320                         #return 
    1321                  
    1322                 #file = open(str(output_file), 'w') 
    1323                 #pickle.dump(data, file) 
    1324                 #file.close() 
    1325          
    1326          
    1327         ################################################################## 
    1328          
    1329         #def exportData(self, parent=None, source=None, target=None, output_file=None, use_default=False): 
    1330                  
    1331                 #if parent == None: 
    1332                         #if self.parent == None: 
    1333                                 #parent = self 
    1334                         #else: 
    1335                                 #parent = self.parent 
    1336                  
    1337                 #if source == None: 
    1338                         #if self.parent == None: 
    1339                                 #source = self 
    1340                         #else: 
    1341                                 #source = self.parent 
    1342                  
    1343                 #if target == None: 
    1344                         #if self.parent == None: 
    1345                                 #target = self 
    1346                         #else: 
    1347                                 #target = self.parent 
    1348                  
    1349                  
    1350                 #(date, localtime) = self.parseTimeStamp(time.time()) 
    1351                  
    1352                 #default_filename = '%s %s.csv' % (date, \ 
    1353                                       #target.lineEditSessionProfile.text()) 
    1354                  
    1355                 #default_filename = os.path.join(target.homepath, default_filename) 
    1356                  
    1357                  
    1358                 #if output_file == None: 
    1359                          
    1360                         ## use_default controls whether or not a file is automatically saves using the 
    1361                         ## default name and path (as opposed to raising a GUI file selection menu) 
    1362                         ## whenever an explicit filepath is not defined 
    1363                         #if use_default: 
    1364                                          
    1365                                         #output_file = default_filename 
    1366                          
    1367                         #else: 
    1368                                 #output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \ 
    1369                                                  #caption="Export Session Data to File", \ 
    1370                                                  #dir=default_filename, \ 
    1371                                                  #filter="CSV File (*.csv);;Text File (*.txt)") 
    1372                                  
    1373                                 #try: 
    1374                                         #output_file = output_file[0] 
    1375                                 #except: 
    1376                                         #output_file = '' 
    1377                  
    1378                  
    1379                 #if output_file == '': 
    1380                         #return 
    1381                  
    1382                  
    1383                 #if str(output_file).endswith('.csv'): 
    1384                          
    1385                         #outputData = self.exportDataToCSV(parent=parent, source=source, target=target) 
    1386                  
    1387                  
    1388                 #else: 
    1389                          
    1390                         #try: 
    1391                                 #outputData = self.textEditDebugConsole.toPlainText() 
    1392                         #except: 
    1393                                 #outputData = self.exportDataToCSV() 
    1394                  
    1395                  
    1396                 #file = open(str(output_file), 'w') 
    1397                 #file.write(outputData) 
    1398                 #file.close() 
    1399          
    1400          
    1401         ################################################################## 
    1402          
    1403         #def exportDataToCSV(self, parent=None, source=None, target=None): 
    1404                  
    1405                 #if parent == None: 
    1406                         #if self.parent == None: 
    1407                                 #parent = self 
    1408                         #else: 
    1409                                 #parent = self.parent 
    1410                  
    1411                 #if source == None: 
    1412                         #if self.parent == None: 
    1413                                 #source = self 
    1414                         #else: 
    1415                                 #source = self.parent 
    1416                  
    1417                 #if target == None: 
    1418                         #if self.parent == None: 
    1419                                 #target = self 
    1420                         #else: 
    1421                                 #target = self.parent 
    1422                  
    1423                 #try: 
    1424                         #truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE 
    1425                 #except: 
    1426                         #truncate_csv_timezone = False 
    1427                  
    1428                 #try: 
    1429                         #scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA 
    1430                 #except: 
    1431                         #scrub_data = False 
    1432                  
    1433                  
    1434                 #headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma' 
    1435                  
    1436                 #customDataHeaders = [] 
    1437                 #for header in parent.customDataHeaders: 
    1438                         #customDataHeaders.append(header) 
    1439                 #for plugin in parent.activePlugins: 
    1440                         #for header in plugin.customDataHeaders: 
    1441                                 #customDataHeaders.append(header) 
    1442                  
    1443                 #for each in customDataHeaders: 
    1444                         #headers = headers + ',%s' % each 
    1445                  
    1446                 #headers = headers + '\n' 
    1447                  
    1448                 #csv = {} 
    1449                  
    1450                 #for packet in source.packets['signals']: 
    1451                          
    1452                          
    1453                         #if 'rawEeg' in packet.keys(): 
    1454                                 #continue 
    1455                          
    1456                         #if packet['timestamp'] not in csv.keys(): 
    1457                                  
    1458                                 #if 'blinkStrength' in packet.keys(): 
    1459                                         ## Skip any blink packets from log 
    1460                                         #continue 
    1461                                  
    1462                                  
    1463                                 ##print packet 
    1464                                 #timestamp = packet['timestamp'] 
    1465                                 #(date, localtime) = self.parseTimeStamp(timestamp, \ 
    1466                                                     #truncate_time_zone=truncate_csv_timezone) 
    1467                                  
    1468                                 #csv[timestamp] = {} 
    1469                                 #csv[timestamp]['Date'] = date 
    1470                                 #csv[timestamp]['Time'] = localtime 
    1471                                 #csv[timestamp]['Attention'] = '' 
    1472                                 #csv[timestamp]['Meditation'] = '' 
    1473                                 #csv[timestamp]['Signal Level'] = '' 
    1474                                 #csv[timestamp]['Delta'] = '' 
    1475                                 #csv[timestamp]['Theta'] = '' 
    1476                                 #csv[timestamp]['Low Alpha'] = '' 
    1477                                 #csv[timestamp]['High Alpha'] = '' 
    1478                                 #csv[timestamp]['Low Beta'] = '' 
    1479                                 #csv[timestamp]['High Beta'] = '' 
    1480                                 #csv[timestamp]['Low Gamma'] = '' 
    1481                                 #csv[timestamp]['Mid Gamma'] = '' 
    1482                                  
    1483                                 #for header in customDataHeaders: 
    1484                                         #csv[timestamp][header] = '' 
    1485                          
    1486                          
    1487                         #if 'eSense' in packet.keys(): 
    1488                                 #if 'attention' in packet['eSense'].keys(): 
    1489                                         #csv[timestamp]['Attention'] = packet['eSense']['attention'] 
    1490                                 #if 'meditation' in packet['eSense'].keys(): 
    1491                                         #csv[timestamp]['Meditation'] = packet['eSense']['meditation'] 
    1492                          
    1493                         #if 'eegPower' in packet.keys(): 
    1494                                 #if 'delta' in packet['eegPower'].keys(): 
    1495                                         #csv[timestamp]['Delta'] = packet['eegPower']['delta'] 
    1496                                 #if 'theta' in packet['eegPower'].keys(): 
    1497                                         #csv[timestamp]['Theta'] = packet['eegPower']['theta'] 
    1498                                 #if 'lowAlpha' in packet['eegPower'].keys(): 
    1499                                         #csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha'] 
    1500                                 #if 'highAlpha' in packet['eegPower'].keys(): 
    1501                                         #csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha'] 
    1502                                 #if 'lowBeta' in packet['eegPower'].keys(): 
    1503                                         #csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta'] 
    1504                                 #if 'highBeta' in packet['eegPower'].keys(): 
    1505                                         #csv[timestamp]['High Beta'] = packet['eegPower']['highBeta'] 
    1506                                 #if 'lowGamma' in packet['eegPower'].keys(): 
    1507                                         #csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma'] 
    1508                                 #if 'highGamma' in packet['eegPower'].keys(): 
    1509                                         #csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma'] 
    1510                          
    1511                         #if 'poorSignalLevel' in packet.keys(): 
    1512                                 #csv[timestamp]['Signal Level'] = packet['poorSignalLevel'] 
    1513                          
    1514                         #for header in customDataHeaders: 
    1515                                 #if 'custom' in packet.keys() and \ 
    1516                                    #header in packet['custom'].keys(): 
    1517                                         #csv[timestamp][header] = packet['custom'][header] 
    1518                  
    1519                  
    1520                 #if scrub_data: 
    1521                         #csv = self.scrubData(csv, truncate_csv_timezone) 
    1522                  
    1523                  
    1524                 #output = headers 
    1525                  
    1526                 #csv_keys = csv.keys() 
    1527                 #csv_keys.sort() 
    1528                  
    1529                 #for key in csv_keys: 
    1530                          
    1531                         #row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \ 
    1532                               #(csv[key]['Date'], \ 
    1533                                #csv[key]['Time'], \ 
    1534                                #csv[key]['Attention'], \ 
    1535                                #csv[key]['Meditation'], \ 
    1536                                #csv[key]['Signal Level'], \ 
    1537                                #csv[key]['Delta'], \ 
    1538                                #csv[key]['Theta'], \ 
    1539                                #csv[key]['Low Alpha'], \ 
    1540                                #csv[key]['High Alpha'], \ 
    1541                                #csv[key]['Low Beta'], \ 
    1542                                #csv[key]['High Beta'], \ 
    1543                                #csv[key]['Low Gamma'], \ 
    1544                                #csv[key]['Mid Gamma']) 
    1545                          
    1546                         #for header in customDataHeaders: 
    1547                                 #row = row + ',%s' % csv[key][header] 
    1548                          
    1549                         #row = row + '\n' 
    1550                          
    1551                         #output = output + row 
    1552                  
    1553                  
    1554                 #return(output) 
    1555          
    1556          
    1557         ################################################################## 
    1558          
    1559         #def scrubData(self, csv, truncate_csv_timezone=False): 
    1560                  
    1561                 ## If there are missing packets, repeat a given packet once per missing 
    1562                 ## second until there is a gap between 1 and 2 seconds, in which case 
    1563                 ## produce a final duplicate packet at the mid-point between the packets 
    1564  
    1565                 #if self.DEBUG: 
    1566                         #print "INFO: Scrubbing Data" 
    1567                  
    1568                 #last_time = None 
    1569                 #last_recorded_time = None 
    1570                  
    1571                 #output = {} 
    1572                  
    1573                 #csv_keys = csv.keys() 
    1574                 #csv_keys.sort() 
    1575                  
    1576                 #for key in csv_keys: 
    1577                          
    1578                         #timestamp = key 
    1579  
    1580                         #if csv[key]['Attention'] == '': 
    1581                                 #continue 
    1582                          
    1583                         #if last_time == None: 
    1584                                 ## First entry in log 
    1585                                 #last_time = timestamp 
    1586                                 #last_recorded_time = timestamp 
    1587                                 #output[key] = csv[key] 
    1588                                 #continue 
    1589                          
    1590                         #else: 
    1591                                  
    1592                                 ##time_difference = timestamp - last_time 
    1593                                 #time_difference = timestamp - last_recorded_time 
    1594                                  
    1595                                 #if (time_difference <= 1) and \ 
    1596                                    #(time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD): 
    1597                                         ## Skip packets within the correct time threshold 
    1598                                         #last_time = timestamp 
    1599                                         #last_recorded_time = timestamp 
    1600                                         #output[key] = csv[key] 
    1601                                         #continue 
    1602                                  
    1603                                 #else: 
    1604                                          
    1605                                         #if self.DEBUG > 1: 
    1606                                                 #print "time_difference:", 
    1607                                                 #print time_difference 
    1608                                                 #print "timestamp:", 
    1609                                                 #print self.parseTimeStamp(timestamp)[-1].split(' ')[0] 
    1610                                                 #print "last_time:", 
    1611                                                 #print self.parseTimeStamp(last_time)[-1].split(' ')[0] 
    1612                                                 #print "last_recorded_time:", 
    1613                                                 #print self.parseTimeStamp(last_recorded_time)[-1].split(' ')[0] 
    1614                                          
    1615                                          
    1616                                         #new_packet = csv[key].copy() 
    1617                                          
    1618                                         #if time_difference >= 2: 
    1619                                                  
    1620                                                 ###new_time = last_time + 1 
    1621                                                 ##new_time = last_recorded_time + 1 
    1622                                                  
    1623                                                 #count = int(time_difference) 
    1624                                                 #while count >= 1: 
    1625                                                         #new_packet = csv[key].copy() 
    1626                                                         #new_time = last_recorded_time + 1 
    1627                                                         #(date, formatted_new_time) = self.parseTimeStamp(new_time, \ 
    1628                                                          #truncate_time_zone=truncate_csv_timezone) 
    1629                                                         #new_packet['Time'] = formatted_new_time 
    1630                                                         #last_recorded_time = new_time 
    1631                                                         #last_time = timestamp 
    1632                                                         #output[new_time] = new_packet 
    1633                                                         #count = count - 1 
    1634                                                 #continue 
    1635                                                  
    1636                                         #elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD: 
    1637                                                 ## Spread out "bunched up" packets 
    1638                                                 ##new_time = last_time + 1 
    1639                                                 #new_time = last_recorded_time + 1 
    1640                                          
    1641                                          
    1642                                         #elif (time_difference < 2) and (time_difference > 1): 
    1643                                                  
    1644                                                 ##new_time = last_time + ((last_time - timestamp) / 2) 
    1645                                                 ##new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2) 
    1646                                                 ##new_time = last_time + 1 
    1647                                                 #new_time = last_recorded_time + 1 
    1648                                          
    1649                                          
    1650                                         #(date, formatted_new_time) = self.parseTimeStamp(new_time, \ 
    1651                                            #truncate_time_zone=truncate_csv_timezone) 
    1652                                          
    1653                                         #new_packet['Time'] = formatted_new_time 
    1654                                          
    1655                                         ##last_time = new_time 
    1656                                         #last_recorded_time = new_time 
    1657                                         #last_time = timestamp 
    1658                                         #output[new_time] = new_packet 
    1659                                          
    1660                                         #if self.DEBUG > 1: 
    1661                                                 #print "WARN: Scrubbing new packet:", 
    1662                                                 #print new_packet 
    1663                                                 #print 
    1664                  
    1665                  
    1666                 #return(output) 
    1667          
    1668          
    1669         ################################################################## 
    1670          
    1671         #def resetData(self, source=None): 
    1672                  
    1673                 #if source == None: 
    1674                         #if self.parent == None: 
    1675                                 #source = self 
    1676                         #else: 
    1677                                 #source = self.parent 
    1678                  
    1679                 ##if target == None: 
    1680                         ##if self.parent == None: 
    1681                                 ##target = self 
    1682                         ##else: 
    1683                                 ##target = self.parent 
    1684                  
    1685                 #source.packets['rawEeg'] = [] 
    1686                 #source.packets['signals'] = [] 
    1687                  
    1688                 #source.synapseServer.protocol.session_start_timestamp = \ 
    1689                         #time.time() 
    1690                  
    1691                 #source.synapseServer.protocol.packet_count = 0 
    1692                 #source.synapseServer.protocol.bad_packets = 0 
    1693                  
    1694                 #self.updateProfileSessionStatus() 
    1695                  
    1696                 #try: 
    1697                         #source.textEditDebugConsole.setText("") 
    1698                 #except: 
    1699                         #pass 
    1700          
    1701          
    1702         ##################################################################### 
    1703          
    1704         #def convert_seconds_to_datetime(self, duration): 
    1705                  
    1706                 #duration_hours = duration / (60 * 60) 
    1707                 #duration_minutes = (duration - (duration_hours * (60 * 60))) / 60 
    1708                 #duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60)) 
    1709                  
    1710                 #duration_hours = '%i' % duration_hours 
    1711                 #if (len(duration_hours) == 1): 
    1712                         #duration_hours = "0%s" % duration_hours 
    1713                  
    1714                 #duration_minutes = '%i' % duration_minutes 
    1715                 #if (len(duration_minutes) == 1): 
    1716                         #duration_minutes = "0%s" % duration_minutes 
    1717                  
    1718                 #duration_seconds = '%i' % duration_seconds 
    1719                 #if (len(duration_seconds) == 1): 
    1720                         #duration_seconds = "0%s" % duration_seconds 
    1721                  
    1722                 #datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds) 
    1723                  
    1724                 #return(datetime) 
    1725          
    1726          
    1727         ################################################################## 
    1728          
    1729810        def stop(self): 
    1730811                 
  • trunk/Puzzlebox/Synapse/Session.py

    r370 r371  
    3535 
    3636 
    37 #try: 
    38         #from Interface_Plot import * 
    39         #MATPLOTLIB_AVAILABLE = True 
    40 #except Exception, e: 
    41         #print "ERROR: Exception importing Interface_Plot:", 
    42         #print e 
    43         #MATPLOTLIB_AVAILABLE = False 
    44  
    45  
    46 #if (sys.platform == 'win32'): 
    47         #import _winreg as winreg 
    48         #import itertools 
    49         #import re 
    50         #import serial 
    51         #DEFAULT_IMAGE_PATH = 'images' 
    52 #elif (sys.platform == 'darwin'): 
    53         #DEFAULT_IMAGE_PATH = 'images' 
    54 #else: 
    55         #import bluetooth 
    56         #DEFAULT_IMAGE_PATH = '/usr/share/puzzlebox_synapse/images' 
    57  
    58  
    5937try: 
    6038        import cPickle as pickle 
     
    6240        import pickle 
    6341 
    64 #from Interface_Design import Ui_Form as Design 
    65  
    66 #import Puzzlebox.Synapse.Client as synapse_client 
    67 #import Puzzlebox.Synapse.ThinkGear.Server as thinkgear_server 
    68 #import Puzzlebox.Synapse.Emotiv.Server as emotiv_server 
    69 #import puzzlebox_logger 
    70  
    7142 
    7243##################################################################### 
     
    8354PATH_TO_HCITOOL = '/usr/bin/hcitool' 
    8455 
    85 ##UPDATE_INTERFACE_VIA_TIMER = True # Alternative is to establish a 
    86                                   ### ThinkGear Connect client which 
    87                                   ### updates the interface on demand 
    88                                   ### as packets are received 
    89  
    90 #UPDATE_INTERFACE_VIA_TIMER = False 
    91  
    92 ##INTERFACE_UPDATE_FREQUENCY = (1 / 512) * 1000 # ms (512 Hz) 
    93 #INTERFACE_UPDATE_FREQUENCY = 1000 # ms 
    94  
    95 #INTERFACE_RAW_EEG_UPDATE_FREQUENCY = 512 
    96  
    97 #PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD = 0.75 
    98  
    9956 
    10057##################################################################### 
     
    10562         
    10663        def __init__(self, log, \ 
    107                      #server=None, \ 
    10864                     DEBUG=DEBUG, \ 
    10965                     parent=None, \ 
     
    12480                 
    12581                self.name = "Synapse:Session" 
    126                  
    127                 #self.synapseServer = None 
    128                 #self.synapseClient = None 
    129                  
    130                 #self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE 
    131                  
    132                 #self.debug_console_buffer = '' 
    133                  
    134                 #self.packets = {} 
    135                 #self.packets['rawEeg'] = [] 
    136                 #self.packets['signals'] = [] 
    137                  
    138                 #self.customDataHeaders = [] 
    139                  
    140                 #if UPDATE_INTERFACE_VIA_TIMER: 
    141                         #self.updateInterfaceTimer = QtCore.QTimer() 
    142                         #QtCore.QObject.connect(self.updateInterfaceTimer, \ 
    143                                                     #QtCore.SIGNAL("timeout()"), \ 
    144                                                     #self.updateInterface) 
    14582                 
    14683                 
     
    177114        def configureSettings(self): 
    178115                 
    179                 # Synapse Interface 
    180                 #image_path = "puzzlebox.ico" 
    181                 #if not os.path.exists(image_path): 
    182                         #image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path) 
    183                  
    184                 #if os.path.exists(image_path): 
    185                         #icon = QtGui.QIcon() 
    186                         #icon.addPixmap(QtGui.QPixmap(image_path), \ 
    187                                             #QtGui.QIcon.Normal, \ 
    188                                             #QtGui.QIcon.Off) 
    189                         #self.setWindowIcon(icon) 
    190                  
    191                 #image_path = "puzzlebox_logo.png" 
    192                 #if not os.path.exists(image_path): 
    193                         #image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path) 
    194                 #if os.path.exists(image_path): 
    195                         #self.labelPuzzleboxIcon.setPixmap(QtGui.QPixmap(image_path)) 
    196                  
    197                  
    198                 #if configuration.INTERFACE_TAB_POSITION == 'South': 
    199                         #self.tabWidget.setTabPosition(QtGui.QTabWidget.South) 
    200                 #else: 
    201                         #self.tabWidget.setTabPosition(QtGui.QTabWidget.North) 
    202                  
    203                  
    204                 # EEG Devices 
    205                 #self.updateDevices() 
    206                  
    207                  
    208                 # Connect Server 
    209                 #self.textLabelBluetoothStatus.setText("Status: Disconnected") 
    210                  
    211                 # Display Host for ThinkGear Connect Socket Server 
    212                 #self.lineEditSynapseHost.setText(SYNAPSE_SERVER_HOST) 
    213                  
    214                 # Display Port for ThinkGear Connect Socket Server 
    215                 #self.lineEditSynapsePort.setText('%i' % SYNAPSE_SERVER_PORT) 
    216                  
    217                  
    218                 # ThinkgGear Progress Bars 
    219                 #self.progressBarEEGDelta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    220                 #self.progressBarEEGTheta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    221                 #self.progressBarEEGLowAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    222                 #self.progressBarEEGHighAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    223                 #self.progressBarEEGLowBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    224                 #self.progressBarEEGHighBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    225                 #self.progressBarEEGLowGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    226                 #self.progressBarEEGMidGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE) 
    227                  
    228                 #self.progressBarAttention.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE) 
    229                 #self.progressBarMeditation.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE) 
    230                  
    231                 #self.progressBarSignalContactQuality.setMaximum(200) 
    232                  
    233                  
    234                 #if MATPLOTLIB_AVAILABLE: 
    235                         #self.rawEEGMatplot = rawEEGMatplotlibCanvas( \ 
    236                                                 #self.tabEEGSignals, \ 
    237                                                 #width=8, \ 
    238                                                 #height=4, \ 
    239                                                 #dpi=100, \ 
    240                                                 #title='Raw EEG Waves') 
    241                         #self.chartEEGMatplot = chartEEGMatplotlibCanvas( \ 
    242                                                 #self.tabCharts, \ 
    243                                                 #width=8, \ 
    244                                                 #height=4, \ 
    245                                                 #dpi=100, \ 
    246                                                 #title='EEG Brain Signals') 
    247                  
    248                 #else: 
    249                         #self.tabWidget.removeTab(self.tabWidget.indexOf(self.tabEEGSignals)) 
    250                         #self.tabWidget.removeTab(self.tabWidget.indexOf(self.tabCharts)) 
    251                  
    252                  
    253116                pass 
    254117         
     
    258121        def connectWidgets(self): 
    259122                 
    260                 #self.connect(self.comboBoxEEGHeadsetModel, \ 
    261                              #QtCore.SIGNAL("currentIndexChanged(int)"), \ 
    262                              #self.updateDevices) 
    263                  
    264                 #self.connect(self.pushButtonBluetoothSearch, \ 
    265                              #QtCore.SIGNAL("clicked()"), \ 
    266                              #self.updateDevices) 
    267                  
    268                 #self.connect(self.pushButtonSynapseServer, \ 
    269                              #QtCore.SIGNAL("clicked()"), \ 
    270                              #self.startSynapseServer) 
    271                  
    272                 #self.connect(self.pushButtonSave, \ 
    273                              #QtCore.SIGNAL("clicked()"), \ 
    274                              #self.saveData) 
    275                  
    276                 #self.connect(self.pushButtonExport, \ 
    277                              #QtCore.SIGNAL("clicked()"), \ 
    278                              #self.exportData) 
    279                  
    280                 #self.connect(self.pushButtonReset, \ 
    281                              #QtCore.SIGNAL("clicked()"), \ 
    282                              #self.resetData) 
    283                  
    284123                pass 
    285          
    286          
    287         ################################################################## 
    288          
    289         #def startSynapseServer(self): 
    290                  
    291                 #eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    292                 #device_address = str(self.comboBoxDeviceSelect.currentText()) 
    293                 #server_interface = str(self.lineEditSynapseHost.text()) 
    294                 #server_port = int(self.lineEditSynapsePort.text()) 
    295                  
    296                  
    297                 #if ((eeg_headset_model == 'NeuroSky MindWave Mobile') or \ 
    298                     #(eeg_headset_model == 'NeuroSky MindWave') or \ 
    299                     #(eeg_headset_model == 'NeuroSky MindSet')): 
    300                          
    301                         #self.startThinkGearConnectService() 
    302                  
    303                 #elif (eeg_headset_model == 'Emotiv EPOC'): 
    304                          
    305                         #self.startEmotivService() 
    306                  
    307                  
    308                 #if UPDATE_INTERFACE_VIA_TIMER: 
    309                         #self.updateInterfaceTimer.start(INTERFACE_UPDATE_FREQUENCY) 
    310                  
    311                 #else: 
    312                         #self.synapseClient = \ 
    313                                 #synapse_client.puzzlebox_synapse_client( \ 
    314                                         #self.log, \ 
    315                                         #server_host=server_interface, \ 
    316                                         #server_port=server_port, \ 
    317                                         #DEBUG=0, \ 
    318                                         #parent=self) 
    319                          
    320                         #self.synapseClient.start() 
    321                  
    322                  
    323                 #device_selection = self.comboBoxDeviceSelect.currentText() 
    324                 #self.textLabelBluetoothStatus.setText("Status: Connected") 
    325                 #self.pushButtonBluetoothSearch.setEnabled(False) 
    326                 #self.comboBoxDeviceSelect.setEnabled(False) 
    327                 #self.comboBoxEEGHeadsetModel.setEnabled(False) 
    328                  
    329                 #self.lineEditSynapseHost.setEnabled(False) 
    330                 #self.lineEditSynapsePort.setEnabled(False) 
    331                  
    332                 #self.pushButtonSynapseServer.setText('Stop') 
    333                  
    334                 #self.progressBarEEGDelta.setValue(0) 
    335                 #self.progressBarEEGTheta.setValue(0) 
    336                 #self.progressBarEEGLowAlpha.setValue(0) 
    337                 #self.progressBarEEGHighAlpha.setValue(0) 
    338                 #self.progressBarEEGLowBeta.setValue(0) 
    339                 #self.progressBarEEGHighBeta.setValue(0) 
    340                 #self.progressBarEEGLowGamma.setValue(0) 
    341                 #self.progressBarEEGMidGamma.setValue(0) 
    342                  
    343                 #self.progressBarAttention.setValue(0) 
    344                 #self.progressBarMeditation.setValue(0) 
    345                  
    346                  
    347                 #self.disconnect(self.pushButtonSynapseServer, \ 
    348                                      #QtCore.SIGNAL("clicked()"), \ 
    349                                      #self.startSynapseServer) 
    350                  
    351                 #self.connect(self.pushButtonSynapseServer, \ 
    352                                   #QtCore.SIGNAL("clicked()"), \ 
    353                                   #self.stopSynapseServer) 
    354          
    355          
    356         ################################################################## 
    357          
    358         #def stopSynapseServer(self): 
    359                  
    360                 #eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    361                 #device_address = str(self.comboBoxDeviceSelect.currentText()) 
    362                  
    363                 #if ((eeg_headset_model == 'NeuroSky MindWave Mobile') or \ 
    364                     #(eeg_headset_model == 'NeuroSky MindWave') or \ 
    365                     #(eeg_headset_model == 'NeuroSky MindSet')): 
    366                          
    367                         #self.stopThinkGearConnectService() 
    368                  
    369                 #elif (eeg_headset_model == 'Emotiv EPOC'): 
    370                          
    371                         #self.stopEmotivService() 
    372                  
    373                  
    374                 #if UPDATE_INTERFACE_VIA_TIMER: 
    375                         #self.updateInterfaceTimer.stop() 
    376                 #else: 
    377                         #try: 
    378                                 #self.synapseClient.exitThread() 
    379                                 ##self.synapseClient.disconnectFromHost() 
    380                         #except Exception, e: 
    381                                 #if self.DEBUG: 
    382                                         #print "Call failed to self.synapseClient.exitThread():", 
    383                                         ##print "Call failed to self.synapseClient.disconnectFromHost():", 
    384                                         #print e 
    385                          
    386                         #try: 
    387                                 #self.synapseServer.exitThread() 
    388                         #except Exception, e: 
    389                                 #if self.DEBUG: 
    390                                         #print "Call failed to self.synapseServer.exitThread():", 
    391                                         #print e 
    392                  
    393                  
    394                 #self.disconnect(self.pushButtonSynapseServer, \ 
    395                                 #QtCore.SIGNAL("clicked()"), \ 
    396                                 #self.stopSynapseServer) 
    397                  
    398                 #self.connect(self.pushButtonSynapseServer, \ 
    399                                   #QtCore.SIGNAL("clicked()"), \ 
    400                                   #self.startSynapseServer) 
    401                  
    402                 #self.lineEditSynapseHost.setEnabled(True) 
    403                 #self.lineEditSynapsePort.setEnabled(True) 
    404                  
    405                 #self.pushButtonSynapseServer.setText('Start') 
    406                  
    407                 #self.pushButtonBluetoothSearch.setEnabled(True) 
    408                  
    409                 #self.pushButtonSynapseServer.setChecked(False) 
    410                  
    411                 #self.textLabelBluetoothStatus.setText("Status: Disconnected") 
    412                  
    413                 #self.pushButtonBluetoothSearch.setEnabled(True) 
    414                  
    415                 #self.comboBoxDeviceSelect.setEnabled(True) 
    416                 #self.comboBoxEEGHeadsetModel.setEnabled(True) 
    417                  
    418                  
    419                 #self.progressBarEEGDelta.setValue(0) 
    420                 #self.progressBarEEGTheta.setValue(0) 
    421                 #self.progressBarEEGLowAlpha.setValue(0) 
    422                 #self.progressBarEEGHighAlpha.setValue(0) 
    423                 #self.progressBarEEGLowBeta.setValue(0) 
    424                 #self.progressBarEEGHighBeta.setValue(0) 
    425                 #self.progressBarEEGLowGamma.setValue(0) 
    426                 #self.progressBarEEGMidGamma.setValue(0) 
    427                  
    428                 #self.progressBarAttention.setValue(0) 
    429                 #self.progressBarMeditation.setValue(0) 
    430                  
    431                 #self.progressBarSignalContactQuality.setValue(0) 
    432                  
    433                 #self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE 
    434                  
    435                 ## In case the user connects to a MindSet, then disconnects 
    436                 ## and re-connects to a MindSet Emulator, 
    437                 ## we need to reset the max power values 
    438                 #self.progressBarEEGDelta.setMaximum(self.maxEEGPower) 
    439                 #self.progressBarEEGTheta.setMaximum(self.maxEEGPower) 
    440                 #self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower) 
    441                 #self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower) 
    442                 #self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower) 
    443                 #self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower) 
    444                 #self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower) 
    445                 #self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower) 
    446          
    447          
    448         ################################################################## 
    449          
    450         #def startThinkGearConnectService(self): 
    451                  
    452                 #eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    453                 #device_address = str(self.comboBoxDeviceSelect.currentText()) 
    454                 #server_interface = str(self.lineEditSynapseHost.text()) 
    455                 #server_port = int(self.lineEditSynapsePort.text()) 
    456                 #emulate_headset_data = (device_address == 'ThinkGear Emulator') 
    457                  
    458                  
    459                 #self.synapseServer = \ 
    460                         #thinkgear_server.puzzlebox_synapse_server_thinkgear( \ 
    461                                 #self.log, \ 
    462                                 #server_interface=server_interface, \ 
    463                                 #server_port=server_port, \ 
    464                                 #device_model=eeg_headset_model, \ 
    465                                 #device_address=device_address, \ 
    466                                 #emulate_headset_data=emulate_headset_data, \ 
    467                                 #DEBUG=DEBUG, \ 
    468                                 #parent=self) 
    469                  
    470                 #self.synapseServer.start() 
    471          
    472          
    473         ################################################################## 
    474          
    475         #def stopThinkGearConnectService(self): 
    476                  
    477                 #pass 
    478          
    479          
    480         ################################################################## 
    481          
    482         #def startEmotivService(self): 
    483                  
    484                 ##eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    485                 #device_address = str(self.comboBoxDeviceSelect.currentText()) 
    486                  
    487                 ##server_host = configuration.EMOTIV_SERVER_HOST 
    488                  
    489                 #if device_address == 'Emotiv Control Panel': 
    490                         ##server_port = configuration.EMOTIV_SERVER_PORT_CONTROL_PANEL 
    491                         #device_address = configuration.EMOTIV_SERVER_PORT_CONTROL_PANEL 
    492                 #else: 
    493                         ##server_port = configuration.EMOTIV_SERVER_PORT_EMOCOMPOSER 
    494                         #device_address = configuration.EMOTIV_SERVER_PORT_EMOCOMPOSER 
    495                  
    496                  
    497                 #server_interface = str(self.lineEditSynapseHost.text()) 
    498                 #server_port = int(self.lineEditSynapsePort.text()) 
    499                 #eeg_headset_model = str(self.comboBoxEEGHeadsetModel.currentText()) 
    500                 ##device_address = str(self.comboBoxDeviceSelect.currentText()) 
    501                 #emulate_headset_data = (device_address == 'ThinkGear Emulator') 
    502                  
    503                  
    504                 #self.synapseServer = \ 
    505                         #emotiv_server.puzzlebox_synapse_server_emotiv( \ 
    506                                 #self.log, \ 
    507                                 #server_interface=server_interface, \ 
    508                                 #server_port=server_port, \ 
    509                                 #device_model=eeg_headset_model, \ 
    510                                 #device_address=device_address, \ 
    511                                 #emulate_headset_data=emulate_headset_data, \ 
    512                                 #DEBUG=DEBUG, \ 
    513                                 #parent=self) 
    514                  
    515                 #self.synapseServer.start() 
    516                  
    517                  
    518                 #self.progressBarEEGDelta.setEnabled(False) 
    519                 #self.progressBarEEGTheta.setEnabled(False) 
    520                 #self.progressBarEEGLowAlpha.setEnabled(False) 
    521                 #self.progressBarEEGHighAlpha.setEnabled(False) 
    522                 #self.progressBarEEGLowBeta.setEnabled(False) 
    523                 #self.progressBarEEGHighBeta.setEnabled(False) 
    524                 #self.progressBarEEGLowGamma.setEnabled(False) 
    525                 #self.progressBarEEGMidGamma.setEnabled(False) 
    526                  
    527                 ##self.progressBarAttention.setEnabled(False) 
    528                 ##self.progressBarMeditation.setEnabled(False) 
    529          
    530          
    531         ################################################################## 
    532          
    533         #def stopEmotivService(self): 
    534                  
    535                 ##self.emotivClient.stop() 
    536                  
    537                 #self.progressBarEEGDelta.setEnabled(True) 
    538                 #self.progressBarEEGTheta.setEnabled(True) 
    539                 #self.progressBarEEGLowAlpha.setEnabled(True) 
    540                 #self.progressBarEEGHighAlpha.setEnabled(True) 
    541                 #self.progressBarEEGLowBeta.setEnabled(True) 
    542                 #self.progressBarEEGHighBeta.setEnabled(True) 
    543                 #self.progressBarEEGLowGamma.setEnabled(True) 
    544                 #self.progressBarEEGMidGamma.setEnabled(True) 
    545                  
    546                 ##self.progressBarAttention.setEnabled(True) 
    547                 ##self.progressBarMeditation.setEnabled(True) 
    548          
    549          
    550         ################################################################## 
    551          
    552         #def updateInterface(self): 
    553                  
    554                 #if not self.synapseServer.emulate_headset_data: 
    555                         #self.processPacketThinkGear( \ 
    556                                 #self.synapseServer.protocol.data_packet) 
    557          
    558          
    559         ################################################################## 
    560          
    561         #def processPacket(self, packet): 
    562                  
    563                 #self.processPacketThinkGear(packet) 
    564                 #self.processPacketEmotiv(packet) 
    565                  
    566                  
    567                 ##if ((self.synapseServer.protocol != None) and 
    568                 #if (self.tabWidget.currentIndex() == \ 
    569                     #self.tabWidget.indexOf(self.tabControlPanel)): 
    570                          
    571                         #self.updateProfileSessionStatus() 
    572          
    573          
    574         ################################################################## 
    575          
    576         #def processPacketThinkGear(self, packet): 
    577                  
    578                 ##if self.DEBUG > 2: 
    579                         ##print packet 
    580                  
    581                  
    582                 #if ('rawEeg' in packet.keys()): 
    583                         #self.packets['rawEeg'].append(packet['rawEeg']) 
    584                         #value = packet['rawEeg'] 
    585                         #if MATPLOTLIB_AVAILABLE and \ 
    586                                 #(self.tabWidget.currentIndex() == \ 
    587                                  #self.tabWidget.indexOf(self.tabEEGSignals)): 
    588                                 #self.rawEEGMatplot.update_figure(value) 
    589                         #return 
    590                 #else: 
    591                         #self.packets['signals'].append(packet) 
    592                  
    593                  
    594                 #if ('poorSignalLevel' in packet.keys()): 
    595                         #value = 200 - packet['poorSignalLevel'] 
    596                         #self.progressBarSignalContactQuality.setValue(value) 
    597                         #self.textEditDebugConsole.append("") 
    598                         #try: 
    599                                 #(date, localtime) = self.parseTimeStamp(packet['timestamp']) 
    600                                 #self.textEditDebugConsole.append("Timestamp: %s %s" % (date, localtime)) 
    601                         #except: 
    602                                 #pass 
    603                         #self.textEditDebugConsole.append("poorSignalLevel: %i" % \ 
    604                                                          #packet['poorSignalLevel']) 
    605                  
    606                  
    607                 #if ('eSense' in packet.keys()): 
    608                          
    609                         #if ('attention' in packet['eSense'].keys()): 
    610                                 #value = packet['eSense']['attention'] 
    611                                 #self.progressBarAttention.setValue(value) 
    612                                 #self.textEditDebugConsole.append("eSense attention: %i" % value) 
    613                          
    614                         #if ('meditation' in packet['eSense'].keys()): 
    615                                 #value = packet['eSense']['meditation'] 
    616                                 #self.progressBarMeditation.setValue(value) 
    617                                 #self.textEditDebugConsole.append("eSense meditation: %i" % value) 
    618                          
    619                          
    620                         #if MATPLOTLIB_AVAILABLE: 
    621                                 #self.chartEEGMatplot.update_values('eSense', packet['eSense']) 
    622                                 #if (self.tabWidget.currentIndex() == \ 
    623                                     #self.tabWidget.indexOf(self.tabCharts)): 
    624                                         #self.chartEEGMatplot.update_figure('eSense', packet['eSense']) 
    625                  
    626                  
    627                 #if ('eegPower' in packet.keys()): 
    628                          
    629                         ## If we are not emulating packets we'll set the maximum EEG Power value 
    630                         ## threshold to the default (or maximum value found within this packet) 
    631                         #if not self.synapseServer.emulate_headset_data: 
    632                                 #self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE 
    633                          
    634                         #for value in packet['eegPower'].keys(): 
    635                                 #if packet['eegPower'][value] > self.maxEEGPower: 
    636                                         #self.maxEEGPower = packet['eegPower'][value] 
    637                          
    638                          
    639                         #if ('delta' in packet['eegPower'].keys()): 
    640                                 #value = packet['eegPower']['delta'] 
    641                                 #self.progressBarEEGDelta.setMaximum(self.maxEEGPower) 
    642                                 #self.progressBarEEGDelta.setValue(value) 
    643                                 #self.textEditDebugConsole.append("delta: %i" % value) 
    644                          
    645                         #if ('theta' in packet['eegPower'].keys()): 
    646                                 #value = packet['eegPower']['theta'] 
    647                                 #self.progressBarEEGTheta.setMaximum(self.maxEEGPower) 
    648                                 #self.progressBarEEGTheta.setValue(value) 
    649                                 #self.textEditDebugConsole.append("theta: %i" % value) 
    650                          
    651                         #if ('lowAlpha' in packet['eegPower'].keys()): 
    652                                 #value = packet['eegPower']['lowAlpha'] 
    653                                 #self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower) 
    654                                 #self.progressBarEEGLowAlpha.setValue(value) 
    655                                 #self.textEditDebugConsole.append("lowAlpha: %i" % value) 
    656                          
    657                         #if ('highAlpha' in packet['eegPower'].keys()): 
    658                                 #value = packet['eegPower']['highAlpha'] 
    659                                 #self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower) 
    660                                 #self.progressBarEEGHighAlpha.setValue(value) 
    661                                 #self.textEditDebugConsole.append("highAlpha: %i" % value) 
    662                          
    663                         #if ('lowBeta' in packet['eegPower'].keys()): 
    664                                 #value = packet['eegPower']['lowBeta'] 
    665                                 #self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower) 
    666                                 #self.progressBarEEGLowBeta.setValue(value) 
    667                                 #self.textEditDebugConsole.append("lowBeta: %i" % value) 
    668                          
    669                         #if ('highBeta' in packet['eegPower'].keys()): 
    670                                 #value = packet['eegPower']['highBeta'] 
    671                                 #self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower) 
    672                                 #self.progressBarEEGHighBeta.setValue(value) 
    673                                 #self.textEditDebugConsole.append("highBeta: %i" % value) 
    674                          
    675                         #if ('lowGamma' in packet['eegPower'].keys()): 
    676                                 #value = packet['eegPower']['lowGamma'] 
    677                                 #self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower) 
    678                                 #self.progressBarEEGLowGamma.setValue(value) 
    679                                 #self.textEditDebugConsole.append("lowGamma: %i" % value) 
    680                          
    681                         #if ('highGamma' in packet['eegPower'].keys()): 
    682                                 #value = packet['eegPower']['highGamma'] 
    683                                 #self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower) 
    684                                 #self.progressBarEEGMidGamma.setValue(value) 
    685                                 #self.textEditDebugConsole.append("highGamma: %i" % value) 
    686                          
    687                          
    688                         #if MATPLOTLIB_AVAILABLE: 
    689                                 #self.chartEEGMatplot.update_values('eegPower', packet['eegPower']) 
    690                                 #if (self.tabWidget.currentIndex() == \ 
    691                                     #self.tabWidget.indexOf(self.tabCharts)): 
    692                                         #self.chartEEGMatplot.update_figure('eegPower', packet['eegPower']) 
    693                  
    694                  
    695                 ###if ((self.synapseServer.protocol != None) and 
    696                 ##if (self.tabWidget.currentIndex() == \ 
    697                     ##self.tabWidget.indexOf(self.tabControlPanel)): 
    698                          
    699                         ##self.updateProfileSessionStatus() 
    700          
    701          
    702         ################################################################## 
    703          
    704         #def processPacketEmotiv(self, packet): 
    705                  
    706                 #if self.DEBUG > 2: 
    707                         #print "INFO [Synapse:Interface] Emotiv packet received:" 
    708                         #print packet 
    709                  
    710                  
    711                 #if ('emotivStatus' in packet.keys()): 
    712                          
    713                         #if ('timeFromStart' in packet['emotivStatus']): 
    714                                 #if not configuration.EMULATE_THINKGEAR_FOR_EMOTIV: 
    715                                         #self.textEditDebugConsole.append("") 
    716                                         #try: 
    717                                                 #(date, localtime) = self.parseTimeStamp(packet['timestamp']) 
    718                                                 #self.textEditDebugConsole.append("Timestamp: %s %s" % (date, localtime)) 
    719                                         #except: 
    720                                                 #pass 
    721                                 #self.textEditDebugConsole.append("timeFromStart: %f" % \ 
    722                                                                   #packet['emotivStatus']['timeFromStart']) 
    723                          
    724                         #if ('headsetOn' in packet['emotivStatus']): 
    725                                 #self.textEditDebugConsole.append("headsetOn: %s" % \ 
    726                                                                   #bool(packet['emotivStatus']['headsetOn'])) 
    727                          
    728                         #if ('contactNumberOfQualityChannels' in packet['emotivStatus']): 
    729                                 #self.textEditDebugConsole.append("contactNumberOfQualityChannels: %i" % \ 
    730                                                                   #packet['emotivStatus']['contactNumberOfQualityChannels']) 
    731                          
    732                         #if ('wireless' in packet['emotivStatus']): 
    733                                 #self.textEditDebugConsole.append("wireless: %i" % \ 
    734                                                                   #packet['emotivStatus']['wireless']) 
    735                  
    736                  
    737                 #if ('affectiv' in packet.keys()): 
    738                          
    739                         #if ('excitement' in packet['affectiv']): 
    740                                 #self.textEditDebugConsole.append("excitement: %.2f" % \ 
    741                                                                   #packet['affectiv']['excitement']) 
    742                          
    743                         #if ('longTermExcitement' in packet['affectiv']): 
    744                                 #self.textEditDebugConsole.append("longTermExcitement: %.2f" % \ 
    745                                                                   #packet['affectiv']['longTermExcitement']) 
    746                          
    747                         #if ('meditation' in packet['affectiv']): 
    748                                 #self.textEditDebugConsole.append("meditation: %.2f" % \ 
    749                                                                   #packet['affectiv']['meditation']) 
    750                          
    751                         #if ('frustration' in packet['affectiv']): 
    752                                 #self.textEditDebugConsole.append("frustration: %.2f" % \ 
    753                                                                   #packet['affectiv']['frustration']) 
    754                          
    755                         #if ('engagementBoredom' in packet['affectiv']): 
    756                                 #self.textEditDebugConsole.append("engagementBoredom: %.2f" % \ 
    757                                                                   #packet['affectiv']['engagementBoredom']) 
    758                  
    759                  
    760                 #if ('cognitiv' in packet.keys()): 
    761                          
    762                         #if ('currentAction' in packet['cognitiv']): 
    763                                 #self.textEditDebugConsole.append("currentAction: %i" % \ 
    764                                                                   #packet['cognitiv']['currentAction']) 
    765                          
    766                         #if ('currentActionPower' in packet['cognitiv']): 
    767                                 #self.textEditDebugConsole.append("currentActionPower: %.2f" % \ 
    768                                                                   #packet['cognitiv']['currentActionPower']) 
    769124         
    770125         
     
    1172527                 
    1173528                return(devices) 
    1174          
    1175          
    1176         ################################################################## 
    1177          
    1178         #def updateDevices(self): 
    1179                  
    1180                 #if (self.parent != None): 
    1181                         #source = self.parent 
    1182                 #else: 
    1183                         #source = self 
    1184                  
    1185                 #model = source.comboBoxEEGHeadsetModel.currentText() 
    1186                  
    1187                 #devices = self.searchForDevices() 
    1188                  
    1189                 #source.comboBoxDeviceSelect.clear() 
    1190                  
    1191                 #if (model == 'NeuroSky MindWave' or \ 
    1192                     #model == 'NeuroSky MindSet' or \ 
    1193                     #model == 'NeuroSky MindWave Mobile'): 
    1194                          
    1195                         #devices.insert(0, 'ThinkGear Emulator') 
    1196                  
    1197                 #elif (model == 'Emotiv EPOC'): 
    1198                          
    1199                         #devices.insert(0, 'EmoComposer') 
    1200                         #devices.insert(0, 'Emotiv Control Panel') 
    1201                  
    1202                  
    1203                 #for device in devices: 
    1204                         #source.comboBoxDeviceSelect.addItem(device) 
    1205529         
    1206530         
     
    17171041                 
    17181042                return(datetime) 
    1719          
    1720          
    1721         ################################################################## 
    1722          
    1723         def stop(self): 
    1724                  
    1725                 if UPDATE_INTERFACE_VIA_TIMER: 
    1726                         self.updateInterfaceTimer.stop() 
    1727                 else: 
    1728                         #if self.thinkgearConnectClient != None: 
    1729                                 #self.thinkgearConnectClient.exitThread() 
    1730                         #if self.emotivClient != None: 
    1731                                 #self.emotivClient.exitThread() 
    1732                         if self.synapseClient != None: 
    1733                                 self.synapseClient.exitThread() 
    1734                  
    1735                 if self.synapseServer != None: 
    1736                         self.synapseServer.exitThread() 
    1737          
    1738          
    1739         ################################################################## 
    1740          
    1741         def closeEvent(self, event): 
    1742                  
    1743                 quit_message = "Are you sure you want to exit the program?" 
    1744                  
    1745                 reply = QtGui.QMessageBox.question( \ 
    1746                            self, \ 
    1747                           'Message', \ 
    1748                            quit_message, \ 
    1749                            QtGui.QMessageBox.Yes, \ 
    1750                            QtGui.QMessageBox.No) 
    1751                  
    1752                 if reply == QtGui.QMessageBox.Yes: 
    1753                          
    1754                         self.stop() 
    1755                          
    1756                         event.accept() 
    1757                  
    1758                 else: 
    1759                         event.ignore() 
     1043 
Note: See TracChangeset for help on using the changeset viewer.