def __init__(self, map_screen, background_screen, text_screen): """ Constructor. :param map_screen: Surface :param background_screen: Surface :param text_screen: Surface """ self.amount_of_enemies = 0 self.amount_of_empty_colonies = 0 self.map_to_load = None self.race_manager = RaceManager() self.human_players = [] self.players = [] self.map = Map(GUISettings.SCREEN_WIDTH, GUISettings.SCREEN_HEIGHT) self.event_handler = EventHandler(self) self.screen = map_screen self.background_screen = background_screen self.player_one = Player() self.human_players.append(self.player_one) self.sound_driver = SoundDriver() self.map_loader = MapLoader(self) self.text_screen = text_screen self.running = True self.map_manager = MapManager() self.state = MainMenu(self) self.menu = MenuSettings.MAIN_MENU(self)
def main(): logging.basicConfig(stream=sys.stderr, level=logging.DEBUG) current_dir = os.path.dirname(__file__) config = dict() config_path = os.path.join(current_dir, "config.yml") with open(config_path, "r") as stream: config = yaml.safe_load(stream) profiles_dir = os.path.join(current_dir, config['profiles_folder']) file_map = { pygame.K_KP0: 0, pygame.K_KP1: 1, pygame.K_KP2: 2, pygame.K_KP3: 3, pygame.K_KP4: 4, pygame.K_KP5: 5, pygame.K_KP6: 6, pygame.K_KP7: 7, pygame.K_KP8: 8, pygame.K_KP9: 9, } soundboard = Soundboard(profiles_dir) event_handler = EventHandler(soundboard, file_map) while True: event_handler.handle(pygame.event.get())
def test_3_on_noEventAddCallback(self): def test_callback_1(sender, obj): print("test_callback_1") self.assertIsNone(EventHandler.on("test_emit_2", test_callback_1)) self.assertEqual(len(EventHandler.getEvents()), 2) self.assertListEqual(["test_emit_1", "test_emit_2"], EventHandler.getEvents() ) self.assertEqual(EventHandler.getCallbackFuncs(EventHandler.getEvents()[1])[0].__name__ , "test_callback_1")
def __init__(self): self.controller = Controller() self.Handler = EventHandler(self.controller) self.object_list = [] self.game_logic = GameLogic() self.fps_clock = pygame.time.Clock() self.fps = 60 self.neuralnet = NeuralNetHolder() self.version = "v1.01"
def __init__(self, window, game): self.window = window self.game = game self.screen = window.screen self.state = GameState.MAIN_MENU self.eventHandler = EventHandler(self.game) self.objectHandler = ObjectHandler() self.mapHandler = MapHandler(self.window) self.loadMenu()
def __init__(self): self.graph = DAG.DAG() self.MiscVals = { 'Name': '', 'PlayerName': '', 'Profession': '', 'Level': 0, 'Experience': 0 } self.Events = EventHandler()
def _send_manual_notification(self, sessionKey, user, post_data): logger.info("_send_manual_notification started", ) logger.debug("user: {}".format(user)) logger.debug("post_data: {}".format(post_data)) notification = {} notifications = [] query = {} query['incident_id'] = post_data.get('incident_id') logger.debug("Filter: {}".format(json.dumps(query))) uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents?query={}'.format( urllib.parse.quote(json.dumps(query))) serverResponse, incident = rest.simpleRequest(uri, sessionKey=sessionKey) logger.debug("Settings for incident: {}".format(incident)) incidents = json.loads(incident) notification['alert'] = incidents[0].get("alert") notification['incident'] = post_data.get('incident_id') notification['event'] = post_data.get('event') notification_message = post_data.get('notification_message') recipients = post_data.get('recipients') recipients_overwrite = post_data.get('recipients_overwrite') logger.debug("recipients_overwrite: {}".format(recipients_overwrite)) notifications.append(notification.copy()) ic = IncidentContext(sessionKey, notification['incident']) context = ic.getContext() context.update({'notification_message': notification_message}) context.update({'recipients': recipients}) context.update({'recipients_overwrite': recipients_overwrite}) logger.debug("Notification context: {}".format(json.dumps(context))) eh = EventHandler(sessionKey=sessionKey) eh.handleEvent(alert=notification['alert'], event=notification['event'], incident=incidents[0], context=ic.getContext()) logger.info("_send_manual_notification stopped") return self.response('Manual notification executed', http.client.OK)
def run(self, total_servers: int, total_arrival: int) -> None: """ Begin the simulation of a MMCC system. Process the information until termination criteria is meet. Params: - total_servers :: The number of servers that can handle clients at any one instance. - total_arrival :: The total number of clients that can be handled within the simulation. """ # Initialise the beginning parameters of the simulation self.servers = Servers(total_servers) # Set up server handler self.events = EventHandler() # Set up the event handler startingEvent = Event("arrival", 0) # Construct the first event object startingEvent.departure_time -= startingEvent.arrival_time # Reset times startingEvent.arrival_time = 0 # Reset times self.events.add(startingEvent) # Create the first event # Begin iteration of events, record arrivals for checking self.num_arrival = 0 while (self.num_arrival < total_arrival): # Collect next event from the event handler currentEvent = self.events.next() # Update simulation time self.sim_time = currentEvent.time() if currentEvent.type == "arrival": # Arrival event received self.num_arrival += 1 # Record number of arrivals # Create new arrival event self.events.add(Event("arrival", currentEvent.time())) # Check if any server is available if not self.servers.isFree(): self.events.block( currentEvent) # Arriving client is blocked continue # Begin serving the client. currentEvent.servedBy(self.servers.allocate()) # All event handler to manage departure self.events.add(currentEvent) else: # Departure event received self.servers.deallocate( currentEvent.servedBy()) # Free the server self.events.depart(currentEvent) # Record departure
def __init__(self, app): super().__init__() self.app = app self.setupUi(self) self.show() self.current_dir = os.path.dirname(__file__) self.current_mode = "Merge" self.event_handler = EventHandler(self) self.current_tool = Merger(self) self.current_files = [] self.setupProgramm()
def __init__(self, screen): self.screen = screen self.bm = BlockManager() self.im = ItemManager() self.em = EffectManager() self.mm = MobManager() self.player = Player(self) self.mobs = [] self.eh = EventHandler(self) self.level = Level('ark.json', self.screen, self) self.gui = None pygame.mixer.music.load('assets/music/theme.mp3') pygame.mixer.music.play(-1)
def __init__(self, transp=None, host=None, port=None, addResource=True, createSock=True, eventType=SE.SipEvent): EventHandler.__init__(self) self.sock = None self.transp = None self.ip = None self.port = None self.remoteip = None self.remoteport = None self.timeout = None self.state = NetworkEventHandler.NEH_NO_SOCK self.pkgsize = Config.MAX_PKG_SIZE self.data = None self.old_data = None self.eventType = eventType if transp is None: transp = Config.DEFAULT_NETWORK_TRANSPORT if (transp.lower() == "udp" or transp.lower() == "tcp"): self.setTransport(transp) else: raise SCException("NetworkEventHandler", "__init__", "unsupported transport type") if host is None: host = Config.LOCAL_IP if port is None: port = int(Config.LOCAL_PORT) if host.startswith("["): host = host[1:] if host.endswith("]"): host = host[:len(host) - 1] self.localip = host self.localport = port # Because we can not return another NEH instance if a new instance for # the same triplet (transport, ip, port) was requested, we simply # close the existing NEH and the create a new one key = str(getTransportNumber(transp)) + str(host) + str(port) + "00" if addResource and Config.resources.has_key( 'NEH') and Config.resources['NEH'].has_key(key): Log.logDebug( "NetworkEventHandler.init(): closing NEH which uses the same address (key '" + key + "') to prevent bind error", 3) Config.resources['NEH'][key].close() if createSock: self.createSock(transp, host, port) if addResource: Config.resources['NEH'][key] = self
def __init__(self): ''' This function calls parents class, initialize infoWindow, load main window UI, and call the clickOnDate function in eventHandler to get today's event list upon opening the GUI Args: none Returns: none ''' self.eventHandler = EventHandler(self) super(CalendarApp, self).__init__() self.infoDialog = InfoWindow() self.load_ui() self.eventHandler.clickOnDate()
def __init__(self, _filename=None, _fixLF=True, addResource=True): """If a filename is given as parameter that file will be opened for reading. If the second parameter is True single line-feeds will be replaced by carriage-return line-feed while reading in and writing to a file. """ EventHandler.__init__(self) self.filename = None self.fileobj = None self.fixLF = _fixLF if _filename is not None: self.filename = _filename self.openFile("r") if addResource: Config.resources['FEH'][self.filename] = self
def generate_java(canvas): jname = canvas.statusbar.getState(StatusBar.MODEL)[1][0] if not jname or jname == "Nonamed": jname = tkFileDialog.asksaveasfilename(filetypes=[("Java source code", "*.java")]) else: if StringUtil.endswith(jname, ".py"): jname = jname[:len(jname) - 3] + ".java" jname = os.path.split(jname)[1] jname = tkFileDialog.asksaveasfilename(initialfile=jname, filetypes=[("Java source code", "*.java")], initialdir=canvas.codeGenDir) if jname: if StringUtil.endswith(jname, ".java"): mname = jname[:len(jname) - 5] + ".des" else: mname = jname + ".java" desc = generate_description(canvas, 0)["desc"] eventhandler = EventHandler(mname, modeltext=desc) g = JavaGenerator(eventhandler) code = g.generate_code() # Save .java file jf = open(jname, "w") jf.write(code) jf.close() # Print on success print "Java code saved to: " + jname
def check_import_mdl(self, path, s, states): if states[IMPORT_STATE] != None: keys = states.keys() keys.sort() for subs in keys: if not subs in StateProperties: print 'WARNING: Importation state has substate(s). This may cause unexpected error.' break filename = DynamicEvaluateExpression(states[IMPORT_STATE]) params = {} keys = states[PARAMETERS].keys() keys.sort() for k in keys: p = states[PARAMETERS][k] b = DynamicEvaluateExpression(p[1]) params[k] = [p[0], b] stnum = self.get_state_num(self.eventhandler.append_path(path, s)) if not self.compiled_files.has_key(filename): eh = EventHandler(filename, None, params, 0, 0, [], [], 0, None, self.eventhandler.options) self.required_models.append(eh) self.compiled_files[filename] = eh.options[MODEL_NAME] self.submodels[stnum] = eh.options[MODEL_NAME] else: self.submodels[stnum] = self.compiled_files[filename]
def __init__(self, device, grabbed=False): self.dev = evdev.InputDevice(device) self.eventHandler = EventHandler() if grabbed: self.dev.grab() #takes exclusive control over the keyboard asyncio.get_event_loop().create_task( self.keyboardHandler()) #starts the keyboad handler loop
def run(self, server_number: int, arrival_total: int): """ Run simulation with specified parameters :param server_number: Number of servers :param arrival_total: Number of events """ # Initialise Servers and EventHandler self.servers = Servers(server_number) self.events = EventHandler() # Create and add initial event starting_event = Event("arrival", 0) starting_event.departure_time -= starting_event.arrival_time starting_event.arrival_time = 0 self.events.add(starting_event) # Run simulation until number of events handled self.arrival_number = 0 while (self.arrival_number < arrival_total): # Iterate to next event and update simulation time current_event = self.events.next() self.simulation_time = current_event.time() # If arrival, update counter and add to appropriate list if current_event.event_type == "arrival": self.arrival_number += 1 self.events.add(Event("arrival", current_event.time())) # If no servers free, block event if not self.servers.is_free(): self.events.block(current_event) continue # Assign server to event current_event.served_by(self.servers.allocate()) self.events.add(current_event) # If departure, free server and depart else: self.servers.deallocate(current_event.served_by()) self.events.depart(current_event)
class Game: def __init__(self, screen): self.screen = screen self.bm = BlockManager() self.im = ItemManager() self.em = EffectManager() self.mm = MobManager() self.player = Player(self) self.mobs = [] self.eh = EventHandler(self) self.level = Level('ark.json', self.screen, self) self.gui = None pygame.mixer.music.load('assets/music/theme.mp3') pygame.mixer.music.play(-1) def update(self): self.level.update() self.player.update() for mob in self.mobs: mob.update() self.eh.handle(None) def step(self, direction=None): if direction is not None: self.player.step(direction) for mob in self.mobs: mob.step() def open_gui(self, gui, callback=None): if callback is not None: self.gui = gui.set_callback(callback) else: self.gui = gui def render(self): self.level.render() self.player.render() if self.gui is not None: self.gui.render() for mob in self.mobs: mob.render() def send_event(self, event): self.eh.handle(event)
def __init__(self, _filename=None, addResource=True): """If a filename is given as parameter that file will be opened for reading. If the second parameter is True single line-feeds will be replaced by carriage-return line-feed while reading in and writing to a file. """ EventHandler.__init__(self) self.filename = None self.fileobj = None self.framenr = 0 if _filename is not None: self.filename = _filename self.openFile(mode="w") if addResource: if self.filename.endswith('.xml'): fn = self.filename[:len(self.filename)-4] else: fn = self.filename Config.resources['XMLEH'][fn] = self
def __init__(self, _filename=None, addResource=True): """If a filename is given as parameter that file will be opened for reading. If the second parameter is True single line-feeds will be replaced by carriage-return line-feed while reading in and writing to a file. """ EventHandler.__init__(self) self.filename = None self.fileobj = None self.framenr = 0 if _filename is not None: self.filename = _filename self.openFile(mode="w") if addResource: if self.filename.endswith('.xml'): fn = self.filename[:len(self.filename) - 4] else: fn = self.filename Config.resources['XMLEH'][fn] = self
def __init__(self): self.root = Tk() self.setUpMenu() self.canvas = self.setUpCanvas(self.root, 800, 800) self.canvas.pack() self.graph = DrawableGraph () self.eventHandler = EventHandler(self.canvas) self.root.mainloop()
def __init__(self, transp=None, host=None, port=None, addResource=True, createSock=True, eventType=SE.SipEvent): EventHandler.__init__(self) self.sock = None self.transp = None self.ip = None self.port = None self.remoteip = None self.remoteport = None self.timeout = None self.state = NetworkEventHandler.NEH_NO_SOCK self.pkgsize = Config.MAX_PKG_SIZE self.data = None self.old_data = None self.eventType = eventType if transp is None: transp = Config.DEFAULT_NETWORK_TRANSPORT if (transp.lower() == "udp" or transp.lower() == "tcp"): self.setTransport(transp) else: raise SCException("NetworkEventHandler", "__init__", "unsupported transport type") if host is None: host = Config.LOCAL_IP if port is None: port = int(Config.LOCAL_PORT) if host.startswith("["): host = host[1:] if host.endswith("]"): host = host[:len(host)-1] self.localip = host self.localport = port # Because we can not return another NEH instance if a new instance for # the same triplet (transport, ip, port) was requested, we simply # close the existing NEH and the create a new one key = str(getTransportNumber(transp)) + str(host) + str(port) + "00" if addResource and Config.resources.has_key('NEH') and Config.resources['NEH'].has_key(key): Log.logDebug("NetworkEventHandler.init(): closing NEH which uses the same address (key '" + key + "') to prevent bind error", 3) Config.resources['NEH'][key].close() if createSock: self.createSock(transp, host, port) if addResource: Config.resources['NEH'][key] = self
def simulate(canvas): global theCanvas theCanvas = canvas mname = canvas.statusbar.getState(StatusBar.MODEL)[1][0] if not mname: mname = "Nonamed.des" else: if mname.endswith(".py"): mname = mname[:len(mname) - 3] mname = mname + ".des" global sc sc = generate_description(canvas, 0) global debugger debugger = Debugger() global eventhandler eventhandler = EventHandler(mname, callback=debugger.EventDebugger, use_gui=1, modeltext=sc["desc"]) eventhandler.final.append("SVMAToM3Plugin.finalize_simulation()") debugger.CustomizeEvent(event_callback, None, 1) global root root = canvas.ASGroot.listNodes DefaultInterpreter.runsource("eventhandler=SVMAToM3Plugin.eventhandler") DefaultInterpreter.runsource("debugger=SVMAToM3Plugin.debugger") debugger.SetEventHandler(eventhandler) eventhandler.run_initializer() highlight_states(eventhandler.state, sc) highlight_trans(eventhandler, sc, root) # Cannot start the Tk mainloop again # eventhandler.run_interactor() DefaultInterpreter.runsource( "setup_gui_debugger(eventhandler, debugger, 0, 0)")
class Application: sorter = None def __init__(self, window): pygame.init() self.window = window self.event_handler = EventHandler() self.renderer = Renderer(window) self.data = Data(10, 300, 64) self.buttons = [ RandomizeButton(BLACK, 25, 25, 125, 25, 'Randomize Data', WHITE, self.data), SorterButton(BLACK, 175, 25, 125, 25, 'Bubble Sort', WHITE, BubbleSorter(self.renderer), self.data), SorterButton(BLACK, 325, 25, 125, 25, 'Selection Sort', WHITE, SelectionSorter(self.renderer), self.data), SorterButton(BLACK, 475, 25, 125, 25, 'Insertion Sort', WHITE, InsertionSorter(self.renderer), self.data), SorterButton(BLACK, 625, 25, 125, 25, 'Merge Sort', WHITE, MergeSorter(self.renderer), self.data), SorterButton(BLACK, 775, 25, 125, 25, 'Quick Sort', WHITE, QuickSorter(self.renderer), self.data) ] self.event_handler.register_buttons(self.buttons) self.renderer.register_buttons(self.buttons) self.renderer.register_data(self.data) def run(self): while 1: # check if any new events have occured self.event_handler.handle_events() # render window self.renderer.refresh() self.renderer.render_buttons() self.renderer.render_data() # update display pygame.display.update()
def _update_incident(self, sessionKey, user, post_data): logger.debug("START _update_incident()") required = ['incident_data'] missing = [r for r in required if r not in post_data] if missing: return self.response( "Missing required arguments: {}".format(missing), http.client.BAD_REQUEST) incident_data = post_data.pop('incident_data') splunk.setDefault('sessionKey', sessionKey) eh = EventHandler(sessionKey=sessionKey) config = {} config['index'] = 'main' restconfig = entity.getEntities('configs/alert_manager', count=-1, sessionKey=sessionKey) if len(restconfig) > 0: if 'index' in restconfig['settings']: config['index'] = restconfig['settings']['index'] logger.debug("Global settings: {}".format(config)) # Parse the JSON incident_data = json.loads(incident_data) # Select between updating multiple incidents (replace full document) and updating single incidents (attribute update) if 'incident_ids' in incident_data and len( incident_data['incident_ids']) > 1: logger.info("do_update_incidents") self._do_update_incidents(sessionKey, config, eh, incident_data, user) elif 'incident_ids' in incident_data and len( incident_data['incident_ids']) == 1: logger.info("do_update_incident") self._do_update_incident(sessionKey, config, eh, incident_data['incident_ids'][0], incident_data, user) else: logger.info("do_update_incident") self._do_update_incident(sessionKey, config, eh, incident_data['incident_id'], incident_data, user) return self.response('Successfully updated incident(s).', http.client.OK)
def __init__(self, window): pygame.init() self.window = window self.event_handler = EventHandler() self.renderer = Renderer(window) self.data = Data(10, 300, 64) self.buttons = [ RandomizeButton(BLACK, 25, 25, 125, 25, 'Randomize Data', WHITE, self.data), SorterButton(BLACK, 175, 25, 125, 25, 'Bubble Sort', WHITE, BubbleSorter(self.renderer), self.data), SorterButton(BLACK, 325, 25, 125, 25, 'Selection Sort', WHITE, SelectionSorter(self.renderer), self.data), SorterButton(BLACK, 475, 25, 125, 25, 'Insertion Sort', WHITE, InsertionSorter(self.renderer), self.data), SorterButton(BLACK, 625, 25, 125, 25, 'Merge Sort', WHITE, MergeSorter(self.renderer), self.data), SorterButton(BLACK, 775, 25, 125, 25, 'Quick Sort', WHITE, QuickSorter(self.renderer), self.data) ] self.event_handler.register_buttons(self.buttons) self.renderer.register_buttons(self.buttons) self.renderer.register_data(self.data)
def simulate(canvas): global theCanvas theCanvas=canvas mname=canvas.statusbar.getState(StatusBar.MODEL)[1][0] if not mname: mname="Nonamed.des" else: if mname.endswith(".py"): mname=mname[:len(mname)-3] mname=mname+".des" global sc sc=generate_description(canvas, 0) global debugger debugger=Debugger() global eventhandler eventhandler=EventHandler(mname, callback=debugger.EventDebugger, use_gui=1, modeltext=sc["desc"]) eventhandler.final.append("SVMAToM3Plugin.finalize_simulation()") debugger.CustomizeEvent(event_callback, None, 1) global root root=canvas.ASGroot.listNodes DefaultInterpreter.runsource("eventhandler=SVMAToM3Plugin.eventhandler") DefaultInterpreter.runsource("debugger=SVMAToM3Plugin.debugger") debugger.SetEventHandler(eventhandler) eventhandler.run_initializer() highlight_states(eventhandler.state, sc) highlight_trans(eventhandler, sc, root) # Cannot start the Tk mainloop again # eventhandler.run_interactor() DefaultInterpreter.runsource("setup_gui_debugger(eventhandler, debugger, 0, 0)")
def main_loop(): json_data = open("config.json").read() config = json.loads(json_data) bot = telegram.Bot(token=config["TOKEN_BOT"]) logging_user = config['logging_user'] if 'logging_user' in config.keys() else None updater = Updater(bot=bot) dispatcher = updater.dispatcher logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG) sender_filter = SenderFilterService(config) message_sender = MessageSender(bot, config, logging_user=logging_user) event_handler = EventHandler(sender_filter, message_sender, config, logging_user=logging_user) all_handler = MessageHandler(Filters.all, event_handler.handle_all) dispatcher.add_handler(all_handler) print 'waiting new messages...' updater.start_polling()
def __init__(self): try: self.graph = pickle.load(open(FILE_LOCATION, "rb")) LoggerSingleton() # Initialise the logger when creating from binary file except: self.graph = generateDemoGraph() self.builder = Gtk.Builder() self.builder.add_from_file("MainScreen.glade") self.builder.connect_signals(EventHandler(self.graph, self)) self.MainWindow = self.builder.get_object("MainWindow") self.LoginWindow = self.builder.get_object("LoginWindow") self.ConversionWindow = self.builder.get_object("ConversionWindow") self.AdminWindow = self.builder.get_object("AdminWindow") self.LoginWindow.show_all()
def add_event_handler(self, evh, uri_base): type = evh.getAttribute('type') file = evh.getAttribute("file") code = "" if file == "": # if no file attribute is specified, it must # be inline code code = evh.childNodes[0].data else: # get the code from the specified file if not re.match("(http:|\/|file:)", file): # the uri appears to be relative, so we # append it to the base uri file = urlparse.urljoin(uri_base, file) try: code = "".join(urllib.urlopen(file).readlines()) except: self.error("couldn't open file %s" % file) code = code.replace("\r\n", "\n") self.event_handlers[type] = EventHandler(self, type, code, file)
def threadFunc(base_path, file_name): EventHandler(base_path, file_name, upload_file)
#! /usr/bin/env python3 import sys sys.path.append(",") from pathlib import Path from time import sleep from watchdog.observers import Observer from EventHandler import EventHandler if __name__ == '__main__': watch_path = Path.home() / 'C:/Users/mwiniarski/Downloads/cleaner' destination_root = Path.home( ) / 'C:/Users/mwiniarski/Downloads/cleaner/holder of things' event_handler = EventHandler(watch_path=watch_path, destination_root=destination_root) observer = Observer() observer.schedule(event_handler, f'{watch_path}', recursive=True) observer.start() try: while True: sleep(60) except KeyboardInterrupt: observer.stop() observer.join()
class App: def __init__(self): self.root = Tk() self.setUpMenu() self.canvas = self.setUpCanvas(self.root, 800, 800) self.canvas.pack() self.graph = DrawableGraph () self.eventHandler = EventHandler(self.canvas) self.root.mainloop() def setUpMenu(self): menubar = Menu(self.root) menubar.add_command(label="New Graph", command=self.newGraph) menubar.add_command(label="Properties", command=self.properties) menubar.add_command(label="Reset Graph", command = self.resetGraph) algMenu = Menu(menubar, tearoff=0) algMenu.add_command(label="Depth First Search", command=self.dfs) algMenu.add_command(label="Breadth First Search", command=self.bfs) algMenu.add_command(label="Prim's Algorithm", command=self.prims) algMenu.add_command(label="Dijkstra's Algorithm", command=self.dijkstras) menubar.add_cascade(label="Algorithms", menu=algMenu) addMenu = Menu(menubar, tearoff=0) addMenu.add_command(label="Vertices", command=self.addVertices) addMenu.add_command(label="Edges", command=self.addEdges) menubar.add_cascade(label="Add", menu=addMenu) self.root.config(menu=menubar) # Bind mouse click event to add a new vertex def addVertices(self): messagebox.showinfo("Add Vertex", "Click anywhere to add a vertex") self.canvas.bind("<Button-1>", self.newVertex) # Bind mouse click event to add a new edge def addEdges(self): messagebox.showinfo("Add Edge", "Select a start vertex and an end vertex") self.canvas.bind("<Button-1>", self.newEdge) # Wipe canvas, set graph attribute to a new graph def newGraph(self): self.canvas.delete("all") self.graph = DrawableGraph() self.canvas.unbind("<Button-1>") # Colour all edges and vertices black def resetGraph(self): for v in self.graph: v.setColour("black") self.graph.drawGraph(self.canvas) # Tell eventHandler to add a new edge def newEdge(self, event): self.eventHandler.newEdge(event, self.graph) # Get properties back from eventHandler and display def properties(self): properties = self.eventHandler.handleProperties(self.graph) # Graph has no edges or vertices, so do not show anything if (properties != None): PropertiesDialog(self.root, properties) # Bind mouse click event to DFS def dfs(self): messagebox.showinfo("DFS", "Click on a start vertex") self.canvas.bind("<Button-1>", self.handleDFS) def handleDFS(self, event): self.eventHandler.handleDFS(self.graph, event) # Bind mouse click event to BFS def bfs(self): messagebox.showinfo("BFS", "Click on a start vertex") self.canvas.bind("<Button-1>", self.handleBFS) def handleBFS(self, event): self.eventHandler.handleBFS(self.graph, event) # Bind mouse click event to Prims def prims(self): messagebox.showinfo("Prims", "Click on a start vertex") self.canvas.bind("<Button-1>", self.handlePrims) def handlePrims(self, event): self.eventHandler.handlePrims(self.graph, event) # Bind mouse click event to Dijkstras def dijkstras(self): messagebox.showinfo("Dijkstras", "Click on a start vertex") self.canvas.bind("<Button-1>", self.handleDijkstra) def handleDijkstra(self, event): self.eventHandler.handleDijkstra(self.graph, event) def draw(self): self.graph.drawGraph(self.canvas) def setUpCanvas(self, master, width, height): canvas = Canvas(master, width=width, height=height) return canvas def newVertex(self, event): self.eventHandler.newVertex(event, self.graph)
if __name__ == '__main__': #init config file print "load global config file" if len(sys.argv) < 2: config.load("../conf/mymeego.conf") else: config.load(sys.argv[1]) #init mainloop dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) # get session bus bus = dbus.SessionBus() mainloop = gobject.MainLoop() event_handler = EventHandler(mainloop) # init upnp ######## configfile = config.coherence_conf if len(configfile) <= 0: sys.exit("no coherence config file specified in config or else") upnp = BackendUpnp(event_handler,configfile,config.device_name,config.device_type) # end upnp init #### # init closing signals signal.signal(signal.SIGINT,close) # CTRL+C signal error signal.signal(signal.SIGQUIT,close) # terminal quit # init modules dbus_module = DbusModule(event_handler,"dbus","org.mymeego.Ui","/org/mymeego/Ui","org.mymeego.Ui") upnp_module = UpnpModule(event_handler,"upnp",upnp)
argn=argn+1 debugger=Debugger() path_name=os.path.split(desc) addpath=path_name[0] name=path_name[1] if len(addpath)>0: sys.path=[addpath]+sys.path params={} while argn<len(sys.argv): arg=sys.argv[argn] argn=argn+1 param=ParseOption(arg) if param!=None: par=ParseParameter(param[0]) params[par[0]]=[par[1], param[1]] try: eventhandler=EventHandler(name, debugger.EventDebugger, params, use_gui, 1, haddition, taddition) except FileNotFound, e: print e raise SystemExit debugger.SetEventHandler(eventhandler) if eventhandler.description: print eventhandler.description eventhandler.run_initializer() eventhandler.run_interactor()
def eventHandlingTest(): print "event handler test set" print "init test set" event_handler = EventHandler() # init modules dbus_module = DbusModule(event_handler,"dbus","org.mymeego.Ui","/org/mymeego/Ui","org.mymeego.Ui") upnp_module = UpnpModule(event_handler,"upnp") worker_module = WorkerModule(event_handler,"worker") #init commands event_handler.addCommand(Command("ReturnUiData",dbus_module)) event_handler.addCommand(Command("DataRequest",worker_module)) # this is the default command from UI event_handler.addCommand(Command("GetDeviceList",upnp_module)) event_handler.addCommand(Command("GetFileList",upnp_module)) event_handler.addCommand(Command("TransferFiles",upnp_module)) print "start tests" event_handler.handleEvent(Event("DataRequest",1,"GetDeviceList")) event_handler.handleEvent(Event("DataRequest",1,"GetFileList")) event_handler.handleEvent(Event("DataRequest",1,"TransferFiles")) event_handler.handleEvent(Event("ReturnUiData",1,"TransferFiles"))
parser = argparse.ArgumentParser('Settings for Morris Bot') parser.add_argument('-T', '--token', help='Token which you got from your group admin.') parser.add_argument( '-Pl', '--parser-login', help= 'Login for your bot-account. Opens new feature like a parsing timetable') parser.add_argument('-Pp', '--parser-password', help='Password for your bot-account.') args = vars(parser.parse_args()) bot = EventHandler() token = args.get('token') # Creating group-class group = Group() group.auth(token) group.connect_storage(DBProxy(Member)) bot.set_group(group) # Setup account for bot. This is need for parsing group wall and timetable account = BotAccount.get_account() account.auth(args.get('parser-login'), args.get('parser-password')) # Setup observers that handle commands command_observer = IObserver.get_observer(CommandObserver)
params = {} while argn < len(sys.argv): arg = sys.argv[argn] argn = argn + 1 param = ParseOption(arg) if param != None: par = ParseParameter(param[0]) params[par[0]] = [par[1], param[1]] if command_only: if len(name) > 4 and string.upper(name[len(name) - 4:]) == ".DES": model_name = name[:len(name) - 4] else: model_name = name else: eventhandler = EventHandler(name, None, params, use_gui, 1, haddition, taddition, 0) model_name = eventhandler.options[MODEL_NAME] code_type = string.lower(code_type) info = {"time": None, "compile": None, "run": None, "file": None} desc = [[], ["time", "Time spent on compilation: "], ["file", "File(s) generated: "], [], ["compile", "Command to compile the source: "], ["run", "Command to run the compiled code: "], []] starttime = time.time() if code_type == "java": if not command_only: from JavaGenerator import JavaGenerator g = JavaGenerator(eventhandler) g.generate()
class CalendarApp(QMainWindow): '''This class contains the CalendarApp class(main window), it inherits the QMainWindow class in Pyside2''' def __init__(self): ''' This function calls parents class, initialize infoWindow, load main window UI, and call the clickOnDate function in eventHandler to get today's event list upon opening the GUI Args: none Returns: none ''' self.eventHandler = EventHandler(self) super(CalendarApp, self).__init__() self.infoDialog = InfoWindow() self.load_ui() self.eventHandler.clickOnDate() def showInfoDialog(self): '''Shows the pop-up infoWindow when the called (upon bookPushbutton is clicked) Args: none Returns: none ''' self.setEnabled( False) #set main window to disable when showing the popup window self.infoDialog.show() # show popup info window #Bindind the UI components to listener(eventhandler) def BindEventsHandler(self): '''Binds the UI components to its listener - functions in EventHandler class Args: none Returns: none ''' btn = self.window.findChild(QPushButton, 'bookPushButton') btn.clicked.connect(self.eventHandler.bookPushButton_cliked) self.calWidget = self.window.findChild(QCalendarWidget, 'calendarWidget') self.calWidget.selectionChanged.connect(self.eventHandler.clickOnDate) self.QListWidget = self.window.findChild(QListWidget, 'listWidget') btn = self.infoDialog.findChild(QPushButton, 'sendButton') btn.clicked.connect(self.eventHandler.sendPushButton_clicked) btn = self.infoDialog.findChild(QPushButton, 'cancelButton') btn.clicked.connect(self.eventHandler.cancelPushButton_clicked) def load_ui(self): '''Load the mainWindow.ui file and show it on screen. Args: none Returns: none ''' loader = QUiLoader() path = os.path.join(os.path.dirname(__file__), "mainWindow.ui") ui_file = QFile(path) ui_file.open(QFile.ReadOnly) self.window = loader.load(ui_file, self) ui_file.close() self.BindEventsHandler() self.window.show()