class BluetoothPlugin(ConnectionPlugin): ADDR_FILE = 'config/bluetooth_address' def __init__(self): super().__init__() self.listener = Listener() self.addr = self.__get_bluetooth_addr() # API method def broadcast(self, msg): print("BROADCASTING") NetworkScanner(msg).start() # API method def run(self): self.listener.start() # API method def address(self): return self.addr def __get_bluetooth_addr(self): with open(BluetoothPlugin.ADDR_FILE, 'r') as file: addr = file.read() print("Bluetooth Address: {}".format(addr)) return addr.strip()
def start(self): self.running = True conn_listener = Listener(self.index, self.port, self.clock) conn_listener.start() for i in range(constants.EVENTS_COUNT): if not self.running: break sleep(min(random.random() + 0.5, 1)) self.clock.increment() if random.random() > self.chance: # local self.logger.info(f"{perf_counter_ns() // 1000} {self.index} {self.clock.get()}{self.index} l") else: # remote idx, node = self.get_node() try: self.send_message(idx, node) except SocketTimeout: print( f"""Error: Timeout sending message to node {idx} ({node["host"]}:{node["port"]})""" ) break conn_listener.stop()
def add_macro(): global database, listenter name = request.form.get("name") language = request.form.get("language") age_group = request.form.get("age") gender = request.form.get("gender") description = request.form.get("description") keyboard_events_path = request.form.get("key_file") event_strings = request.form.get("events_string") sound_1 = request.form.get("sound_1") sound_2 = request.form.get("sound_2") sound_3 = request.form.get("sound_3") ok, message = training_service.get_model(name, (sound_1, sound_2, sound_3), language, age_group, gender) if (not ok): return jsonify({"message": message}) else: try: database.insert((name, language, age_group, gender, description, event_strings, keyboard_events_path, message)) try: listenter.stop() except Exception as e: pass if (len(database.get_all()) > 0): listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor) listenter.start() return jsonify({"message": "ok"}) except sqlite3.Error as e: return jsonify({"message": e.args[0]})
class ReportQueue: def __init__(self, rr): self.railroad = rr self.msgQ = queue.Queue(0) self.listener = Listener(self, "192.168.1.142", "8001", self.msgQ) self.listener.start() def serve_forever(self): self.forever = True while self.forever: try: msg = self.msgQ.get(True, 0.25) except queue.Empty: msg = None if msg: #print("(%s)" % msg) jdata = json.loads(msg) if "disconnect" in jdata.keys(): self.forever = False else: self.railroad.processMsg(jdata) self.listener.kill() self.listener.join()
def main(): listener = Listener() listener.start() while True: recv_queue_data = listener.queue.get() recv_data = recv_queue_data.msgtype distance = recv_queue_data.msg if recv_data == 0x05: # Follower to move forward totalMoves(distance) print ("Received Follower move forward") elif recv_data == 0x06: # Follower to move backward totalMoves(distance) print ("Received Follower move backward") elif recv_data == 0x07: # Follower to move left totalMoves(distance) print ("Received Follower move left") elif recv_data == 0x09: # Follower to move right totalMoves(distance) print ("Received Follower move right") elif recv_data == 0x13: # Follower reports found token followerTokenFND() elif recv_data == 0x15: # Scanning Follower Servo print ("Received Scanning Beginning") elif recv_data == 0x16: # Scan returned Lead Found scanServo() elif recv_data == 0x17: # Scan returned Object Found scanServo() else: # Something unexpected happened print("Received unexpected data %d" % recv_data) try: cmdInput(listener.queue) except KeyboardInterrupt: pass listener.close()
def start_ip_listener(): listener_ipv4 = None listener_ipv6 = None if socket.has_ipv6: try: listener_ipv6 = Listener(shared.listening_host, shared.listening_port, family=socket.AF_INET6) listener_ipv6.start() except Exception as e: logging.warning( 'Error while starting IPv6 listener on port {}'.format( shared.listening_port)) logging.warning(e) try: listener_ipv4 = Listener(shared.listening_host, shared.listening_port) listener_ipv4.start() except Exception as e: if listener_ipv6: logging.warning( 'Error while starting IPv4 listener on port {}. '.format( shared.listening_port) + 'However the IPv6 one seems to be working and will probably accept IPv4 connections.' ) else: logging.error( 'Error while starting IPv4 listener on port {}. '.format( shared.listening_port) + 'You will not receive incoming connections. Please check your port configuration' ) logging.error(e)
def main(): listener = Listener() #incoming_message_Thread = Thread(target=incoming_message_handle, args=[listener.clientList], daemon=True) listener.start() #incoming_message_Thread.start() while True: try: recv_queue_data = listener.queue.get(timeout=1) print("Message : ", recv_queue_data) except Empty: print("empty") pass try: recv_data = recv_queue_data.msgtype message_pack_recv = recv_queue_data.msg if recv_data == "Rover Move": # Follower to move FORWARD if message_pack_recv == ROVER_FORWARD: #totalMoves(distance) print ("Received Follower move forward") elif message_pack_recv == ROVER_BACKWARD: # Follower to move BACKWARD #totalMoves(distance) print ("Received Follower move backward") elif message_pack_recv == ROVER_LEFT: # Follower to move LEFT #totalMoves(distance) print ("Received Follower move left") elif message_pack_recv == ROVER_RIGHT: # Follower to move RIGHT #totalMoves(distance) print ("Received Follower move right") elif message_pack_recv == ROVER_STOP: # Follower to STOP #totalMoves(distance) print ("Received Follower STOP") elif recv_data == "Follower Distance": # Follower reports distance traveled totalMoves(message_pack_recv) print ("Received Follower Distance: ", message_pack_recv) elif recv_data == "Follower Token Found": # Follower reports found token followerTokenFND() elif recv_data == "Scanning Follower Servo": # Scanning Follower Servo if message_pack_recv == SCAN_STARTED: # Servo Scan Started print ("Received Scanning Beginning") elif message_pack_recv == LEAD_FOUND: # Scan returned Lead Found scanServo() elif message_pack_recv == OBJECT_FOUND: # Scan returned Object Found scanServo() elif recv_data == "Follower Distance To Lead": # Follower reports found token print ("Received Follower Distance To Lead: ", message_pack_recv) else: # Something unexpected happened print("Received unexpected data %d" % recv_data) except KeyboardInterrupt: print("CTRL C Detected") return listener.close()
def delete(id=None): global listenter, database, args _, _, _, _, _, _, _, ke_path, model_path = database.get_macro(id) os.remove(ke_path) os.remove(model_path) database.delete_macro(id) try: listenter.stop() except Exception as e: pass if (len(database.get_all()) > 0): listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor) listenter.start() return redirect('/')
def main(): logging.basicConfig(filename='/var/log/executioner/executioner.log', level=logging.INFO, format='%(asctime)s %(message)s') #not handling signals because python can't reconcile them with multithreading. supposedly Py3.3 does though. #signal.signal(signal.SIGINT, handle_signal) #signal.signal(signal.SIGTERM, handle_signal) sys.stdout = LoggerWriter(logging.info) sys.stderr = LoggerWriter(logging.error) MotorController.init() SwitchController.init() listener = Listener() listener.start()
class DataGen(object): def __init__(self): conn1, conn2 = multiprocessing.Pipe() self.conn = conn2 self.listener = Listener(debug_connection = conn1) self.listener.start() self.bpm_to_test = [0] self.bpm_energies = [0] def __iter__(self): return self def next(self): while self.conn.poll(): self.bpm_to_test, self.bpm_energies = self.conn.recv() return (self.bpm_to_test, self.bpm_energies)
class DataGen(object): def __init__(self): conn1, conn2 = multiprocessing.Pipe() self.conn = conn2 self.listener = Listener(debug_connection=conn1) self.listener.start() self.bpm_to_test = [0] self.bpm_energies = [0] def __iter__(self): return self def next(self): while self.conn.poll(): self.bpm_to_test, self.bpm_energies = self.conn.recv() return (self.bpm_to_test, self.bpm_energies)
class Communicator: messageQueue = None def __init__(self, peer): # print "A communicator is created!" self.peer = peer self.messageQueue = peer.messageQueue self.mylistener = Listener(peer) self.mylistener.setDaemon(True) self.mylistener.start() # self.operation() def send(self, host, sendPort, content): # print "sending ..." # socket setting buf = 1024 * 1024 addr = (host, sendPort) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sock.connect(addr) except Exception: print "Connection lost with: ", addr return False sock.send(content) sock.close() return True # sock.sendto(content, addr) # sock.close() # def rcv(self, myPId): # msgList = [] # newMsgQueue = [] # for item in self.messageQueue: # msgList.append(item) # self.messageQueue = newMsgQueue # return msgList def prtMsgQueue(self): for item in self.messageQueue: print item
def start_ip_listener(): listener_ipv4 = None listener_ipv6 = None if socket.has_ipv6: try: listener_ipv6 = Listener(shared.listening_host, shared.listening_port, family=socket.AF_INET6) listener_ipv6.start() except Exception as e: logging.warning('Error while starting IPv6 listener on port {}'.format(shared.listening_port)) logging.warning(e) try: listener_ipv4 = Listener(shared.listening_host, shared.listening_port) listener_ipv4.start() except Exception as e: if listener_ipv6: logging.warning('Error while starting IPv4 listener on port {}. '.format(shared.listening_port) + 'However the IPv6 one seems to be working and will probably accept IPv4 connections.') else: logging.error('Error while starting IPv4 listener on port {}. '.format(shared.listening_port) + 'You will not receive incoming connections. Please check your port configuration') logging.error(e)
def EmonHub(): # Load settings settings = ConfigObj("emonhub.conf", file_error=True) # Create queue for node packets queue = Queue.Queue(0) # Create and start serial listener a = Listener(queue, settings) a.start() # Create and start http dispatcher b = Dispatcher(queue, settings) b.start() while 1: try: time.sleep(0.1) except KeyboardInterrupt: print "Stopping threads" a.stop = True b.stop = True break
def EmonHub(): # Load settings settings = ConfigObj("emonhub.conf", file_error=True) # Create queue for node packets queue = Queue.Queue(0) # Create and start serial listener a = Listener(queue,settings) a.start() # Create and start http dispatcher b = Dispatcher(queue,settings) b.start() while 1: try: time.sleep(0.1) except KeyboardInterrupt: print "Stopping threads" a.stop = True b.stop = True break
class Main(QMainWindow): def __init__(self): QMainWindow.__init__(self) # make variables self.voltage = 0 self.current = 0 # load gui.ui self.ui = loadUi('../gui/gui.ui') self.ui.setAttribute(QtCore.Qt.WA_DeleteOnClose, True) self.ui.destroyed.connect(self.shutdown) # show window self.ui.show() # make new log object self.log = Log(self.ui) # make new sender object self.sender = Sender(self.ui, self.log) # set events self.set_events() # initial reset self.sender.reset() # new listener self.listener = Listener() # new_data_received signal self.listener.data_received.connect(self.new_data_received) # start listener self.listener.start() # new interpreter self.interpreter = Interpreter(self.log, self.ui) # add tree self.add_tree() def add_tree(self): # Items for tree voltage_item = QTreeWidgetItem(["Spannung", str(self.voltage) + " V"]) self.ui.treeView.addTopLevelItem(voltage_item) current_item = QTreeWidgetItem(["Strom", str(self.current) + " A"]) self.ui.treeView.addTopLevelItem(current_item) power_item = QTreeWidgetItem(["Watt", "0 W"]) self.ui.treeView.addTopLevelItem(power_item) def set_events(self): # sendButton clicked self.ui.sendButton.clicked.connect(lambda: self.sender.send("debug")) # holdButton clicked self.ui.holdButton.clicked.connect(self.log.toggle_hold) # clearButton clicked self.ui.clearButton.clicked.connect(self.log.clear_log) # messageInput return pressed self.ui.messageInput.returnPressed.connect(lambda: self.sender.send("debug")) # sliders value changed self.ui.voltageSlider.sliderReleased.connect(lambda: self.sender.send("slider-voltage")) self.ui.currentSlider.sliderReleased.connect(lambda: self.sender.send("slider-current")) # reset action self.ui.resetActionButton.triggered.connect(self.sender.reset) # automode checkbox self.ui.automodeCheckbox.stateChanged.connect(lambda: self.sender.send("checkbox-automode")) # lamp checkboxes self.ui.lamp1Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp")) self.ui.lamp2Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp")) self.ui.lamp3Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp")) self.ui.lamp4Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp")) def new_data_received(self, text): self.interpreter.interpret(text) def shutdown(self): self.listener.exit()
import redis from listener import Listener class Myclass(object): def __init__(self): pass def test(self, a, b, c): print a, b, c def sum(self, a, b, c): print a + b + c def dispatch(self): self.dispatcher = { 'test': self.test, 'sum': self.sum } r = redis.Redis() client = Listener(r, ['__key*__:*'], Myclass()) client.start()
import os import time import logging from listener import Listener, worker if __name__ == '__main__': logging.basicConfig(filename="log.txt", level=logging.DEBUG, format='%(asctime)s: %(message)s') os.makedirs('screenshots', exist_ok=True) listener = Listener() listener.start() time.sleep(5) listener.stop() worker.stop()
elif msgstring == "start": try: testcase = int(input("Select Test Case:")) assert testcase in range(1, 8) except (TypeError, AssertionError): print("Test case does not exist") continue listener.queue.put(InternalMessage(ROUTER, START_GAME, bytes([testcase]))) elif msgstring == "end": listener.queue.put(InternalMessage(ROUTER, END_GAME, bytes([0]))) else: msgstring = msgstring.encode() while msgstring: msg = InternalMessage(ROUTER, DEBUG_MSG, msgstring[:INTERNAL_MSG_SIZE + 1]) listener.queue.put(msg) msgstring = msgstring[INTERNAL_MSG_SIZE + 1:] if __name__ == "__main__": listener = Listener() outWorker = OutboundWorker(listener.queue, listener.clientList, listener.clientDict) listener.start() outWorker.start() try: cmdInput(listener) except KeyboardInterrupt: pass listener.close()
#! /usr/bin/env python from config import Config # this is a subdir from listener import Listener from poller import Poller import sys if __name__ == "__main__": """Run the monitor. The listener class waits for requests. The poller class polls the PIDs that were input and forwards output to the output class.""" parpid = sys.argv[1] cfg = Config() cfg.add_item('parentpid', parpid) lst = Listener(cfg) lst.start() print "listener started" # Where is the output class? pol = Poller(cfg) pol.start() print "Poller started"
def start( self ): myConfigurationFile = ConfigurationFile( self.fileName ) myConfiguration = myConfigurationFile.load() myListener = Listener( myConfiguration ) myListener.start()
def launch_listener(final_results_queue, total_metrics): listener = Listener(final_results_queue, total_metrics) listener.start()
{ "track" : "Sakhir (Bahrain)", "weather" : "wi-day-sunny", "trackTemperature" : "29", "airTemperature" : "21", "sessionDuration" : 127, "sessionType" : 10 } """ emit('track', udp_listener.race_info) if __name__ == '__main__': """ Run the Listener to parse UDP in a Thread Run the Flask website using socketio in a separated Thread """ config = configparser.ConfigParser(allow_no_value=True) config.read('config.ini') udp_listener = Listener(host=config["UDP"]["host"], port=int(config["UDP"]["port"]), my_name=config["UDP"]["my_name"]) udp_listener.start() socketio.run(app, debug=bool(int(config["server"]["debug"])), use_reloader=bool(int(config["server"]["use_reloader"])), host=config["server"]["host"], port=int(config["server"]["port"]))
def start(self): myConfigurationFile = ConfigurationFile(self.fileName) myConfiguration = myConfigurationFile.load() myListener = Listener(myConfiguration) myListener.start()
class MessageHandler(threading.Thread): def __init__(self, peer, messages, isVerbose=True, listening_mode=False, msgs_freq=1, wait_time=20, port=2123): threading.Thread.__init__(self) self.sock = None self.TAG_NAME = 'GTPV2 SERVER_LISTENER' self.peer = peer self.is_verbose = isVerbose self.messages = messages self.is_listening = listening_mode self.gtp_port = port self.sock = socket(AF_INET, SOCK_DGRAM) self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.sock.bind(('0.0.0.0', self.gtp_port)) self.msgs_freq = msgs_freq self.wait_time = wait_time self.listener = None self.sender = None signal.signal(signal.SIGQUIT, self.stop) signal.signal(signal.SIGINT, self.stop) signal.signal(signal.SIGTERM, self.stop) ## ## @brief Determines if the thread is running ## ## @param self refers to the class itself ## ## @return True if running, False otherwise. ## def isRunning(self): return self.is_running ## ## @brief Starts the execution of the thread ## ## @param self refers to the class itself ## def run(self): self.is_running = True if self.is_listening: if self.is_verbose: print "\033[34m[*]\033[0m starting the listener ...." ''' START Listener ''' self.listener = Listener(open_sock=self.sock, isVerbose=self.is_verbose) self.listener.daemon = True self.listener.start() if self.is_verbose: print "\033[34m[*]\033[0m starting the sender ...." ''' START Sender''' self.sender = Sender(sock=self.sock, messages=self.messages, peers=self.peer, isVerbose=self.is_verbose, msg_freq=self.msgs_freq, wait_time=self.wait_time, gtp_port=self.gtp_port) self.sender_daemon = True self.sender.start() self.sender.join() time.sleep(5) self.stop() ## ## @brief Stops the execution of the thread ## ## @param self refers to the class itself ## def stop(self): if self.sender: self.sender.stop() if self.listener: self.listener.stop() if self.sock: self.sock.close() self.is_running = False if self.is_verbose: print "%s: Stopped" % (self.TAG_NAME)
parser = argparse.ArgumentParser() parser.add_argument("--port", type=int, help="The port for the server run locally", default=8000) parser.add_argument("--sensitivity", type=float, help="Model sensitivity", default=0.35) parser.add_argument("--speed_factor", type=float, help="Keyboard speed factor playback", default=0) return parser.parse_args(argv) args = parse_argument(sys.argv[1:]) if (len(database.get_all()) > 0): listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor) listenter.start() app.run('0.0.0.0', args.port) sound_recorder.end() try: listenter.stop() except: pass database.close()
def main(): signal.signal(signal.SIGINT, handler) signal.signal(signal.SIGTERM, handler) logging.basicConfig(level=shared.log_level, format='[%(asctime)s] [%(levelname)s] %(message)s') logging.info('Starting MiNode') if not os.path.exists(shared.data_directory): try: os.makedirs(shared.data_directory) except Exception as e: logging.warning( 'Error while creating data directory in: {}'.format( shared.data_directory)) logging.warning(e) try: with open(shared.data_directory + 'objects.pickle', mode='br') as file: shared.objects = pickle.load(file) except Exception as e: logging.warning('Error while loading objects from disk.') logging.warning(e) try: with open(shared.data_directory + 'nodes.pickle', mode='br') as file: shared.node_pool = pickle.load(file) except Exception as e: logging.warning('Error while loading nodes from disk.') logging.warning(e) with open(os.path.join(shared.source_directory, 'core_nodes.csv'), mode='r', newline='') as f: reader = csv.reader(f) shared.core_nodes = {tuple(row) for row in reader} shared.node_pool.update(shared.core_nodes) if not shared.trusted_peer: try: for item in socket.getaddrinfo('bootstrap8080.bitmessage.org', 80): shared.unchecked_node_pool.add((item[4][0], 8080)) logging.debug( 'Adding ' + item[4][0] + ' to unchecked_node_pool based on DNS bootstrap method') for item in socket.getaddrinfo('bootstrap8444.bitmessage.org', 80): shared.unchecked_node_pool.add((item[4][0], 8444)) logging.debug( 'Adding ' + item[4][0] + ' to unchecked_node_pool based on DNS bootstrap method') except Exception as e: logging.error('Error during DNS bootstrap') logging.error(e) manager = Manager() manager.clean_objects() manager.clean_connections() manager.start() advertiser = Advertiser() advertiser.start() listener_ipv4 = None listener_ipv6 = None if shared.listen_for_connections: if socket.has_ipv6: try: listener_ipv6 = Listener('', shared.listening_port, family=socket.AF_INET6) listener_ipv6.start() except Exception as e: logging.warning('Error while starting IPv6 listener') logging.warning(e) try: listener_ipv4 = Listener('', shared.listening_port) listener_ipv4.start() except Exception as e: if listener_ipv6: logging.warning( 'Error while starting IPv4 listener. ' 'However the IPv6 one seems to be working and will probably accept IPv4 connections.' ) else: logging.error( 'Error while starting IPv4 listener.' 'You will not receive incoming connections. Please check your port configuration' ) logging.error(e)
class VpnServer(object): def __init__(self, port, shared_key, connected_callback, broken_conn_callback, debug_continue, debug, app): self.port = port self.shared_key = shared_key self.connected_callback = connected_callback self.broken_conn_callback = broken_conn_callback self.send_queue = Queue() self.receive_queue = Queue() self.authenticated = False self.debug_continue = debug_continue self.debug = debug self.waiting = True self.sender = None self.receiver = None self.is_server = True self.sessionkey='' self.app = app def setup(self): try: self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) except socket.error: return (-1, "Could not create socket") try: self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(('', self.port)) Logger.log("Listening for connections...", self.is_server) self.socket.listen(1) except socket.error: return (-1, "Could not bind socket to port " + str(self.port)) return (0, "VPN server set to listen on port " + str(self.port)) def send(self, msg): if (self.authenticated): Logger.log("sessionkey: " +self.sessionkey, self.is_server) emsg = self.auth.encrypt_message(msg, self.auth.get_sessionkey()) self.send_queue.put(emsg) Logger.log("Put message on send queue: "+ msg, self.is_server) else: self.send_queue.put(msg) Logger.log("Put message on send queue: "+ msg, self.is_server) def receive(self): if not self.receive_queue.empty(): msg = self.receive_queue.get() if (self.authenticated): msg, valid = self.auth.decrypt_message(msg, self.auth.get_sessionkey()) if valid is False: return None Logger.log("Decrypted msg: "+ msg, self.is_server) return msg else: return None def start(self, callback=None): self.listener = Listener(self.socket, self.shared_key, self, self.connected_callback, self.app) self.listener.start() def bind(self, client_socket): self.debug_continue.disabled = self.debug self.sender = Sender(client_socket, self.send_queue, self) self.receiver = Receiver(client_socket, self.receive_queue, self) self.sender.start() self.receiver.start() def clear_queues(self): self.receive_queue.queue.clear() self.send_queue.queue.clear() def broken_conn(self): Logger.log("Broken connection", self.is_server) self.send_queue.queue.clear() self.receive_queue.queue.clear() self.sender.close() self.receiver.close() self.waiting = True self.authenticated = False if (self.listener): self.listener.broken_conn() def close(self): Logger.log("Connection closing", self.is_server) self.send_queue.queue.clear() self.receive_queue.queue.clear() self.listener.close() self.socket.close() self.authenticated = False if self.sender: self.sender.close() if self.receiver: self.receiver.close()
def startGame(): listener = Listener('user_output.txt', shortcut_list) listener.start() return getNextLevel()
class NetMgr(Mgr): def __init__(self, engine,localOptions): Mgr.__init__(self, engine) self.engine = engine self.networkingEnabled = localOptions.enableNetworking if self.networkingEnabled: self.server = localOptions.server else: self.server = False self.ip = localOptions.ip self.remainingIDs = [] self.timeToWaitForPlayers = 10 def initialize(self): pass def loadLevel(self): if self.networkingEnabled: self.broadcaster = Broadcaster() self.listener = Listener() self.listener.start() self.broadcaster.start() if self.server or not self.networkingEnabled: self.remainingIDs.append([1,""]) self.remainingIDs.append([2,""]) def releaseLevel(self): if self.networkingEnabled: self.listener.stop() self.broadcaster.stop() self.listener.join() self.broadcaster.join() def tick(self, dtime): if self.networkingEnabled: if dtime < 1 and self.timeToWaitForPlayers > 0: self.timeToWaitForPlayers -= dtime # check to see if all players are ready to start the race if self.timeToWaitForPlayers > 0 and self.engine.gameMgr.allPlayersReady == False: allReady = True for ent in self.engine.entMgr.entities: if not ent.isReady: allReady = False if len(self.engine.entMgr.entities) > 1: self.engine.gameMgr.allPlayersReady = allReady elif self.timeToWaitForPlayers <= 0: self.engine.gameMgr.allPlayersReady = True # get messages incoming = self.listener.getMessages() outgoingMsgs = [] for msgs in incoming: msgType, msg = messages.unpack(msgs) if msgType == const.STATUS: found = False # check to see if the status message is regarding a ship that is already created for ent in self.engine.entMgr.entities: if ent.shipId == msg.shipId: found = True # if it is, send updates to entity if found and msg.shipId != self.engine.entMgr.playerIndex: self.engine.entMgr.entities[msg.shipId].updateQueue.append(msg) # if it isn't, create that entity elif not found: ent = Spaceship("Ship" + str(msg.shipId),msg.shipId, self.engine,const.MESHES[msg.shipId]) ent.pos = self.engine.entMgr.nextPos self.engine.entMgr.nextPos.x += 40 self.engine.entMgr.entities.append(ent) # only process requests before game has started elif msgType == const.REQUEST and self.timeToWaitForPlayers > 0: for ID in self.remainingIDs: # if the id has not been issued already, or if the ID corresponds to a user who has been given an ID (but did not recieve their ID), send the ID if ID[1] == "" or ID[1] == msg.userName: outgoingMsgs.append(messages.pack(messages.InfoMessage(msg.userName,ID[0]),const.INFO)) ID[1] = msg.userName # only process info messages when this player has not been handed a playerIndex elif msgType == const.INFO and not self.server and self.engine.entMgr.playerIndex == -1: self.engine.entMgr.playerIndex = msg.shipId found = False for ent in self.engine.entMgr.entities: if ent.shipId == msg.shipId: found = True if not found: ent = Spaceship("Ship" + str(msg.shipId),msg.shipId, self.engine,const.MESHES[msg.shipId]) ent.pos = self.engine.entMgr.nextPos self.engine.entMgr.nextPos.x += 40 self.engine.entMgr.entities.append(ent) # if this player has not been handed a playerIndex, request one. if self.engine.entMgr.playerIndex == -1: outgoingMsgs.append(messages.pack(messages.RequestMessage(str(socket.gethostname())),const.REQUEST)) # if the player has been handed a playerIndex, send the status of your ship else: myId = self.engine.entMgr.playerIndex myEnt = self.engine.entMgr.entities[myId] outgoingMsgs.append(messages.pack(messages.StatusMessage(myId,myEnt.pos,myEnt.dir,myEnt.colVel,myEnt.speed,myEnt.pitch, myEnt.roll,myEnt.isReady),const.STATUS)) # send outgoing messages for msg in outgoingMsgs: self.broadcaster.addMessage(msg)
#! /usr/bin/env python from config import Config # this is a subdir from listener import Listener from poller import Poller import sys if __name__ == "__main__": """Run the monitor. The listener class waits for requests. The poller class polls the PIDs that were input and forwards output to the output class.""" parpid = sys.argv[1] cfg = Config() cfg.add_item('parentpid',parpid) lst = Listener(cfg) lst.start() print "listener started" # Where is the output class? pol = Poller(cfg) pol.start() print "Poller started"
class NodeTester(wx.Frame): def __init__(self): wx.Frame.__init__(self, None, wx.ID_ANY, "Node Tester", size=(500, 500)) self.SetBackgroundColour(wx.Colour(255, 255, 255)) self.Bind(wx.EVT_CLOSE, self.onClose) self.CreateStatusBar() self.qStatus = queue.Queue() menuBar = wx.MenuBar() self.menuServer = wx.Menu() self.menuServer.Append(MENU_SERVER_NODES, "Nodes Report", "Get Nodes Report") self.menuServer.Append(MENU_SERVER_SHUTDOWN, "Shut down", "Shut down server") self.menuNode = wx.Menu() self.menuNode.Append(MENU_NODE_CONFIG, "Re-Config", "Modify current node configuration") self.menuNode.Append(MENU_NODE_INIT, "Init", "Reinit the node communicatione with the server") self.menuWindow = wx.Menu() self.menuWindow.Append(MENU_WINDOW_INPUTS, "Inputs") self.menuWindow.Append(MENU_WINDOW_OUTPUTS, "Outputs") self.menuWindow.Append(MENU_WINDOW_SERVOS, "Servos/Turnouts") menuBar.Append(self.menuServer, "Server") menuBar.Append(self.menuNode, "Node") menuBar.Append(self.menuWindow, "Window") self.Bind(wx.EVT_MENU, self.onMenuNodes, id=MENU_SERVER_NODES) self.Bind(wx.EVT_MENU, self.onMenuShutdown, id=MENU_SERVER_SHUTDOWN) self.Bind(wx.EVT_MENU, self.onMenuConfig, id=MENU_NODE_CONFIG) self.Bind(wx.EVT_MENU, self.onMenuInit, id=MENU_NODE_INIT) self.Bind(wx.EVT_MENU, self.onMenuInputs, id=MENU_WINDOW_INPUTS) self.Bind(wx.EVT_MENU, self.onMenuOutputs, id=MENU_WINDOW_OUTPUTS) self.Bind(wx.EVT_MENU, self.onMenuServos, id=MENU_WINDOW_SERVOS) self.SetMenuBar(menuBar) self.images = Images("images") self.ipAddress = "192.168.1.142" self.httpPort = "8000" self.socketPort = "8001" self.server = Server() self.listener = None self.inputs = 1 self.outputs = 1 self.servos = 1 self.flags = 0 self.registers = 0 self.inputsMap = [] self.outputsMap = [] self.servosMap = [] self.subscribed = False self.currentNodeAddr = None self.timer = wx.Timer(self) self.ticks = 0 self.clearTimer = None sz = wx.BoxSizer(wx.VERTICAL) sz.AddSpacer(2) self.dlgInputs = None self.dlgOutputs = None self.dlgServos = None boxSvr = wx.StaticBox(self, wx.ID_ANY, " Server ") topBorder, botBorder = boxSvr.GetBordersForSizer() if os.name != 'nt': botBorder += 30 bsizer = wx.BoxSizer(wx.VERTICAL) bsizer.AddSpacer(topBorder) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(boxSvr, wx.ID_ANY, "IP Address:", size=(SVRLABELW, -1))) self.teIpAddr = wx.TextCtrl(boxSvr, wx.ID_ANY, self.ipAddress, size=(125, -1)) self.Bind(wx.EVT_TEXT, self.onTeIpAddrChange, self.teIpAddr) self.teIpAddr.Bind(wx.EVT_KILL_FOCUS, self.onTeIpAddrLoseFocus) self.teIpAddr.Bind(wx.EVT_SET_FOCUS, self.onTeIpAddrSetFocus) hsizer.Add(self.teIpAddr) hsizer.AddSpacer(10) bsizer.Add(hsizer) bsizer.AddSpacer(5) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(boxSvr, wx.ID_ANY, "HTTP Port:", size=(SVRLABELW, -1))) self.teHPort = wx.TextCtrl(boxSvr, wx.ID_ANY, self.httpPort, size=(125, -1)) self.Bind(wx.EVT_TEXT, self.onTeHPortChange, self.teHPort) self.teHPort.Bind(wx.EVT_KILL_FOCUS, self.onTeHPortLoseFocus) self.teHPort.Bind(wx.EVT_SET_FOCUS, self.onTeHPortSetFocus) hsizer.Add(self.teHPort) hsizer.AddSpacer(10) bsizer.Add(hsizer) bsizer.AddSpacer(5) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(boxSvr, wx.ID_ANY, "Socket Port:", size=(SVRLABELW, -1))) self.teSPort = wx.TextCtrl(boxSvr, wx.ID_ANY, self.socketPort, size=(125, -1)) hsizer.Add(self.teSPort) hsizer.AddSpacer(10) self.bSubscribe = wx.Button(boxSvr, wx.ID_ANY, "Subscribe") self.bSubscribe.SetToolTip("Subscribe to receive asynchronous reports from the server") self.Bind(wx.EVT_BUTTON, self.onSubscribe, self.bSubscribe) hsizer.Add(self.bSubscribe) hsizer.AddSpacer(10) bsizer.Add(hsizer) bsizer.AddSpacer(botBorder) boxSvr.SetSizer(bsizer) sz.Add(boxSvr, 0, wx.EXPAND|wx.ALL, 5) sz.AddSpacer(10) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(self, wx.ID_ANY, "Node Address:")) hsizer.AddSpacer(10) self.stAddr = wx.StaticText(self, wx.ID_ANY, " ") hsizer.Add(self.stAddr) hsizer.AddSpacer(20) self.bGetAddr = wx.Button(self, wx.ID_ANY, "...", size=(30, -1)) self.bGetAddr.SetToolTip("Select node address") self.Bind(wx.EVT_BUTTON, self.onGetNodeAddr, self.bGetAddr) hsizer.Add(self.bGetAddr) hsizer.AddSpacer(10) self.bRefresh = wx.Button(self, wx.ID_ANY, "Refresh") self.bRefresh.SetToolTip("Refresh node information by querying the actual node") self.Bind(wx.EVT_BUTTON, self.onBRefresh, self.bRefresh) hsizer.Add(self.bRefresh) sz.Add(hsizer) sz.AddSpacer(10) boxCfg = wx.StaticBox(self, wx.ID_ANY, " Node Config ") topBorder, botBorder = boxCfg.GetBordersForSizer() if os.name != 'nt': botBorder += 30 bsizer = wx.BoxSizer(wx.VERTICAL) bsizer.AddSpacer(topBorder) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(boxCfg, wx.ID_ANY, "Inputs:", size=(CFGLABELW, -1))) self.stInputs = wx.StaticText(boxCfg, wx.ID_ANY, "") hsizer.Add(self.stInputs) hsizer.AddSpacer(10) bsizer.Add(hsizer) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(boxCfg, wx.ID_ANY, "Outputs:", size=(CFGLABELW, -1))) self.stOutputs = wx.StaticText(boxCfg, wx.ID_ANY, "") hsizer.Add(self.stOutputs) hsizer.AddSpacer(10) bsizer.Add(hsizer) hsizer = wx.BoxSizer(wx.HORIZONTAL) hsizer.AddSpacer(10) hsizer.Add(wx.StaticText(boxCfg, wx.ID_ANY, "Servos:", size=(CFGLABELW, -1))) self.stServos = wx.StaticText(boxCfg, wx.ID_ANY, "") hsizer.Add(self.stServos) hsizer.AddSpacer(10) bsizer.Add(hsizer) bsizer.AddSpacer(botBorder) self.setConfigValues(1, 1, 1) boxCfg.SetSizer(bsizer) sz.Add(boxCfg, 0, wx.EXPAND|wx.ALL, 5) sz.AddSpacer(20) mainsz = wx.BoxSizer(wx.HORIZONTAL) mainsz.AddSpacer(20) mainsz.Add(sz) mainsz.AddSpacer(20) wsz = wx.BoxSizer(wx.VERTICAL) wsz.Add(mainsz) self.SetSizer(wsz) self.Layout() self.Fit() self.Show() self.enableMenuItems(False) self.server.setServerAddress(self.teIpAddr.GetValue(), self.teHPort.GetValue()) self.serverValueChanged = False self.hPortValueChanged = False self.timer.Start(250) self.Bind(wx.EVT_TIMER, self.onTimer) self.Bind(EVT_DELIVERY, self.onDeliveryEvent) self.Bind(EVT_DISCONNECT, self.onDisconnectEvent) self.sz = self.GetSize() print("size = ", self.sz) def onMenuInputs(self, _): if self.currentNodeAddr is None: self.setStatusText("Retrieve configuration first") else: self.openInputsDlg() def openInputsDlg(self): if len(self.inputsMap) == 0: self.setStatusText("No inputs information available") return pos = None if self.dlgInputs is not None: try: pos = self.dlgInputs.GetScreenPosition() self.dlgInputs.Destroy() except: pos = None self.dlgInputs = InputsDlg(self, self.inputsMap, self.inputs, self.currentNodeAddr) if pos is not None: self.dlgInputs.SetPosition(pos) else: ppos = self.GetScreenPosition() self.dlgInputs.SetPosition((ppos[0], ppos[1]+self.sz[1])) self.dlgInputs.Show() self.szInputs = self.dlgInputs.GetSize() def dlgInputsExit(self): self.dlgInputs = None def onMenuOutputs(self, _): if self.currentNodeAddr is None: self.setStatusText("Retrieve configuration first") else: self.openOutputsDlg() def openOutputsDlg(self): if len(self.outputsMap) == 0: self.setStatusText("No outputs information available") return pos = None if self.dlgOutputs is not None: try: pos = self.dlgOutputs.GetScreenPosition() self.dlgOutputs.Destroy() except: pos = None self.dlgOutputs = OutputsDlg(self, self.outputsMap, self.outputs, self.currentNodeAddr) if pos is not None: self.dlgOutputs.SetPosition(pos) else: ppos = self.GetScreenPosition() self.dlgOutputs.SetPosition((ppos[0], ppos[1]+self.sz[1]+self.szInputs[1])) self.dlgOutputs.Show() self.szOutputs = self.GetSize() def dlgOutputsExit(self): self.dlgOutputs = None def onMenuServos(self, _): if self.currentNodeAddr is None: self.setStatusText("Retrieve configuration first") else: self.openServosDlg() def openServosDlg(self): if len(self.servosMap) == 0: self.setStatusText("No outputs information available") return pos = None if self.dlgServos is not None: try: pos = self.dlgServos.GetScreenPosition() self.dlgServos.Destroy() except: pos = None self.dlgServos = ServosDlg(self, self.servosMap, self.servos, self.currentNodeAddr) if pos is not None: self.dlgServos.SetPosition(pos) else: ppos = self.GetScreenPosition() self.dlgServos.SetPosition((ppos[0]+self.sz[0], ppos[1])) self.dlgServos.Show() def dlgServosExit(self): self.dlgServos = None def onTeIpAddrSetFocus(self, evt): self.serverValueChanged = False evt.Skip() def onTeIpAddrChange(self, _): self.serverValueChanged = True def onTeIpAddrLoseFocus(self, evt): if self.serverValueChanged: self.serverValueChanged = False self.server.setServerAddress(self.teIpAddr.GetValue(), self.teHPort.GetValue()) evt.Skip() def onTeHPortSetFocus(self, evt): self.hPortValueChanged = False evt.Skip() def onTeHPortChange(self, _): self.hPortValueChanged = True def onTeHPortLoseFocus(self, evt): if self.hPortValueChanged: self.hPortValueChanged = False self.server.setServerAddress(self.teIpAddr.GetValue(), self.teHPort.GetValue()) evt.Skip() def throwTurnout(self, tx, throw): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr if throw == "N": try: sc, data = self.server.setTurnoutNormal(addr, tx) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False elif throw == "R": try: sc, data = self.server.setTurnoutReverse(addr, tx) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False else: # throw == "T" try: sc, data = self.server.setTurnoutToggle(addr, tx) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: try: if throw == "N": self.servosMap[tx][3] = self.servosMap[tx][0] elif throw == "R": self.servosMap[tx][3] = self.servosMap[tx][1] else: if self.servosMap[tx][3] == self.servosMap[tx][0]: self.servosMap[tx][3] = self.servosMap[tx][1] if self.servosMap[tx][3] == self.servosMap[tx][1]: self.servosMap[tx][3] = self.servosMap[tx][0] else: # toggle would have done nothing here pass self.setStatusText("Success") return True except: self.setStatusText("Unable to process return data: '%s'" % data) return False else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def setServoAngle(self, sx, ang): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr try: sc, data = self.server.setServoAngle(addr, sx, ang) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: try: self.servosMap[sx][3] = ang self.setStatusText("Success") return True except: self.setStatusText("Unable to process return data: '%s'" % data) return False else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def setTurnoutLimits(self, tx, norm, rev, ini): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr try: sc, data = self.server.setlimits(addr, tx, norm, rev, ini) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: try: self.servosMap[tx][0] = norm self.servosMap[tx][1] = rev self.servosMap[tx][2] = ini self.setStatusText("Success") return True except: self.setStatusText("Unable to process return data: '%s'" % data) return False else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def swapTurnout(self, tx): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr sv = self.servosMap[tx] norm = sv[0] rev = sv[1] try: sc, data = self.server.setlimits(addr, tx, rev, norm, sv[2]) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: try: self.servosMap[tx][0] = rev self.servosMap[tx][1] = norm self.setStatusText("Success") return True except: self.setStatusText("Unable to process return data: '%s'" % data) return False else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def nodeStore(self): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr try: sc, data = self.server.nodeStore(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: self.setStatusText("Success") return True else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def getServosMap(self): return self.servosMap def setOutput(self, bn, newState): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr if newState: try: sc, data = self.server.setOutputOn(addr, bn) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False else: try: sc, data = self.server.setOutputOff(addr, bn) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: try: self.outputsMap[bn] = newState self.setStatusText("Success") return True except: self.setStatusText("Unable to process return data: '%s'" % data) return False else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def pulseOutput(self, bn, pl): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr try: sc, data = self.server.pulseOutput(addr, bn, pl) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: try: self.setStatusText("Success") return True except: self.setStatusText("Unable to process return data: '%s'" % data) return False else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def setConfigValues(self, i, o, s): self.inputs = i self.stInputs.SetLabel("%d" % i) self.outputs = o self.stOutputs.SetLabel("%d" % o) self.servos = s self.stServos.SetLabel("%d" % s) def onSubscribe(self, _): if self.subscribed: self.listener.kill() self.listener.join() self.listener = None self.subscribed = False self.bSubscribe.SetLabel("Subscribe") else: ip = self.teIpAddr.GetValue() pt = self.teSPort.GetValue() self.listener = Listener(self, ip, pt) self.listener.start() self.subscribed = True self.bSubscribe.SetLabel("Unsubscribe") def raiseDeliveryEvent(self, data): try: jdata = json.loads(data) except json.decoder.JSONDecodeError: print("Unable to parse (%s)" % data) return evt = DeliveryEvent(data=jdata) wx.PostEvent(self, evt) def raiseDisconnectEvent(self): evt = DisconnectEvent() wx.PostEvent(self, evt) def onDisconnectEvent(self, _): self.listener = None self.subscribed = False self.bSubscribe.SetLabel("Subscribe") self.setStatusText("Server socket closed") def setStatusText(self, text): if self.clearTimer == 0: self.clearTimer = 10 self.SetStatusText(text) else: self.qStatus.put(text) def onGetNodeAddr(self, _): nr = self.getNodeRpt() if nr is None: dlg = wx.MessageDialog(self, 'Unable to retrieve node report from server', 'Error', wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy() return dlg = NodeDlg(self, self.currentNodeAddr, nr) rc = dlg.ShowModal() if rc in [ wx.ID_OK, ID_INIT ]: n = dlg.getValues() dlg.Destroy() if rc not in [ wx.ID_OK, ID_INIT ]: return if n is None: return if rc == wx.ID_OK: self.currentNodeAddr = n self.stAddr.SetLabel("%d" % self.currentNodeAddr) self.loadConfig() else: self.doInit(n) def onBRefresh(self, _): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr try: sc, data = self.server.nodeRefresh(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return if sc >= 400: self.setStatusText("RC <%d> %s" % (sc, data)) return False self.setStatusText("Refresh Success") self.loadConfig() def loadConfig(self): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() addr = self.currentNodeAddr if addr is None: self.setStatusText("Select node address first") self.enableMenuItems(False) self.enableMenuItems(True) try: sc, data = self.server.getConfig(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) if sc < 400: try: d = json.loads(data) self.setConfigValues(d['inputs'], d['outputs'], d['servos']) self.setStatusText("Retrieve Node Config Success") except: self.setStatusText("Unable to process return data: '%s'" % data) else: self.setStatusText("RC <%d> %s" % (sc, data)) try: sc, data = self.server.getInputs(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return if sc < 400: try: d = json.loads(data) self.inputsMap = d["inputs"]["values"] self.openInputsDlg() self.setStatusText("Retrieve Inputs Success") except: self.inputsMap = [] self.setStatusText("Unable to process return data: '%s'" % data) else: self.setStatusText("RC <%d> %s" % (sc, data)) try: sc, data = self.server.getOutputs(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return if sc < 400: try: d = json.loads(data) self.outputsMap = d["outputs"]["values"] self.openOutputsDlg() self.setStatusText("Retrieve Outputs Success") except: self.outputsMap = [] self.setStatusText("Unable to process return data: '%s'" % data) else: self.setStatusText("RC <%d> %s" % (sc, data)) try: sc, data = self.server.getTurnouts(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return if sc < 400: try: d = json.loads(data) self.servosMap = d["servos"]["values"] self.openServosDlg() self.setStatusText("Retrieve Turnouts Success") except: self.servosMap = [] self.setStatusText("Unable to process return data: '%s'" % data) else: self.setStatusText("RC <%d> %s" % (sc, data)) def enableMenuItems(self, flag): self.menuNode.Enable(MENU_NODE_CONFIG, flag) self.menuWindow.Enable(MENU_WINDOW_INPUTS, flag) self.menuWindow.Enable(MENU_WINDOW_OUTPUTS, flag) self.menuWindow.Enable(MENU_WINDOW_SERVOS, flag) self.bRefresh.Enable(flag) def onDeliveryEvent(self, evt): if "inputs" in evt.data: imsg = evt.data["inputs"] iaddr = imsg["address"] if iaddr != self.currentNodeAddr: return if "delta" in imsg and imsg["delta"]: vals = imsg["values"] if len(vals) > 0: for inp, val in vals: self.inputsMap[inp] = val if self.dlgInputs is not None: self.dlgInputs.update(self.inputsMap) else: vals = imsg["values"] if len(vals) == len(self.inputsMap): self.inputsMap = [x for x in vals] if self.dlgInputs is not None: self.dlgInputs.update(self.inputsMap) else: self.setStatusText("Mismatch number of inputs") elif "outputs" in evt.data: omsg = evt.data["outputs"] iaddr = omsg["address"] if iaddr != self.currentNodeAddr: return if "delta" in omsg and omsg["delta"]: vals = omsg["values"] if len(vals) > 0: for outp, val in vals: self.outputsMap[outp] = val if self.dlgOutputs is not None: self.dlgOutputs.update(self.outputsMap) else: vals = omsg["values"] if len(vals) == len(self.outputsMap): self.outputsMap = [x for x in vals] if self.dlgOutputs is not None: self.dlgOutputs.update(self.outputsMap) else: self.setStatusText("Mismatch number of outputs") elif "servos" in evt.data: smsg = evt.data["servos"] iaddr = smsg["address"] if iaddr != self.currentNodeAddr: return if "limits" in smsg and smsg["limits"]: vals = smsg["values"] if len(vals) > 0: for outp, v0, v1, v2 in vals: self.servosMap[outp][0] = v0 self.servosMap[outp][1] = v1 self.servosMap[outp][2] = v2 if self.dlgServos is not None: self.dlgServos.update(self.servosMap) elif "delta" in smsg and smsg["delta"]: vals = smsg["values"] if len(vals) > 0: for outp, val in vals: self.servosMap[outp][3] = val if self.dlgServos is not None: self.dlgServos.update(self.servosMap) else: vals = smsg["values"] if len(vals) == len(self.servosMap): self.servosMap = [x for x in vals] if self.dlgServos is not None: self.dlgServos.update(self.servosMap) else: self.setStatusText("Mismatch number of turnouts/servos") elif "pulse" in evt.data: pmsg = evt.data["pulse"] iaddr = pmsg["address"] if iaddr != self.currentNodeAddr: return idx = pmsg["index"] pl = pmsg["length"] self.outputsMap[idx] = False # only on for a brief period if self.dlgOutputs is not None: self.dlgOutputs.pulseOutput(idx, pl) elif "nodes" in evt.data: print(json.dumps(evt.data)) if self.currentNodeAddr is None: # nothing to do with this is we are not currently looking at a node return for nd in evt.data["nodes"]: if nd["address"] == self.currentNodeAddr and not nd["active"]: # we are looking at an inactive node - tear down the dialog boxes if self.dlgInputs is not None: self.dlgInputs.Destroy() self.dlgInputs = None if self.dlgOutputs is not None: self.dlgOutputs.Destroy() self.dlgOutputs = None if self.dlgServos is not None: self.dlgServos.Destroy() self.dlgServos = None self.currentNodeAddr = None self.stAddr.SetLabel(" ") break else: print("Unknown report type (%s)" % list(evt.data.keys())[0]) def onMessageEvent(self, evt): self.setStatusText(evt.message) def getNodeRpt(self): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() try: sc, data = self.server.getNodeRpt() except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return None if sc < 400: try: self.setStatusText("Success") d = json.loads(data) return d except: self.setStatusText("Unable to process return data: '%s'" % data) return None else: self.setStatusText("RC <%d> %s" % (sc, data)) return None def onMenuNodes(self, _): d = self.getNodeRpt() if d is None: return False try: nl = d["nodes"] except: return False rpt = "" for nd in nl: active = "Active" if nd["active"] else "Inactive" rpt += "%20.20s: A:%-2d I:%-2d O:%-2d S:%-2d %s\n" % ( nd["name"], nd["address"], nd["inputs"], nd["outputs"], nd["servos"], active) dlg = wx.MessageDialog(self, rpt, "Nodes Report", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy() return True def onMenuConfig(self, _): addr = self.currentNodeAddr dlg = wx.MessageDialog(self, "Proceeding with this will result in the node restarting\nand will require a reconfiguration and restart of the server process", "Reconfiguration of Node %d" % addr, wx.OK | wx.CANCEL | wx.ICON_WARNING) rc = dlg.ShowModal() dlg.Destroy() if rc == wx.ID_OK: dlg = NodeConfigDlg(self, addr, self.inputs, self.outputs, self.servos) rc = dlg.ShowModal() if rc == wx.ID_OK: a, i, o, s = dlg.getValues() dlg.Destroy() if rc != wx.ID_OK: return ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() try: sc, data = self.server.setConfig(addr, a, i, o, s) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: self.setStatusText("Success") return True else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def onMenuInit(self, _): if self.currentNodeAddr is None: return self.doInit(self.currentNodeAddr) def doInit(self, addr): ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() try: sc, data = self.server.nodeInit(addr) except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: self.setStatusText("Success") return True else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def onMenuShutdown(self, _): dlg = wx.MessageDialog(self, "This will shutdown the server process.\nAre you sure you want to proceed?", "Continue with server shutdown", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_WARNING) rc = dlg.ShowModal() dlg.Destroy() if rc == wx.ID_YES: ip = self.teIpAddr.GetValue() pt = self.teHPort.GetValue() try: sc, data = self.server.quit() except: self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt)) return False if sc < 400: self.setStatusText("Success") return True else: self.setStatusText("RC <%d> %s" % (sc, data)) return False def onTimer(self, _): # do this every quarter second if self.dlgOutputs is not None: self.dlgOutputs.clearPulses() self.ticks += 1 if self.ticks < 4: return self.ticks = 0 # do this once a second if self.clearTimer is None: return if self.clearTimer == 0: if self.qStatus.empty(): self.SetStatusText("") self.clearTimer = None else: t = self.qStatus.get() self.SetStatusText(t) elif self.clearTimer >0: self.clearTimer -= 1 def onClose(self, _): if self.listener is not None: self.setStatusText("destroying listener thread") self.listener.kill() self.listener.join() self.Destroy()
class TIM(QWidget, Ui_Form_For_Main): grouplist = [] userslist = [] tmpuseritem = [] groupInfo = {} chatWindow = {} groupChatWindow = {} my_groups = [] #Save my group glist = [] #Save all information for each group def __init__(self, client): super().__init__() self.m_drag = False self.m_DragPosition = QPoint() self.cache = Cache(self) self.setupUi(self) self.client = client self.Ui_init() self.menuflag = 1 self.temp = {} self.groupTemp = [] #New group id self.addTemp = [] #Join the group id self.setStyleSheet(open('styles/style5.qss').read()) self.setWindowIcon(QIcon('img/bubbles-alt-icon.png')) palette = QPalette() palette.setBrush(self.backgroundRole(), QtGui.QBrush(QtGui.QPixmap('img/background/bg1.jpg'))) self.setPalette(palette) self.setWindowFlag(Qt.FramelessWindowHint) self.tray = MySystemTray(self) self.listener = Listener(self) self.listener.newSysMsgSignal.connect(self.cache.newSysMsg) self.listener.newFriendMsgSignal.connect(self.newFriendMsg) self.listener.newGroupMsgSignal.connect(self.newGroupMsg) self.listener.successAddFriendSignal.connect(self.successAddFriend) self.listener.friendOfflineSignal.connect(self.dealFriendOffline) self.listener.friendsOnlineSignal.connect(self.dealFriendOnline) self.listener.noExistSignal.connect(self.noExist) self.listener.offlineSignal.connect(self.offline) self.listener.beDelSignal.connect(self.dealBeDel) self.listener.createGroupOkSignal.connect(self.dealCreateGroupOk) self.listener.addGroupOkSignal.connect(self.dealAddGroupOk) self.listener.start() def Ui_init(self): image = QImage() image.loadFromData(self.client.head) self.lblHead.setScaledContents(True) self.lblHead.setPixmap(QPixmap.fromImage(image)) self.lblName.setText(self.client.name) self.lblId.setText(str(self.client.id)) self.bt_search.setIcon(QIcon('img/search.png')) self.minBt.setIcon(QIcon('img/min.png')) self.closeBt.setIcon(QIcon('img/wclose.png')) self.setupBt.setIcon(QIcon('img/setting.png')) self.bt_adduser.setIcon(QIcon('img/add.png')) self.cacheBt.setIcon(QIcon('img/msg.png')) self.groupBt.setIcon(QIcon('img/群组.png')) self.faceBt.setIcon(QIcon("img/face.png")) self.lblIcon.setPixmap(QPixmap('img/chat.png')) self.tabWidget.setStyleSheet("background-color:rgba(255,255,255,0.7)") self.treeWidget.setStyleSheet("background-color:rgba(255,255,255,0)") self.groups.setStyleSheet("background-color:rgba(255,255,255,0)") self.groupList.setStyleSheet("background-color:rgba(255,255,255,0)") self.friendList.setStyleSheet("background-color:rgba(255,255,255,0)") self.m_model = QStandardItemModel(0, 1, self) m_completer = QCompleter(self.m_model, self) self.lineEdit.setCompleter(m_completer) m_completer.activated[str].connect(self.onUsernameChoosed) self.setupBt.clicked.connect(self.setUp) self.closeBt.clicked.connect(self.close) self.minBt.clicked.connect(self.showMinimized) self.cacheBt.clicked.connect(self.msgCache) self.groupBt.clicked.connect(self.addGroup) self.faceBt.clicked.connect(self.changeFace) self.treeWidget.currentItemChanged.connect(self.restatistic) self.treeWidget.itemClicked.connect(self.isclick) self.bt_adduser.clicked.connect(self.on_bt_adduser_clicked) self.bt_search.clicked.connect(self.on_bt_search_clicked) self.lineEdit.textChanged[str].connect(self.on_lineEdit_textChanged) self.treeWidget.itemDoubleClicked.connect( self.cache.responseFriendItemClicked) self.groups.itemDoubleClicked.connect( self.cache.responseGroupItemClicked) self.treeWidget.setIndentation(0) self.treeWidget.setColumnCount(1) self.treeWidget.setColumnWidth(0, 50) self.treeWidget.setHeaderLabels(['Friend']) self.treeWidget.header().hide() self.treeWidget.setIconSize(QSize(70, 70)) self.treeWidget.setFocusPolicy(Qt.NoFocus) self.treeWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.treeWidget.setSelectionMode(QAbstractItemView.ExtendedSelection) self.creategroup() self.initGroup() def closeWindow(self): if self.cache.isVisible() == True: self.cache.close() for i in self.chatWindow.keys(): self.chatWindow[i].close() for i in self.groupChatWindow.keys(): self.groupChatWindow[i].close() def dealCreateGroupOk(self, gid, data): gname = data.decode('utf-8') for info in self.groupTemp: if gname == info[0]: ghead = info[1] newG = Group(gname, gid, ghead, [self.client.id]) item = QListWidgetItem(self.groups) item.setSizeHint(QSize(self.groups.width(), 61)) self.groups.setItemWidget(item, newG) self.groupTemp.remove(info) self.my_groups.append(gid) groupdic = { 'group': item, 'groupid': gid, 'groupname': gname, 'grouphead': ghead, 'groupmember': [self.client.id] } self.glist.append(groupdic) break def dealAddGroupOk(self, gid, data): if gid in self.addTemp: data = data.split('\n'.encode('utf-8'), 2) gname = data[0].decode('utf-8') gmembers = json.loads(data[1].decode('utf-8')) ghead = data[2] item = QListWidgetItem(self.groups) item.setSizeHint(QSize(self.groups.width(), 61)) newG = Group(gname, gid, ghead, gmembers) self.groups.setItemWidget(item, newG) self.addTemp.remove(gid) self.my_groups.append(gid) groupdic = { 'group': item, 'groupid': gid, 'groupname': gname, 'grouphead': ghead, 'groupmember': gmembers } self.glist.append(groupdic) def newGroupMsg(self, groupid, type, data): if groupid in self.groupChatWindow.keys( ) and self.groupChatWindow[groupid].isVisible(): if (type == Type.GROUP_TEXT): self.groupChatWindow[groupid].recviveMsg(data.decode('utf-8')) else: self.groupChatWindow[groupid].recvivePic(data) else: self.cache.newGroupMsg(groupid, type, data) def newFriendMsg(self, id, type, data): if type == Type.FILE: for user in self.userslist: if id == user['userid']: name = user['username'] break filename, file = data.split('\n'.encode('utf-8'), 1) filename = filename.decode('utf-8') response = QMessageBox.question( None, "Message", "Friend %s (%s) Send file %s,Would you like to accept it?" % (name, id, filename), QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes) if response == QMessageBox.Yes: filepath = QFileDialog.getSaveFileName(None, 'Save as', './' + filename, '') if filepath[0]: with open(filepath[0], 'wb') as f: f.write(file) self.client.dealAcceptFile(id, filename) else: self.client.dealRefuseFile(id, filename) else: self.client.dealRefuseFile(id, filename) elif type == Type.FILE_AC: for user in self.userslist: if id == user['userid']: name = user['username'] break QMessageBox.information( None, 'Message', 'Friend %s (%s) Received file %s' % (name, id, data.decode('utf-8'))) elif type == Type.FILE_RF: for user in self.userslist: if id == user['userid']: name = user['username'] break QMessageBox.information( None, 'Message', 'Friend %s (%s) 拒绝接收文件 %s' % (name, id, data.decode('utf-8'))) else: if id in self.chatWindow.keys() and self.chatWindow[id].isVisible( ): if type == Type.TEXT: self.chatWindow[id].recviveMsg(data.decode('utf-8')) elif type == Type.PIC: self.chatWindow[id].recvivePic(data) else: self.cache.newFriendMsg(id, type, data) def sendGroupMsg(self, id, text): self.client.dealSendGroupMsg(id, text) def sendGroupPic(self, id, pic): self.client.dealSendGroupPic(id, pic) def sendMsg(self, id, text): index = self.searchuser(id) if self.userslist[index]['ishide'] == 1: self.chatWindow[id].notOnline() else: self.client.dealSendMsg(id, text) def sendPic(self, id, bytes): index = self.searchuser(id) if self.userslist[index]['ishide'] == 1: self.chatWindow[id].notOnline() else: self.client.dealSendPic(id, bytes) def sendFile(self, id, filename): index = self.searchuser(id) if self.userslist[index]['ishide'] == 1: self.chatWindow[id].notOnline() else: self.client.dealSendFile(id, filename) def initGroup(self): #格式{群id:[群成员id]}?? #grouplist格式为:列表[群id] self.my_groups = groupInfo = self.client.dealGetGroupList() for groupid in groupInfo: groupname, grouphead = self.client.dealGetGroupNameAndHead(groupid) groupmember = self.client.dealGetGroupMember(groupid) group = QListWidgetItem(self.groups) group.setSizeHint(QSize(self.groups.width(), 55)) groupdic = { 'group': group, 'groupid': groupid, 'groupname': groupname, 'grouphead': grouphead, 'groupmember': groupmember } g = Group(groupname, str(groupid), grouphead, groupmember) self.glist.append(groupdic) self.groups.setItemWidget(group, g) def addGroup(self): addG = AddGroup(self.my_groups, self.groupTemp, self.addTemp) response = addG.exec_() if response == 1: gname, ghead = self.groupTemp[-1] self.client.dealCreateGroup(gname, ghead) elif response == 2: gid = self.addTemp[-1] self.client.dealJoinGroup(gid) def changeFace(self): file = QFileDialog.getOpenFileName(self, 'Select background', '.', ("Images (*.png *.jpg *.bmp)")) if file[0]: palette = QPalette() palette.setBrush(self.backgroundRole(), QtGui.QBrush(QtGui.QPixmap(file[0]))) self.setPalette(palette) def noExist(self, id): QMessageBox.information(self, 'Prompt', 'There is no account number %s User!' % (id)) for k, v in self.temp.items(): if k == id: self.temp.pop(k) break def dealBeDel(self, id): dindex = self.searchuser(id) ishide = self.userslist[dindex]['ishide'] delitem = self.userslist[dindex]['user'] pindex = delitem.parent().indexOfChild(delitem) name = self.userslist[dindex]['username'] del self.userslist[dindex] fathergroup = delitem.parent() findex = self.searchgroup(fathergroup) parentName = self.grouplist[findex]['groupname'] if ishide == 1: self.grouplist[findex]['childishide'] -= 1 self.grouplist[findex]['childcount'] -= 1 else: self.grouplist[findex]['childcount'] -= 1 delitem.parent().takeChild(pindex) for user in self.groupInfo[parentName]: if user['userid'] == id: self.groupInfo[parentName].remove(user) break def offline(self, id): QMessageBox.information( self, 'Prompt', 'Account number is %s Users are not online!' % (id)) for k, v in self.temp.items(): if k == id: self.temp.pop(k) break def dealRefuseAdd(self, id): QMessageBox.information( self, 'Prompt', 'Account number is %s User rejects your friend request!' % id) for k, v in self.temp.items(): if k == id: self.temp.pop(k) break def dealFriendOnline(self, id): useritemindex = self.searchuser(id) if useritemindex is not None: self.userslist[useritemindex]['ishide'] = 0 useritem = self.userslist[useritemindex]['user'] parent = useritem.parent() findex = self.searchgroup(parent) widget = self.treeWidget.itemWidget(useritem, 0) widget.lblonlinestate.setPixmap(QPixmap("img/bullet_green.png")) self.grouplist[findex]['childishide'] -= 1 fathergroupname = self.grouplist[findex]['groupname'] fathergroupname += ' ' + str( self.grouplist[findex]['childcount'] - self.grouplist[findex]['childhide']) + '/' + str( self.grouplist[findex]['childcount']) parent.setText(0, fathergroupname) def dealBeAdded(self, widget): reply = QMessageBox.question( self, 'Friend add Prompt', '%s(%s)Add you as a friend' % (widget.name, widget.id), QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes) if reply == QMessageBox.No: self.client.dealRefuseAdded(widget.id) else: info = ['my good friend', widget.name] dialog = Add_Dialog(info) for g in self.grouplist: dialog.comboBox.addItem(g['groupname']) dialog.exec_() self.client.dealAcceptAdded(widget.id) newitem = QTreeWidgetItem() newitem.setSizeHint(0, QSize(self.treeWidget.width(), 55)) head = widget.data.split('\n'.encode('utf-8'), 1)[1] buddy = Buddy(info[1], str(widget.id), head, 0) userdic = { 'user': newitem, 'username': info[1], 'userid': widget.id, 'head': head, 'ishide': 0 } cindex = self.searchgroup(info[0]) group = self.grouplist[cindex]['group'] self.grouplist[cindex]['childcount'] += 1 self.userslist.append(userdic) group.addChild(newitem) self.treeWidget.setItemWidget(newitem, 0, buddy) self.treeWidget.setCurrentItem(newitem) user = {'username': info[1], 'userid': widget.id, 'ishide': 0} self.groupInfo[info[0]].append(user) def dealFriendOffline(self, id): useritemindex = self.searchuser(id) if useritemindex is not None: self.userslist[useritemindex]['ishide'] = 1 useritem = self.userslist[useritemindex]['user'] parent = useritem.parent() findex = self.searchgroup(parent) widget = self.treeWidget.itemWidget(useritem, 0) widget.lblonlinestate.setPixmap(QPixmap('img/bullet-grey.png')) self.grouplist[findex]['childishide'] += 1 fathergroupname = self.grouplist[findex]['groupname'] fathergroupname += ' ' + str( self.grouplist[findex]['childcount'] - self.grouplist[findex]['childhide']) + '/' + str( self.grouplist[findex]['childcount']) parent.setText(0, fathergroupname) self.treeWidget.setCurrentItem(parent) def on_bt_adduser_clicked(self): des_id = [-1] adduser = Dialog_additem(des_id, self.temp, self.userslist, self.client.id) for g in self.grouplist: adduser.comboBox.addItem(g['groupname']) if adduser.exec_() == 1: data = self.client.name.encode('utf-8') + "\n".encode( 'utf-8') + self.client.head protocol = Protocol(len(data), self.client.id, des_id[0], Type.ADD_FRIEND) header = protocol.make_packet_header() self.client.sock.sendall(header + data) def successAddFriend(self, friend, head): newitem = QTreeWidgetItem() newitem.setSizeHint(0, QSize(self.treeWidget.width(), 55)) friendName = friend['name'] friendId = friend['id'] ishide = friend['ishide'] buddy = Buddy(friendName, str(friendId), head, ishide) userdic = { 'user': newitem, 'username': friendName, 'userid': friendId, 'head': head, 'ishide': ishide } for k, v in self.temp.items(): if k == friend['id']: comboxinfo = self.temp.pop(k) break cindex = self.searchgroup(comboxinfo) group = self.grouplist[cindex]['group'] groupname = self.grouplist[cindex]['groupname'] self.grouplist[cindex]['childcount'] += 1 self.userslist.append(userdic) group.addChild(newitem) self.treeWidget.setItemWidget(newitem, 0, buddy) self.treeWidget.setCurrentItem(newitem) user = {'username': friendName, 'userid': friendId, 'ishide': 0} self.groupInfo[groupname].append(user) def creategroup(self): self.groupInfo = groupInfo = self.client.dealInitGroupInfo() for groupname in groupInfo.keys(): hidernum = 0 group = QTreeWidgetItem(self.treeWidget) groupdic = { 'group': group, 'groupname': groupname, 'childcount': 0, 'childhide': 0 } icon = self.searchIcon(groupname) group.setIcon(0, icon) for friend in groupInfo[groupname]: child = QTreeWidgetItem() child.setSizeHint(0, QSize(self.treeWidget.width(), 55)) friendName = friend['username'] friendId = friend['userid'] ishide = friend['ishide'] head = self.client.dealGetHead(friendId) buddy = Buddy(friendName, str(friendId), head, ishide) userdic = { 'user': child, 'username': friendName, 'userid': friendId, 'head': head, 'ishide': ishide } self.userslist.append(userdic) if friend['ishide'] == 1: hidernum += 1 userdic['ishide'] = 1 group.addChild(child) self.treeWidget.setItemWidget(child, 0, buddy) childnum = group.childCount() lastchildnum = childnum - hidernum groupdic['childcount'] = childnum groupdic['childishide'] = hidernum groupname += ' ' + str(lastchildnum) + '/' + str(childnum) group.setText(0, groupname) group.setExpanded(True) self.grouplist.append(groupdic) def createusers(self, num): randname = "黑子" randicon = QIcon(str(num) + '.jpg') font = QFont() font.setPointSize(16) isvip = random.randint(0, 5) ishider = random.randint(0, 5) if ishider == 1: randicon = QIcon(str(num) + 'h.jpg') return randname, randicon, font, isvip, ishider def searchIcon(self, gpname2): if gpname2.find('Friend') >= 0: return QIcon('img/buddy.ico') elif gpname2.find('同事'): return QIcon('img/partner.ico') elif gpname2.find('黑名单'): return QIcon('img/blacklist.ico') else: return QIcon('img/defalut.ico') def mousePressEvent(self, event): if event.button() == Qt.LeftButton: self.m_drag = True self.m_DragPosition = event.globalPos() - self.pos() event.accept() def mouseMoveEvent(self, QMouseEvent): if QMouseEvent.buttons() and Qt.LeftButton: self.move(QMouseEvent.globalPos() - self.m_DragPosition) QMouseEvent.accept() def mouseReleaseEvent(self, QMouseEvent): self.m_drag = False def onUsernameChoosed(self, name): self.lineEdit.setText(name) def on_lineEdit_textChanged(self, text): namelist = [] for itm in self.userslist: username = itm['username'] if username.find(text) >= 0: namelist.append(itm['username']) self.m_model.removeRows(0, self.m_model.rowCount()) for i in range(0, len(namelist)): self.m_model.insertRow(0) self.m_model.setData(self.m_model.index(0, 0), namelist[i]) def on_bt_search_clicked(self): username = self.lineEdit.text() if len(username) > 0: useritemindex = self.searchuser(username) if useritemindex is not None: useritem = self.userslist[useritemindex]['user'] self.treeWidget.setCurrentItem(useritem) else: QMessageBox.information(self, 'Message', 'This friend does not exist!') def closeEvent(self, event): reply = QMessageBox.question( self, 'Prompt', 'Are you sure you want to quit the program?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.No: event.ignore() else: self.hide() self.client.dealUpdate(self.groupInfo) self.closeWindow() time.sleep(3) self.client.dealQuit() time.sleep(1) self.listener.terminate() event.accept() def msgCache(self): self.cache.show() def setUp(self): setup = SetInfoDialog(self.client) if setup.exec_() > 0: self.lblName.setText( self.client.name ) ################################################################################需要设置头像!!!!!!! image = QImage() image.loadFromData(self.client.head) self.lblHead.setPixmap(QPixmap.fromImage(image)) self.client.dealSetHead() self.client.dealSetName() def delGroup(self): hititem = self.groups.currentItem() group = self.groups.itemWidget(hititem) gid = int(group.id.text()) self.client.dealDeleteGroup(gid) row = self.groups.row(hititem) self.groups.takeItem(row) def contextMenuEvent(self, event): x = QCursor.pos().x() y = QCursor.pos().y() widget = QApplication.widgetAt(x, y) if type(widget) == Group: menu = QMenu(self) pDeleteAct = QAction('Delete group', self.groups) menu.addAction(pDeleteAct) pDeleteAct.triggered.connect(self.delGroup) menu.popup(self.mapToGlobal(event.pos())) elif type(widget) == QWidget: hititem = self.treeWidget.currentItem() pgroupmenu = QMenu(self) pAddgroupAct = QAction('Add group', self.treeWidget) pRenameAct = QAction('Rename', self.treeWidget) pDeleteAct = QAction('Delete group', self.treeWidget) pgroupmenu.addAction(pAddgroupAct) pgroupmenu.addAction(pRenameAct) pgroupmenu.addAction(pDeleteAct) pAddgroupAct.triggered.connect(self.addgroup) pRenameAct.triggered.connect(self.renamegroup) if self.treeWidget.itemAbove(hititem) is None: pDeleteAct.setEnabled(False) else: pDeleteAct.setEnabled(True) pDeleteAct.triggered.connect(self.deletegroup) pgroupmenu.popup(self.mapToGlobal(event.pos())) elif type(widget) == Buddy: hititem = self.treeWidget.currentItem() root = hititem.parent() if root.childCount() > 0: pItemmenu = QMenu(self) pDeleteItemAct = QAction('Delete contact', pItemmenu) pItemmenu.addAction(pDeleteItemAct) pDeleteItemAct.triggered.connect(self.delete) if len(self.grouplist) > 1: pSubMenu = QMenu('Transfer contacts to', pItemmenu) pItemmenu.addMenu(pSubMenu) for item_dic in self.grouplist: if item_dic['group'] is not root: pMoveAct = QAction(item_dic['groupname'], pItemmenu) pSubMenu.addAction(pMoveAct) pMoveAct.triggered.connect(self.moveItem) if len(self.getListitems(self.menuflag)) == 1: pRenameItemAct = QAction('Setting note', pItemmenu) pItemmenu.addAction(pRenameItemAct) pRenameItemAct.triggered.connect(self.renameItem) if self.menuflag > 0 and root.childCount() > 1: pBatchAct = QAction('Batch operation within a group', pItemmenu) pItemmenu.addAction(pBatchAct) pBatchAct.triggered.connect(self.Batchoperation) elif self.menuflag < 0: pCancelBatchAct = QAction('Cancel batch operation', pItemmenu) pItemmenu.addAction(pCancelBatchAct) pCancelBatchAct.triggered.connect( self.CancelBatchoperation) pItemmenu.popup(self.mapToGlobal(event.pos())) def moveItem(self): movelist = self.getListitems(self.menuflag) togroupname = self.sender().text() mindex = self.searchgroup(togroupname) togroup = self.grouplist[mindex]['group'] self.deleteItems(movelist, flag=0) self.add(togroup, movelist) self.tmpuseritem.clear() def delete(self): delitems = self.getListitems(self.menuflag) self.deleteItems(delitems) self.tmpuseritem.clear() def deleteItems(self, items, flag=1): for delitem in items: delitem.setData(0, Qt.CheckStateRole, QVariant()) pindex = delitem.parent().indexOfChild(delitem) dindex = self.searchuser(delitem) ishide = self.userslist[dindex]['ishide'] id = self.userslist[dindex]['userid'] if flag == 1: self.client.dealDelFriend(id) del self.userslist[dindex] fathergroup = delitem.parent() findex = self.searchgroup(fathergroup) parentName = self.grouplist[findex]['groupname'] for user in self.groupInfo[parentName]: if user['userid'] == id: self.groupInfo[parentName].remove(user) break fathergroup = delitem.parent() findex = self.searchgroup(fathergroup) if ishide == 1: self.grouplist[findex]['childishide'] -= 1 self.grouplist[findex]['childcount'] -= 1 else: self.grouplist[findex]['childcount'] -= 1 delitem.parent().takeChild(pindex) def add(self, group, items): gindex = self.searchgroup(group) gname = self.grouplist[gindex]['groupname'] for item in items: aindex = self.searchuser(item) ishide = self.userslist[aindex]['ishide'] userid = self.userslist[aindex]['userid'] username = self.userslist[aindex]['username'] head = self.userslist[aindex]['head'] if ishide == 1: self.grouplist[gindex]['childishide'] += 1 self.grouplist[gindex]['childcount'] += 1 else: self.grouplist[gindex]['childcount'] += 1 buddy = Buddy(username, str(userid), head, ishide) group.addChild(item) self.treeWidget.setItemWidget(item, 0, buddy) self.treeWidget.itemWidget(item, 0).show() self.treeWidget.setCurrentItem(item) user = {'username': username, 'userid': userid, 'ishide': 0} self.groupInfo[gname].append(user) def Batchoperation(self): self.menuflag *= -1 group = self.getListitems()[0].parent() childnum = group.childCount() for c in range(childnum): child = group.child(c) child.setCheckState(0, Qt.Unchecked) def CancelBatchoperation(self): self.menuflag *= -1 group = self.getListitems()[0].parent() childnum = group.childCount() for c in range(childnum): child = group.child(c) child.setData(0, Qt.CheckStateRole, QVariant()) def isclick(self, item): if item.checkState(0) == Qt.Checked: if self.tmpuseritem.count(item) == 0: self.tmpuseritem.append(item) else: if len(self.tmpuseritem) > 0: if self.tmpuseritem.count(item) != 0: i = self.tmpuseritem.index(item) del self.tmpuseritem[i] def renameItem(self): hituser = self.treeWidget.currentItem() widget = self.treeWidget.itemWidget(hituser, 0) uindex = self.searchuser(hituser) unewname, ok = QInputDialog.getText(self, 'Prompt Information', 'Please enter a note name') if ok: if len(unewname) == 0: QMessageBox.information(self, 'Prompt', 'Note name cannot be empty') else: widget.name.setText(unewname) self.userslist[uindex]['username'] = unewname id = self.userslist[uindex]['userid'] parent = hituser.parent() parentIndex = self.searchgroup(parent) parentName = self.grouplist[parentIndex]['groupname'] for user in self.groupInfo[parentName]: if user['userid'] == id: user['username'] = unewname def searchuser(self, hituser): if isinstance(hituser, str): if hituser.isdigit(): for i, u in enumerate(self.userslist): if str(u['userid']) == hituser: return i else: for i, u in enumerate(self.userslist): if u['username'] == hituser: return i elif isinstance(hituser, int): for i, u in enumerate(self.userslist): if u['userid'] == hituser: return i else: for i, u in enumerate(self.userslist): if hituser == u['user']: return i return None def getListitems(self, flag=1): if flag > 0: return self.treeWidget.selectedItems() else: return self.tmpuseritem def addgroup(self): gname, ok = QInputDialog.getText(self, 'Prompt Information', 'Please enter a group name') if ok: if len(gname) == 0: QMessageBox.information(self, 'Prompt', 'Group name cannot be empty') else: hidernum = 0 group = QTreeWidgetItem(self.treeWidget) groupdic = { 'group': group, 'groupname': gname, 'childcount': 0, 'childhide': 0 } #sself.groupInfo[gname] = '' icon = self.searchIcon(gname) group.setIcon(0, icon) childnum = group.childCount() lastchildnum = childnum - hidernum groupdic['childcount'] = childnum groupdic['childishide'] = hidernum self.groupInfo[gname] = [] gname += ' ' + str(lastchildnum) + '/' + str(childnum) group.setText(0, gname) self.grouplist.append(groupdic) def renamegroup(self): hitgroup = self.treeWidget.currentItem() gnewname, ok = QInputDialog.getText(self, 'Prompt', 'Please enter a new group name') if ok: if len(gnewname) == 0: QMessageBox.information(self, 'Prompt', 'Group name cannot be empty') else: hitgroup.setText(0, gnewname) newicon = self.searchIcon(hitgroup.text(0)) hitgroup.setIcon(0, newicon) gindex = self.searchgroup(hitgroup) oldname = self.grouplist[gindex]['groupname'] self.grouplist[gindex]['groupname'] = gnewname self.treeWidget.setCurrentItem(hitgroup.child(0)) self.groupInfo[gnewname] = self.groupInfo.pop(oldname) def deletegroup(self): hitgroup = self.treeWidget.currentItem() gindex = self.searchgroup(hitgroup) reply = QMessageBox.question( self, 'Warning', 'Are you sure you want to delete this group?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.Yes: self.treeWidget.takeTopLevelItem(gindex) groupname = self.grouplist[gindex]['groupname'] del self.grouplist[gindex] del self.groupInfo[groupname] def searchgroup(self, hitgroup): if isinstance(hitgroup, str): for i, g in enumerate(self.grouplist): if g['groupname'] == hitgroup: return i else: for i, g in enumerate(self.grouplist): if g['group'] == hitgroup: return i def restatistic(self, item, preitem): if item: fathergroup = item.parent() if fathergroup: self.restatistic_op(fathergroup) else: self.restatistic_op(item) elif preitem.parent().childCount() == 1: lastgroupname = preitem.parent().text(0).split()[0] + ' 0/0' preitem.parent().setText(0, lastgroupname) self.menuflag = 1 def restatistic_op(self, itemorgroup): gindex = self.searchgroup(itemorgroup) totalcount = self.grouplist[gindex]['childcount'] hidecount = self.grouplist[gindex]['childishide'] fathergroupname = self.grouplist[gindex]['groupname'] fathergroupname += ' ' + str(totalcount - hidecount) + '/' + str(totalcount) itemorgroup.setText(0, fathergroupname)