def __init__(self, app=None, direction=VERTICAL): Overlay.__init__(self, OVERLAY_SPLITTER) EventHandler.__init__(self, app) self.direction = direction self.__enlarged = False self.__scaleMultiplier = 4.0 self._canScale = False self.mouseOverScale = 1.0 self.setTransparency(255) self.z = BOTTOM_Z - 10 self.relPos = 0.5 # relative to the section it splits self._preCollapsedPos = self.relPos self.__buffer = int(20 * getGlobalScale()) self._collapsed = False self.registerForEvent(EVT_DRAG, self.__onDrag) self.registerForEvent(EVT_CLICK, self.__onClick) self.registerForEvent(EVT_MOVE, self.__onMove) self.registerForEvent(EVT_LEFT_WINDOW, self._onLeftWindow) self.registerForEvent(EVT_ENTERED_WINDOW, self._onEnteredWindow) if direction == VERTICAL: self.__image = opj("images", "vertical_divider.png") else: self.__image = opj("images", "horizontal_divider.png")
def __init__(self, overlayId, app): Overlay.__init__(self, OVERLAY_APP, overlayId) EventHandler.__init__(self) self.app = app # which app is this overlay tied to self.bounds.setAll(app.left, app.right, app.top, app.bottom) self.displayId = app.getDisplayId() self.aspectRatio = self.bounds.getWidth() / float(self.bounds.getHeight()) self.minAppSize = 300 # min app size in either direction self.z = self.app.getZvalue() self.__resetOverlay() self.capturedCorner = APP self.lastClickPos = (0,0) self.lastClickDeviceId = None self.overCorner = APP # register for the events that are fired when an app changes self.registerForEvent(EVT_APP_INFO, self.__onAppChanged) self.registerForEvent(EVT_Z_CHANGE, self.__onZChanged) # register for the events that are fired by devices self.registerForEvent(EVT_MOVE, self.__onOver) self.registerForEvent(EVT_CLICK, self.__onClick) self.registerForEvent(EVT_DRAG, self.__onDrag) self.registerForEvent(EVT_ROTATE, self.__onRotate) self.registerForEvent(EVT_ZOOM, self.__onZoom) self.registerForEvent(EVT_ARROW, self.__onArrow) self.registerForEvent(EVT_LEFT_WINDOW, self.__onLeftWindow) # register for the events from the special devices self.registerForEvent(EVT_MOVE_SPECIAL, self.__onSpecialMove) self.registerForEvent(EVT_ENTERED_WINDOW_SPECIAL, self.__onEnteredWindowSpecial) self.registerForEvent(EVT_LEFT_WINDOW_SPECIAL, self.__onLeftWindowSpecial)
def __init__(self): self.eventHandler = EventHandler() super(UIMainMenu, self).__init__(9, self.eventHandler) #We tell the button to draw to a dummy screen so it does not appear self.winScreen.primary_button.screen = pygame.Surface((0, 0)) self.nineByNine = UIMessage(self.screen, self.screen, "9x9", self.FONT, self.BASELINE_GRID, self.MESSAGE_FONTSIZE, pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25, self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR, self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select", None, 0.35, 0.05, self.eventHandler) self.thirteenByThirteen = UIMessage( self.screen, self.screen, "13x13", self.FONT, self.BASELINE_GRID, self.MESSAGE_FONTSIZE, pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25, self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR, self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select", None, 0.35, 0.35, self.eventHandler) self.nineteenByNineteen = UIMessage( self.screen, self.screen, "19x19", self.FONT, self.BASELINE_GRID, self.MESSAGE_FONTSIZE, pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25, self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR, self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select", None, 0.35, 0.65, self.eventHandler)
def __init__(self, app=None): Overlay.__init__(self, OVERLAY_BUTTON) EventHandler.__init__(self, app) # register for the events that are fired by devices self.registerForEvent(EVT_CLICK, self._onClick) self.registerForEvent(EVT_MOVE, self._onMove) self.registerForEvent(EVT_LEFT_WINDOW, self._onLeftWindow) self.registerForEvent(EVT_ENTERED_WINDOW, self._onEnteredWindow) # paths to images drawn for different button states self.__upImage = "images/default_button_up.png" self.__downImage = "" self.__overImage = "" self.__doPlaySound = True # button can be a toggle self._isToggle = False self.__radioFunc = True self.__clicked = False self._manual = False self._radio = False # current state of the button self.__state = UP_STATE # callbacks you can register self.__onDown = None self.__onUp = None self._lastDevice = None self.__minTimeBetweenClicks = 0.5 # by default, allow rapid successive clicks self.__lastUp = 0.0 self.__lastDown = 0.0
def __init__(self, displayId): EventHandler.__init__(self) self.displayId = displayId #self.registerForEvent(EVT_MOVE, self.__onMove) self.registerForEvent(EVT_DISPLAY_INFO, self.__onDispInfo) self.registerForEvent(EVT_ENTERED_WINDOW, self.__onEnteredWindow) self.registerForEvent(EVT_LEFT_WINDOW, self.__onLeftWindow) self.z = BOTTOM_Z
def __init__(self, app=None, label="", fontSize=NORMAL): """ If you pass in None for app, the widget will reside on the top layer above all apps but below pointers. """ Overlay.__init__(self, OVERLAY_LABEL) EventHandler.__init__(self, app) self.setLabel(label, fontSize) self.__drawBackground = True
def __init__(self, app): Overlay.__init__(self, OVERLAY_APP) EventHandler.__init__(self, app) # must set size and pos first self._canScale = False self.setSize(1.0, 1.0) # same size as the app self.setPos(0.0, 0.0) # right over the app self._zOffset = APP_OVERLAY_Z self._allowSelection = True # some initial params self.minAppSize = 250 # min app size in either direction self.capturedCorner = APP self.lastClickPos = (0,0) self.lastClickDeviceId = None self.overCorner = APP self.bounds = self.getBounds() # from EventHandler base class self._clickDownTime = 0.0 self.__startedDrag = False # for accidental touches... # if less than X seconds has passed between two double clicks, # maximize to the whole display, otherwise, just within the section self._lastDoubleClick = 0.0 self.__maximizeThreshold = 1.3 # seconds between two double clicks... # for closing apps self.__multiTouchStartTime = -1 self.org = getLayoutOrganization() # get the filename from appLauncher if "imageviewer" in app.getName().lower() or \ "mplayer" in app.getName().lower() or \ "stereo3d" in app.getName().lower() or \ "pdf" in app.getName().lower(): # get the config info from the right appLauncher if app.getLauncherId() != "none": appLauncher = xmlrpclib.ServerProxy("http://" + app.getLauncherId()) try: res = appLauncher.getAppConfigInfo( app.getAppId() ) except: print "\nUnable to connect to appLauncher on", app.getLauncherId(), "so not saving this app: ", app.getName() else: print "appLauncher.getAppConfigInfo : ", res if res != -1: configName, optionalArgs = res if "imageviewer" in app.getName().lower(): # filename at the beginning of the command line for images self.fullpathname = optionalArgs.split()[0].strip('"') self.filename = os.path.basename( self.fullpathname ) else: # filename at the end of the command line for movies self.fullpathname = optionalArgs.split()[-1].strip('"') self.filename = os.path.basename( self.fullpathname ) if getShowWindowTitleBar(): self.setTooltip(self.filename, LARGER)
def __init__(self, app=None, direction=HORIZONTAL): """ If you pass in None for app, the widget will reside on the top layer above all apps but below pointers. """ Overlay.__init__(self, OVERLAY_SIZER) EventHandler.__init__(self, app) self.__direction = direction # let the events pass through since we are transparent self._eventTransparent = True
def __init__(self, size=9): self.players = [Player('B', 300), Player('W', 300)] self.currentPlayer = 0 self.board = Board(size) self.territories = Board(size) self.previousBoard = self.board.getMatrix() self.currentBoard = self.board.getMatrix() self.cursor = Cursor(self.board) self.attemptedPlace = False self.handler = EventHandler() self.UI = UIMatch(size, self.handler) self.newGame = False self.exit = False
def __init__(self, width, height): # initialize variables self.__interfaceWidth = width self.__interfaceHeight = height self.__header_bg = 'silver' self.__ListBoxLabel_bg = 'gainsboro' # Create Interface Window Template self.root = Tk() self.root.title("My Analytic Solver") self.root.geometry('{}x{}'.format( self.__interfaceWidth, self.__interfaceHeight)) # set size to fit iphone size self.root.resizable(0, 0) # this prevents from resizing the window # Create EventHandler object self.eh = EventHandler(self)
def __init__(self): pygame.init() pygame.display.set_caption('enemy invasion') self.main_clock = pygame.time.Clock() self.background_color = ss.screen_background_color self.screen = pygame.display.set_mode(ss.screen_size) self.ship: Ship = Ship(self.screen) self.enemyFleet = EnemyFleet(self.screen, self.ship) self.eventHandler = EventHandler() self.add_events()
def main(): model = init_model( os.path.dirname(os.path.abspath(__file__)), getpass.getuser(), os.uname().nodename ) def resize(signum, frame): Render(model) # Re-renders Terminal in case of SIGWINCH(resize) event signal.signal(signal.SIGWINCH, resize) while not model.exit: try: Render(model) try: model = EventHandler(model, blesses.get_key()) except KeyboardInterrupt: model = replace(model, exit=1) except Exception as e: with open("crash.json", "w+") as f: f.write(json.dumps(asdict(model),indent=4)) raise e
def setRelPos(self, rp): self.relPos = rp sec = self.getUserData() # now calculate the absolute x,y in SAGE coords based on the section-relative position if self.direction == HORIZONTAL: x = sec.getX() y = int(sec.bounds.bottom + sec.bounds.getHeight()*rp) else: y = sec.getY() x = int(sec.bounds.left + sec.bounds.getWidth()*rp) newSpace = abs(x-self.getX()), abs(y-self.getY()) EventHandler.setPos(self, x, y) return newSpace
def main(): # watch manager wm = pyinotify.WatchManager() # watched events mask = \ pyinotify.IN_MODIFY | \ pyinotify.IN_ACCESS | \ pyinotify.IN_CLOSE_WRITE | \ pyinotify.IN_CLOSE_NOWRITE # Exclude patterns from file excl_file = os.path.join(os.getcwd(), 'exclude.lst') excl = pyinotify.ExcludeFilter(excl_file) watch_path_list = [ # '/var/log/mosquitto/mosquitto.log', '/var/log/syslog', # '/var/log/postgresql/postgresql-9.6-main.log' ] # Add watches wdd = wm.add_watch(watch_path_list, mask, rec=True, exclude_filter=excl) # event handler eh = EventHandler() # notifier notifier = pyinotify.ThreadedNotifier(wm, eh) notifier.start()
def __init__(self, playerNames): self.logicHandler = LogicHandler() self.eventHandler = EventHandler() self.players = [] self.turns = 0 self.jsonResponse = {} for playerName in playerNames: objective = self.logicHandler.get_random_objective() self.players.append(Player(playerName, objective))
def __init__(self, app=None): """ If you pass in None for app, the widget will reside on the top layer above all apps but below pointers. """ Overlay.__init__(self, OVERLAY_PANEL) EventHandler.__init__(self, app) self.registerForEvent(EVT_DRAG, self.__onDrag) self.registerForEvent(EVT_CLICK, self._onClick) self._allowDrag = False # ONLY USE WITH ABSOLUTE POSITION!!! (wont work when aligned) self.__fitInWidth = True self.__fitInHeight = True self.__borderWidth = 0 self._zOffset -= 0.01 # just below the other widgets self.px = self.py = 0
def __init__(self, x=0, y=0): Overlay.__init__(self, OVERLAY_POINTER) EventHandler.__init__(self) self.setSize(50,75) self.setPos(x,y) self.setDrawOrder(POST_DRAW) self.state = RESET self.lastOrientation = 0 self.inApp = False self.__savedState = [self.state, self.lastOrientation, self.inApp] # some devices only produce one analog event so set it here if so # (e.g. a zoom-only puck) # this is used when the device enters an application in order to show # the correct pointer shape describing what the device can do self.onlyAnalogEvent = None self._eventTransparent = True # so that we dont receive our own clicks... self.__image = ""
def main() -> None: """The main function loads all the required variables, instantiates the tcod console, tcod context and the game engine. It then continuously executes the game loop by calling the engine""" title = "Roachlife" console_width = 80 console_height = 50 map_width = 80 map_height = 45 max_room_size = 10 min_room_size = 5 max_rooms = 20 max_enemies_per_room = 2 tileset = tcod.tileset.load_tilesheet("dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD) ### Instantiating the objects to use for testing ### player = copy.deepcopy(definedEntities.player) ### Instantiating the objects to use for testing ### game_map = generate_game_map(map_width=map_width, map_height=map_height, max_rooms=max_rooms, min_room_size=min_room_size, max_room_size=max_room_size, max_enemies_per_room=max_enemies_per_room, player=player) event_handler = EventHandler( ) # We initialize the eventHandler object to be inputted into the engine. engine = Engine( event_handler=event_handler, game_map=game_map, player=player ) # We initialize the engine with the EventHandler object and a player object representing the player character. # The tcod context with tcod.context.new_terminal(console_width, console_height, tileset=tileset, title=title, vsync=True) as context: console = tcod.Console(console_width, console_height, order="F") while True: engine.render(console, context) events = tcod.event.wait() engine.handle_events(events)
def start(self): # Controls Physics and other engine related Things # Init Input self.inputHandler = InputHandler(self) self.inputHandler.start() # Event HAndler self.eventHandler = EventHandler(self) self.eventHandler.start() # Init Camera self.cameraHandler = CameraHandler(self, "TPS") # Start Engine Loop taskMgr.add(self.engineLoop, "Engine_Loop")
class GraphicsInterface: def __init__(self, width, height): # initialize variables self.__interfaceWidth = width self.__interfaceHeight = height self.__header_bg = 'silver' self.__ListBoxLabel_bg = 'gainsboro' # Create Interface Window Template self.root = Tk() self.root.title("My Analytic Solver") self.root.geometry('{}x{}'.format( self.__interfaceWidth, self.__interfaceHeight)) # set size to fit iphone size self.root.resizable(0, 0) # this prevents from resizing the window # Create EventHandler object self.eh = EventHandler(self) def createMenu(self): # Creating a root menu to insert all the sub menus root_menu = Menu(self.root) self.root.config(menu=root_menu) # Creating sub menus in the root menu file_menu = Menu( root_menu) # it intializes a new sub menu in the root menu root_menu.add_cascade( label="File", menu=file_menu) # it creates the name of the sub menu file_menu.add_command(label="Open .csv file", command=self.eh.askOpenFileName) file_menu.add_separator( ) # it adds a line after the 'Open files' option file_menu.add_command(label="Exit", command=self.root.destroy) # creting another sub menu predict_menu = Menu(root_menu) root_menu.add_cascade(label="Predict", menu=predict_menu) predict_menu.add_command(label="Linear Regression", command=self.eh.linearRegression) predict_menu.add_command(label="Neural Network", command=self.eh.function) def createTemplate(self): # create all of the main containers header_frame = Frame(self.root, bg=self.__header_bg, width=self.__interfaceWidth, height=40, pady=3) content_frame = Frame(self.root, width=self.__interfaceWidth, height=60, pady=3) footer_frame = Frame(self.root, width=self.__interfaceWidth, height=40, pady=3) footer_frame2 = Frame(self.root, width=self.__interfaceWidth, height=40, pady=3) footer_frame3 = Frame(self.root, width=self.__interfaceWidth, height=40, pady=3) # layout all of the main containers self.root.grid_rowconfigure(1, weight=1) self.root.grid_columnconfigure(0, weight=1) header_frame.grid(row=0, sticky="ew") content_frame.grid(row=1, sticky="nsew") footer_frame.grid(row=3, sticky="ew") footer_frame2.grid(row=4, sticky="ew") footer_frame3.grid(row=5, sticky="ew") # create the content widgets content_frame.grid_rowconfigure(0, weight=1) content_frame.grid_columnconfigure(0, weight=1) self.cnt_left_frame = Frame(content_frame, width=int(self.__interfaceWidth * 0.4), padx=2, pady=2) self.cnt_mid_frame = Frame(content_frame, width=int(self.__interfaceWidth * 0.2), padx=2, pady=2) self.cnt_right_frame = Frame(content_frame, width=int(self.__interfaceWidth * 0.4), padx=2, pady=2) self.cnt_left_frame.grid(row=0, column=0, sticky="nsew") self.cnt_mid_frame.grid(row=0, column=1, sticky="nsew") self.cnt_right_frame.grid(row=0, column=2, sticky="nsew") self.cnt_left_frame.grid_propagate(False) self.cnt_mid_frame.grid_propagate(False) self.cnt_right_frame.grid_propagate(False) # Create Labels in Header intro_label = Label(header_frame, text="Welcome to My Analytic Solver!", bg=self.__header_bg) intro_label.grid(row=0, sticky='nw') intro_label2 = Label( header_frame, text="Please open CSV file, then choose method to run", bg=self.__header_bg) intro_label2.grid(row=1, sticky='nw') # create the widgets for the footer3 frame file_label = Label(footer_frame3, text='File: ') self.filename_label = Label(footer_frame3, text=None, wraplength=300) running_label = Label(footer_frame3, text='Running: ') self.runningname_label = Label(footer_frame3, text=None) # layout the widgets in the footer3 frame file_label.grid(row=0, column=0, sticky='nw') self.filename_label.grid(row=0, column=1, sticky='nw') running_label.grid(row=1, column=0, sticky='nw') self.runningname_label.grid(row=1, column=1, sticky='nw') def promptAlertForCSV(self): mb.showinfo("Alert Message", "Please select a .CSV file") self.eh.askOpenFileName() def setFileName(self, fileName): # take .csv file only if (fileName): if fileName[-4:] == '.csv': self.filename_label.config( text=fileName) # assign .csv file into fileName Label else: # Wrong file, redo self.promptAlertForCSV() else: pass # Cancel selected def getFileName(self): return self.filename_label['text'] def setRunningName(self, running): self.runningname_label.config(text=running) def getRunningName(self): return self.runningname_label['text'] def checkRequirements(self): # Check to make sure .CSV is selected # currently, just need .csv filename else returns default None=False return self.getFileName() def createLinearRegression(self, variables_list): # Weight template self.cnt_left_frame.grid_columnconfigure(0, weight=1) self.cnt_mid_frame.grid_columnconfigure(0, weight=1) self.cnt_right_frame.grid_columnconfigure(0, weight=1) self.cnt_left_frame.grid_rowconfigure(1, weight=1) self.cnt_mid_frame.grid_rowconfigure(0, weight=7) self.cnt_mid_frame.grid_rowconfigure(3, weight=14) self.cnt_mid_frame.grid_rowconfigure(6, weight=9) self.cnt_right_frame.grid_rowconfigure(1, weight=1) self.cnt_right_frame.grid_rowconfigure(3, weight=1) # Create Variables List __variable_label = Label(self.cnt_left_frame, text="Variables", bg=self.__ListBoxLabel_bg) __variable_label.grid(row=0, sticky='nwe') self.variables_lb = Listbox(self.cnt_left_frame, selectmode='extended') for variable in variables_list: self.variables_lb.insert('end', variable) self.variables_lb.grid(row=1, sticky='nwe') # Create Add Selected Button self.addSelected_btn = Button(self.cnt_mid_frame, text=">>>", command=self.eh.addSelectedVariables) self.addSelected_btn.grid(row=1) # Create Remove Selected Button self.removeSelected_btn = Button( self.cnt_mid_frame, text="<<<", command=self.eh.removeSelectedVariables) self.removeSelected_btn.grid(row=2) # Create Selected Variables List __selected_label = Label(self.cnt_right_frame, text="Selected", bg=self.__ListBoxLabel_bg) __selected_label.grid(row=0, sticky='nwe') self.selectedVariables_lb = Listbox(self.cnt_right_frame, selectmode='extended') self.selectedVariables_lb.grid(row=1, sticky='nwe') # Create Add Categorical Button self.addCategorical_btn = Button( self.cnt_mid_frame, text=">>>", command=self.eh.addCategoricalVariables) self.addCategorical_btn.grid(row=4) # Create Remove Categorical Button self.removeCategorical_btn = Button( self.cnt_mid_frame, text="<<<", command=self.eh.removeCategoricalVariables) self.removeCategorical_btn.grid(row=5) # Create Categorical Variables List __categorical_label = Label(self.cnt_right_frame, text="Categorical", bg=self.__ListBoxLabel_bg) __categorical_label.grid(row=2, sticky='nwe') self.categoricalVariables_lb = Listbox(self.cnt_right_frame, selectmode='extended') self.categoricalVariables_lb.grid(row=3, sticky='nwe') # Create Add Output Button self.addOutput_btn = Button( self.cnt_mid_frame, text=">>>", command=lambda: self.eh.addOutputVariables(True)) self.addOutput_btn.grid(row=7) # Create Remove Output Button self.removeOutput_btn = Button( self.cnt_mid_frame, text="<<<", command=lambda: self.eh.removeOutputVariables(True)) self.removeOutput_btn.grid(row=8) # Create Output Entry __output_label = Label(self.cnt_right_frame, text="Output", bg=self.__ListBoxLabel_bg) __output_label.grid(row=4, sticky='nwe') self.outputVariables_lb = Listbox(self.cnt_right_frame, height=10) self.outputVariables_lb.config(height=0) self.outputVariables_lb.grid(row=5, sticky='nwe') def getVariablesLB(self): return self.variables_lb def appendVariablesLB(self, variable): self.variables_lb.insert('end', variable) def refreshVariablesLB(self, variables_list): # Clear List Box self.variables_lb.delete(0, 'end') # Add variables_list for variable in variables_list: self.variables_lb.insert('end', variable) def getSelectedVariablesLB(self): return self.selectedVariables_lb def appendSelectedVariablesLB(self, selected): self.selectedVariables_lb.insert('end', selected) def refreshSelectedVariablesLB(self, selected_list): # Clear List Box self.selectedVariables_lb.delete(0, 'end') # Add selected_list for selected in selected_list: self.selectedVariables_lb.insert('end', selected) def getCategoricalVariablesLB(self): return self.categoricalVariables_lb def appendCategoricalVariablesLB(self, categorical): self.categoricalVariables_lb.insert('end', categorical) def refreshCategoricalVariablesLB(self, categorical_list): # Clear List Box self.categoricalVariables_lb.delete(0, 'end') # Add selected_list for categorical in categorical_list: self.categoricalVariables_lb.insert('end', categorical) def getOutputVariablesLB(self): return self.outputVariables_lb def appendOutputVariablesLB(self, output): self.outputVariables_lb.insert('end', output) def refreshOutputVariablesLB(self, output_list): # Clear List Box self.outputVariables_lb.delete(0, 'end') # Add selected_list for output in output_list: self.outputVariables_lb.insert('end', output) def close(self): self.root.destroy() def run(self): # Create Menu + Template self.createMenu() self.createTemplate() # Run listening for events self.root.mainloop()
import psycopg2 from eventHandler import EventHandler import sys import json handler = EventHandler() for line in sys.stdin: try: if line == '' or line == '\n': break inp = json.loads(line) handler.Event(inp) except (Exception) as error: print({"status": "ERROR", 'debug': error})
class UIMainMenu(UIMatch): def __init__(self): self.eventHandler = EventHandler() super(UIMainMenu, self).__init__(9, self.eventHandler) #We tell the button to draw to a dummy screen so it does not appear self.winScreen.primary_button.screen = pygame.Surface((0, 0)) self.nineByNine = UIMessage(self.screen, self.screen, "9x9", self.FONT, self.BASELINE_GRID, self.MESSAGE_FONTSIZE, pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25, self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR, self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select", None, 0.35, 0.05, self.eventHandler) self.thirteenByThirteen = UIMessage( self.screen, self.screen, "13x13", self.FONT, self.BASELINE_GRID, self.MESSAGE_FONTSIZE, pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25, self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR, self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select", None, 0.35, 0.35, self.eventHandler) self.nineteenByNineteen = UIMessage( self.screen, self.screen, "19x19", self.FONT, self.BASELINE_GRID, self.MESSAGE_FONTSIZE, pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25, self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR, self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select", None, 0.35, 0.65, self.eventHandler) def draw(self): self.update([[]], 0, 300, 300, 0, 0, (0, 0)) self.nineByNine.update() self.thirteenByThirteen.update() self.nineteenByNineteen.update() pygame.display.update() def mainLoop(self): self.draw() self.exit = False while self.exit == False: self.lookForInput() def lookForInput(self): self.eventHandler.update() if self.eventHandler.hasQuit(): self.exit = True self.quit() if self.nineByNine.primary_button.wasPressed(): self.quit() self.match = Match(9) self.match.matchLoop() self.exit = True elif self.thirteenByThirteen.primary_button.wasPressed(): self.quit() self.match = Match(13) self.match.matchLoop() self.exit = True elif self.nineteenByNineteen.primary_button.wasPressed(): self.quit() self.match = Match(19) self.match.matchLoop() self.exit = True
class Engine(DirectObject): """The engine class sets up the holders for game GameObjects and starts the parser that runs through the [name].egg """ def __init__(self, _main): print "Engine - init >>>" log.info("Engine - init >>>") # Main ref self.main = _main self.settings = Settings() self.graphicMgr = GraphicManager(self.settings) self.audioMgr = AudioManager() self.lng = Language(self.settings) self.lng.setup(self.settings) ### Bools ### # Gets set if we have a player character to work with. self.hasPlayer = False ### Bools END ### ### Setup Engine Holders ### self.__resetObjects() ### Engine Holders END ### # Setup Bullet Physics #? We could save this somewhere else i guess? self.bulletWorld = BulletWorld() self.bulletWorld.setGravity( Vec3(self.settings.gravity_x, self.settings.gravity_y, self.settings.gravity_z)) # Init Factory self.factory = Factory(self) # Debug node self.debugNP = None def start(self): # Controls Physics and other engine related Things # Init Input self.inputHandler = InputHandler(self) self.inputHandler.start() # Event HAndler self.eventHandler = EventHandler(self) self.eventHandler.start() # Init Camera self.cameraHandler = CameraHandler(self, "TPS") # Start Engine Loop taskMgr.add(self.engineLoop, "Engine_Loop") def stop(self): taskMgr.remove("Engine_Loop") self.unloadLevel() self.__resetObjects() self.inputHandler.stop() del(self.inputHandler) self.eventHandler.stop() del(self.eventHandler) self.cameraHandler.stop() del(self.cameraHandler) render.clearLight() base.messenger.send("Quit") def unloadLevel(self): self.__removeObjects() def loadLevel(self, levelName): # Parse the .egg file self.factory.parseLevelFile(levelName) def __resetObjects(self): # Create Game ObjectType Holders these hold the instances self.GameObjects = {} self.GameObjects["player"] = None self.GameObjects["level"] = {} self.GameObjects["object"] = {} self.GameObjects["light"] = {} self.GameObjects["sensor"] = {} # Create Render Object Holders for sorting stuff in sceneG. # nodepaths self.RenderObjects = {} self.BulletObjects = {} # none visual self.BulletObjects["main"] = render.attachNewNode("Bullet_main") self.BulletObjects["player"] = self.BulletObjects["main"].attachNewNode("Bullet_player") self.BulletObjects["level"] = self.BulletObjects["main"].attachNewNode("Bullet_level") self.BulletObjects["object"] = self.BulletObjects["main"].attachNewNode("Bullet_object") self.BulletObjects["sensor"] = self.BulletObjects["main"].attachNewNode("Bullet_sensor") # Visuals self.RenderObjects["player"] = render.attachNewNode("Render_player") self.RenderObjects["level"] = render.attachNewNode("Render_level") self.RenderObjects["object"] = render.attachNewNode("Render_object") self.RenderObjects["light"] = render.attachNewNode("Render_light") def __removeObjects(self): for name, objects in self.GameObjects.items(): if name == "player": objects.remove() continue for name, obj in objects.items(): obj.remove() def showBulletDebug(self): """Show bullet Debug""" # Bullet DEBUG debugNode = BulletDebugNode('Debug') debugNode.showWireframe(True) debugNode.showConstraints(False) debugNode.showBoundingBoxes(False) debugNode.showNormals(False) self.debugNP = render.attachNewNode(debugNode) self.debugNP.show() self.bulletWorld.setDebugNode(self.debugNP.node()) def hideBulletDebug(self): """Hide the debug stuff""" self.debugNP.hide() def engineLoop(self, task): """Handle Engine Related Tasks""" dt = globalClock.getDt() # Handle Physics self.bulletWorld.doPhysics(dt) if self.hasPlayer: self.inputHandler.update(dt) self.cameraHandler.update(dt) self.GameObjects["player"].setBasicMovement(dt) self.GameObjects["player"].startGhostContactTester(dt) self.GameObjects["player"].startContactTester(dt) return task.cont
def main(self): # init game and graphic pygame.init() pygame.display.init() # init menu and event taken self.menu = MenuHandler() handler = EventHandler(self.menu) while True: # handle all the user inputs... for event in pygame.event.get(): if event.type == QUIT: raise SystemExit if event.type == MOUSEBUTTONUP: if handler.mode == self.MENU: handler.processMenuClick(pygame.mouse.get_pos()) # handle back to menu event elif handler.game.back['rect'].collidepoint(pygame.mouse.get_pos()): self.menu = MenuHandler() handler = EventHandler(self.menu) elif handler.game.done: if handler.game.again['rect'].collidepoint(pygame.mouse.get_pos()): handler.game.done = False handler.game=Game(handler.mode) elif handler.mode ==self.AUTO1: if handler.game.dialog['rect'].collidepoint(pygame.mouse.get_pos()): handler.moreInput = True handler.trials = True else: pass elif handler.mode ==self.AUTO2: if handler.game.dialog['rect'].collidepoint(pygame.mouse.get_pos()): handler.moreInput = True handler.trials = True elif handler.game.dialog2['rect'].collidepoint(pygame.mouse.get_pos()): handler.moreInput = True handler.trials = False else: pass if event.type == KEYDOWN and handler.moreInput: if handler.mode == self.AUTO1 or handler.mode ==self.AUTO2: if handler.trials == True: handler.processKeyEvent(event.key,0) elif handler.trials == False: handler.processKeyEvent(event.key,1) else: pass
class TCPClient(object): def __init__(self): from messages import Messages messages = Messages() self.s = socket(AF_INET, SOCK_STREAM) self.s.connect((messages.getValue("socket", "host"), int(messages.getValue("socket", "port")))) def __del__(self): self.s.close() ''' result = TCPClient().send(([DBUtils.method_name], 元祖类型作为sql参数)) ''' def send(self, params, callback=None): self.s.send(dumps(params)) result = loads(self.s.recv(1024)) if callback: # callback(result) t = Thread(target=callback, args=(result, )) t.start() return result if __name__ == '__main__': from eventHandler import EventHandler eventHandler = EventHandler() eventHandler.openMainWindow()
from pathlib import Path from time import sleep from watchdog.observers import Observer from eventHandler import EventHandler watch_path = Path.home() / 'Desktop' organised_path = Path.home() / 'Desktop/Organiser' event_handler = EventHandler(watch_path=watch_path, organised_path=organised_path) observer = Observer() observer.schedule(event_handler, f'{watch_path}', recursive=True) observer.start() try: while True: sleep(60) except KeyboardInterrupt: observer.stop() observer.join()
def _refresh(self): EventHandler._refresh(self) self.__calculateRelPos()
def setPos(self, x, y): EventHandler.setPos(self, x, y)
def _destroy(self): #self.getUserData().slideHide() EventHandler._destroy(self)
import pygame as pg from player import Player from eventHandler import EventHandler menu_running = True game_running = False width = 1280 height = 720 FPS = 60 pg.init() pg.display.set_caption("Name of game") sc = pg.display.set_mode((width, height)) eventHandle = EventHandler(game_running, menu_running) clock = pg.time.Clock() pg.display.update() player = Player(20, 20, pg) pg.mixer.init() # light shade of the button color_light = (170, 170, 170) # dark shade of the button color_dark = (100, 100, 100) # defining a font smallfont = pg.font.SysFont('Corbel', 35) # this font text = smallfont.render('start game', True, (255, 255, 255)) while True: while eventHandle.menu: clock.tick(FPS) mouse = pg.mouse.get_pos() eventHandle.setInputs(events=pg.event.get(), pg=pg, mouse=mouse)
class Game(object): def __init__(self, playerNames): self.logicHandler = LogicHandler() self.eventHandler = EventHandler() self.players = [] self.turns = 0 self.jsonResponse = {} for playerName in playerNames: objective = self.logicHandler.get_random_objective() self.players.append(Player(playerName, objective)) def handleAction(self, playerName, action, options): if self.getCurrentTurnPlayerName() != playerName: print "Not your turn! Player's " + str(self.getTurns()/2) + " turn." return False self.affectedPlayers = [] player = self.getPlayerWithName(playerName) if player == None: print "Cannot find player!" return False self.jsonResponse = None if action is Action.TradeRequest: print "trade offer" #options contains targetPlayerNames, resourceOffer, resourceRequest targetPlayerNames = options["targetPlayerNames"] resourcesOffer = options["offer"] resourcesRequest = options["want"] if not targetPlayerNames or not resourcesOffer or not resourcesRequest: return False targetPlayers = [] for name in targetPlayerNames: targetPlayer = self.getPlayerWithName(name) targetPlayers.append(targetPlayer) if self.logicHandler.ingredient_suffice_to_trade(player, resourcesOffer): self.currentTrade = Trade(player, resourcesOffer, resourcesRequest, targetPlayers) self.affectedPlayers.append(player) for playerName in targetPlayerNames: targetPlayer = self.getPlayerWithName(playerName) self.affectedPlayers.append(targetPlayer) makeTradeTemplateJson(self.currentTrade) return True else: return False if action is Action.TradeAccept: print "Trade accept" #options contains tradeId tradeId = options["tradeId"] if not self.isTradeValidWithIdAndName(tradeId, player.get_name()): return False if self.logicHandler.accept_trade(player, self.currentTrade): self.currentTrade.set_player_responded(player.get_name()) self.affectedPlayers.append(player) #player who accept the trade self.affectedPlayers.append(self.currentTrade.get_initiator()) self.makeUpdateTemplateJson() return True else: return False elif action is Action.TradeDeny: print "trade deny" #options contains tradeId tradeId = options["tradeId"] if not self.isTradeValidWithIdAndName(tradeId, player.get_name()): return False self.currentTrade.set_player_responded(player.get_name()) return True elif action is Action.TradeWithBank: print "trade with bank" #options contains resourcesOffer, resourcesRequest bankMultiplier = self.eventHandler.getBankMultiplier() if self.logicHandler.trade_with_bank(player, options["offer"], options["want"], bankMultiplier): self.affectedPlayers.append(player) self.makeUpdateTemplateJson() return True else: return False elif action is Action.Build or action is Action.UpgradeResourceGenerator: print "Build or upgrade resouce generator" #options contains generatorName if self.logicHandler.build(player, options["target"]): self.affectedPlayers.append(player) self.makeUpdateTemplateJson() return True else: return False elif action is Action.Gather: print "gather" multipliers = self.eventHandler.getGeneratorMultipliers() if self.logicHandler.gather(player, multipliers): self.affectedPlayers.append(player) self.makeUpdateTemplateJson() return True else: return False elif action is Action.Destroy: #options contains targetPlayerName , buildingName print "destroy" targetPlayer = self.getPlayerWithName(options["to"]) if self.logicHandler.destroy(player, targetPlayer, options["target"]): self.affectedPlayers.append(player) self.affectedPlayers.append(targetPlayer) self.makeUpdateTemplateJson() return True else: return False elif action is Action.UpgradeResource: print "upgrade resource" #options contains resourceType if self.logicHandler.upgrade_resource(player, options["target"]): self.affectedPlayers.append(player) self.makeUpdateTemplateJson() return True else: return False else: print("error action") return False def isTradeValidWithIdAndName(self, tradeId, playerName): if not tradeId or tradeId != self.currentTrade.get_id() or \ playerName not in self.currentTrade.get_target_players_name(): return False if self.currentTrade.get_is_trade_over(): print("trade is over") return False return True def updateEventAndGetUpcomingEvents(self): self.eventHandler.randomUpcomingEvent() currentEvents = self.eventHandler.getUpcomingEvents() def getPlayerWithName(self, name): for player in self.players: if player.get_name() == name: return player print "player not found" return None def playerLeft(self, player_name): for player in self.players: if (player_name == player.get_name()): self.players.remove(player) break; def getAffectedPlayersSummaries(self): affectedPlayerSummaries = {} for player in self.affectedPlayers: playerSummary = {} resources = player.get_resources() for res, count in resources.items(): playerSummary[res.name] = count generator = player.get_generators() for gen, count in generator.items(): playerSummary[gen.name] = count affectedPlayerSummaries[player.get_name()] = playerSummary return affectedPlayerSummaries def getAllPlayersSummaries(self): allPlayerSummaries = {} for player in self.players: playerSummary = {} resources = player.get_resources() for res, count in resources.items(): playerSummary[res.name] = count generator = player.get_generators() for gen, count in generator.items(): playerSummary[gen.name] = count allPlayerSummaries[player.get_name()] = playerSummary return allPlayerSummaries def getGeneratorsAndBankMultipliers(self): multipliers = {} for key, mutliplier in self.eventHandler.getGeneratorMultipliers.items(): mutliplier[key.name] = multipliers multipliers["bank"] = self.eventHandler.getBankMultiplier() return multipliers def getTradeId(self): return self.currentTrade.get_id() def getIsTradeOver(self): return self.currentTrade.get_is_trade_over() def getTurns(self): return self.turns def increaseTurns(self): self.turns += 1 def setTurns(self, turns): self.turns = turns def getCurrentTurnPlayerName(self): return self.players[(self.getTurns()/2)].get_name() def makeUpdateTemplateJson(self): json = {} json['action'] = "Update" json['update_res'] = self.getAffectedPlayersSummaries() self.jsonResponse = json def makeTradeTemplateJson(self, trade): json = {} json['action'] = "TradeRequest" json['from'] = trade.get_initiator() json['to'] = trade.get_target_players_name() json['want'] = trade.get_resources_request() json['offer'] = trade.get_resources_offer() json['tid'] = trade.get_id() self.jsonResponse = json def getJsonResponse(self): return self.jsonResponse
class EnemyInvasion: def __init__(self): pygame.init() pygame.display.set_caption('enemy invasion') self.main_clock = pygame.time.Clock() self.background_color = ss.screen_background_color self.screen = pygame.display.set_mode(ss.screen_size) self.ship: Ship = Ship(self.screen) self.enemyFleet = EnemyFleet(self.screen, self.ship) self.eventHandler = EventHandler() self.add_events() def add_events(self): self.eventHandler.add_event(pygame.QUIT, lambda event: sys.exit(0)) move = { pygame.K_q: sys.exit, pygame.K_LEFT: self.ship.move_left, pygame.K_RIGHT: self.ship.move_right, pygame.K_SPACE: self.ship.shot } self.eventHandler.add_event( pygame.KEYDOWN, lambda event: move.get(event.key, lambda: None)()) stop_move = { pygame.K_LEFT: self.ship.stop_move_left, pygame.K_RIGHT: self.ship.stop_move_right } self.eventHandler.add_event( pygame.KEYUP, lambda event: stop_move.get(event.key, lambda: None) ()) def check_collision(self): # #pygame.sprite.groupcollide(self.ship.bullets_group, self.enemyFleet, lambda i: i.set_ready(), True) for bullet, enemy in pygame.sprite.groupcollide( self.ship.bullets_group, self.enemyFleet, False, False).items(): # only first enemy has been shot will die. enemy[0].die() bullet.set_ready() def update_screen(self): # redraw the screen. self.screen.fill(self.background_color) # draw bullets. self.ship.draw_bullets() self.ship.bullets_group.update() # draw ship in screen. self.ship.draw() # #self.enemyFleet.draw(self.screen) self.enemyFleet.draw_enemies() self.enemyFleet.update() self.check_collision() self.enemyFleet.schedule() # make the most recently drawn screen visible. pygame.display.flip() def start(self): while True: self.eventHandler.check_events(pygame.event.get()) self.update_screen() # control the game speed by 40 iteration per second. self.main_clock.tick(170)
class Match: def __init__(self, size=9): self.players = [Player('B', 300), Player('W', 300)] self.currentPlayer = 0 self.board = Board(size) self.territories = Board(size) self.previousBoard = self.board.getMatrix() self.currentBoard = self.board.getMatrix() self.cursor = Cursor(self.board) self.attemptedPlace = False self.handler = EventHandler() self.UI = UIMatch(size, self.handler) self.newGame = False self.exit = False ''' Evaulates one turn, the return value indictates if the match should end ''' def playTurn(self): stonePlaced = False self.players[self.currentPlayer].passed = False if self.board.noPlayableMoves(self.players[self.currentPlayer].colour): print("No possible moves, passing...") self.players[self.currentPlayer].passed = True while (not stonePlaced): if self.end == True: break if self.players[self.currentPlayer].time <= 0: self.players[self.currentPlayer].passed = True self.attemptedPlace = False self.lookForInput() self.UI.update(self.currentBoard, self.currentPlayer, self.players[0].time, self.players[1].time, self.players[0].prisoners, self.players[1].prisoners, self.cursor.coordinates) if self.players[self.currentPlayer].passed == True: break if self.players[self.currentPlayer].resigned == True: break if self.attemptedPlace == True: if self.players[self.currentPlayer].placeStone( self.board, self.cursor.coordinates, self.previousBoard) == True: break self.currentPlayer = (self.currentPlayer + 1) % len(self.players) self.previousBoard = self.currentBoard self.currentBoard = self.board.getMatrix() ''' The main loop of the match ''' def matchLoop(self): self.UI.update(self.currentBoard, self.currentPlayer, self.players[0].time, self.players[1].time, self.players[0].prisoners, self.players[1].prisoners, self.cursor.coordinates) self.end = False lastTurnPassed = False while (not self.end): self.playTurn() if self.players[0].passed == True and\ self.players[1].passed ==True: blackScore = self.findScore(self.players[0]) whiteScore = self.findScore(self.players[1]) if whiteScore == blackScore: text = "Scores tied at {}".format(whiteScore) self.UI.drawEnd(text) self.end = True if whiteScore > blackScore: text = "White beats black with {} to {}.".format( whiteScore, blackScore) self.UI.drawEnd(text) if whiteScore < blackScore: text = "Black beats white with {} to {}.".format( blackScore, whiteScore) self.UI.drawEnd(text) self.end = True if self.players[0].resigned == True: self.UI.drawEnd("Black quit, white wins") self.end = True if self.players[1].resigned == True: self.UI.drawEnd("White quit, black wins") self.end = True while self.newGame == False and self.exit == False: self.lookForInput() self.UI.quit() if self.newGame == True: newMenu = UIMainMenu() newMenu.mainLoop() ''' Gives the current score of a player ''' def findScore(self, player): self.updateTerritory() score = player.prisoners for group in self.territories.groups: if group.colour == player.colour: score = score + len(group.coordinates) return score ''' updates self.territories to represent the current state of board ''' def updateTerritory(self): for x in range(self.board.size): for y in range(self.board.size): if self.board.isEmpty((x,y)) and \ self.territories.isEmpty((x,y)): newGroup = Group("u", {(x, y)}) self.territories.addToGroups(newGroup) self.evaluateTerritory((x, y), newGroup) ''' called recursively by updateTerritory() to evaluate a territory group ''' def evaluateTerritory(self, position, group): for neighbour in self.territories.neighbours(position): if self.territories.isEmpty(neighbour): if self.board.isEmpty(neighbour): newGroup = Group(group.colour, {neighbour}) self.territories.addToGroups(newGroup) group.mergeGroup(newGroup, self.territories) self.evaluateTerritory(neighbour, group) elif self.board.getGroup(neighbour).colour != group.colour: if group.colour == "u": group.colour = self.board.getGroup(neighbour).colour else: group.colour = "n" ''' Looks for any of the allowed inputs to any resolves the relvent action ''' def lookForInput(self): self.handler.update() if self.players[self.currentPlayer].time > 0: self.players[ self.currentPlayer].time -= self.handler.getTimePassed() if self.handler.hasQuit(): self.end = True self.exit = True if self.UI.winScreen.primary_button.wasPressed() and\ self.end == True: self.newGame = True if self.currentPlayer == 0: if self.UI.blackPlayer.quitButton.wasPressed(): self.players[0].resigned = True if self.UI.blackPlayer.passButton.wasPressed(): self.players[0].passed = True if self.handler.keyWasPressed(pygame.K_SPACE): self.attemptedPlace = True if self.handler.keyWasPressed(pygame.K_a): self.cursor.moveBy((-1, 0)) if self.handler.keyWasPressed(pygame.K_d): self.cursor.moveBy((1, 0)) if self.handler.keyWasPressed(pygame.K_w): self.cursor.moveBy((0, -1)) if self.handler.keyWasPressed(pygame.K_s): self.cursor.moveBy((0, 1)) if self.currentPlayer == 1: if self.UI.whitePlayer.quitButton.wasPressed(): self.players[1].resigned = True if self.UI.whitePlayer.passButton.wasPressed(): self.players[1].passed = True if self.handler.keyWasPressed(pygame.K_BACKSPACE): self.attemptedPlace = True if self.handler.keyWasPressed(pygame.K_LEFT): self.cursor.moveBy((-1, 0)) if self.handler.keyWasPressed(pygame.K_RIGHT): self.cursor.moveBy((1, 0)) if self.handler.keyWasPressed(pygame.K_UP): self.cursor.moveBy((0, -1)) if self.handler.keyWasPressed(pygame.K_DOWN): self.cursor.moveBy((0, 1))
def _onAppChanged(self, event): if self.app == event.app: EventHandler._onAppChanged(self, event) # updates the bounds in the base class' method self._updateAppOverlays() self._resetOverlay() # Deal with sync'ed layout al,ar,at,ab = self.app.getBounds() ratio = self.app.getAspectRatio() ax,ay = self.app.getCenterX(),self.app.getCenterY() aw,ah = self.app.getWidth(),self.app.getHeight() print("_onAppChanged: something changed: ", self.app.isShared, al,ar,at,ab) if self.app.isShared and self.app.section and self.app.section.isShared and getMasterSiteMode(): localw = float ( self.app.section.getWidth() ) localh = float ( self.app.section.getHeight() ) localx = float ( self.app.section.getX() ) localy = float ( self.app.section.getY() ) ll = al / localw lr = ar / localw lt = at / localh lb = ab / localh lx = (ax-localx) / localw ly = (ay-localy) / localh lw = aw / localh lh = ah / localh # Get handlers on the remote site rgate, rdata = getGate( getMasterSite() ) # Get the remote display dimensions dremote = rdata.getDisplayInfo() remotew = float ( dremote.sageW ) remoteh = float ( dremote.sageH * 0.97) offsetx = 0.0 offsety = 0.0 # adjust remote dimensions to match local aspect ratio if (remotew/remoteh) >= (localw/localh): remotew = remoteh * localw / localh offsetx = ( float ( dremote.sageW ) - remotew ) / 2.0 else: remoteh = remotew * localh / localw offsety = ( float ( dremote.sageH * 0.97 ) - remoteh ) / 2.0 # Calculate the remote size rl = ll * remotew rr = lr * remotew rt = lt * remoteh rb = lb * remoteh rx = lx * remotew ry = ly * remoteh rw = lw * remoteh rh = lh * remoteh rl = rx - rw/2 rr = rx + rw/2 rt = ry + rh/2 rb = ry - rh/2 # center the remote windows if offsetx > 0.0: rl += offsetx rr += offsetx if offsety > 0.0: rb += offsety rt += offsety rb += float ( dremote.sageH * 0.03 ) rt += float ( dremote.sageH * 0.03 ) print("Remote position should be:", int(rl), int(rr), int(rb), int(rt)) # Get local information local_apps = getSageGate().getAppStatus() local_params = local_apps[str(event.app.appId)][1].split() directory, local_filename = os.path.split( local_params[-1] ) remote_apps = rgate.getAppStatus() running_apps = rdata.getRunningApps() winner = None for k in remote_apps: ra = remote_apps[k] rparams = ra[1].split() rdir, rfile = os.path.split( rparams[-1] ) if rfile == local_filename: winner = int(k) for v in running_apps.values(): remote_filename = v.title # print("One remote app", v.sailID, v.appName, v.title, v.windowId, v.appId, v.launcherId, v.zValue, v.configNum) if v.appName == event.app.appName: if v.appId == winner: print (" Remote app to control>", v.sailID) #rgate.sendAppEvent(APP_QUIT, v.sailID) rgate.resizeWindow(v.windowId, int(rl), int(rr), int(rb), int(rt))