def restart( self ): """ use to restart the app without ending it - also extend init parameters will be reloaded and the gui rebuilt args: zip ret: zip ... all sided effects """ #rint( "===================restart===========================" ) self.no_restarts += 1 if self.gui is not None: self.logger.info( self.app_name + ": restart" ) # self.post_to_queue( "stop", None , ( ) ) # need to shut down other thread # self.helper_thread.join() self.gui.close() importlib.reload( parameters ) # self.polling_mode = "off" #self._polling_fail = False # flag set if _polling in gui thread fails # self.is_first_gui_loop = True #self.ext_processing = None # built later from parameters if specified self.logger = None # set later none value protects against call against nothing # ----- parameters self.parmeters_x = "none" # name without .py for parameters #extension may ?? be replaced by command line args self.select_manager = None # populate in cb_change_select_type self.parameters = parameters.Parameters( ) self.starting_dir = os.getcwd() self.logger_id = self.parameters.logger_id # std name self.logger = self.config_logger() # std name AppGlobal.logger = self.logger AppGlobal.logger_id = self.logger_id self.prog_info() self.gui = gui.GUI( ) self.last_begin_dt, self.last_end_dt = self.gui.get_dt_begin_end() # after gui is built # now most of setup memory has been allocated -- may want to check in again later, save this value ?? process = psutil.Process(os.getpid()) # import psutil mem = process.memory_info().rss # convert to mega and format mem_mega = mem/( 1e6 ) msg = f"process memory = {mem_mega:10,.2f} mega bytes " print( msg ) # set up gui thread polling if delta > 0 self.logger.log( AppGlobal.force_log_level, msg ) self.polling_delta = self.parameters.polling_delta if self.polling_delta > 0: self.gui.root.after( self.polling_delta, self.polling_0 ) self.gui.run() self.logger.info( self.app_name + ": all done" )
def __init__(self): # pygame setup pygame.init() pygame.key.set_repeat(300, 30) self.screen = pygame.display.set_mode((1280, 720), pygame.SRCALPHA) self.screen.fill((255, 255, 255)) self.clock = pygame.time.Clock() # Create a white background self.background = pygame.Surface(self.screen.get_size(), pygame.SRCALPHA) self.background = self.background.convert() self.background.fill((255, 255, 255)) self.menu_background = copy.copy(self.background) self.menu_background.fill((57, 65, 101)) pygame.display.flip() # Setup classes self.world = World(self.screen) self.robot = RobotControl(self.screen, self.world) self.slam = SLAM(self.screen, self.robot) self.gui = gui.GUI(self.screen, self.world, self.robot, self.slam) self.font = pygame.font.Font(None, 30) self.state = 0 self.main()
def doSearch(): searchstring = None if len(sys.argv) > 1: try: param = sys.argv[1] if param.startswith('searchstring:'): import urllib searchstring = param.split(':', 1)[-1] searchstring = urllib.unquote_plus(searchstring) searchstring = searchstring.replace('\'', '') searchstring = searchstring.replace('"', '') except: searchstring = None if not searchstring: keyboard = xbmc.Keyboard('', LANGUAGE(32101), False) keyboard.doModal() if (keyboard.isConfirmed()): searchstring = keyboard.getText() if searchstring: params = {} import gui ui = gui.GUI("script-globalsearch-main.xml", CWD, "Default", searchstring=searchstring, params=params) ui.doModal() del ui sys.modules.clear()
def __init__(self): self.display = gui.GUI(self.root, self, self.board, self.player_turns) self.display.pack(side='top', fill='both', expand='true', padx=4, pady=4)
def _manage_shortcuts(self, group, defaultGroup, nolabels, groupname): homeWindow = xbmcgui.Window(10000) if homeWindow.getProperty("skinshortcuts-loading") and int( calendar.timegm(gmtime())) - int( homeWindow.getProperty("skinshortcuts-loading")) <= 5: return homeWindow.setProperty("skinshortcuts-loading", str(calendar.timegm(gmtime()))) import gui ui = gui.GUI("script-skinshortcuts.xml", CWD, "default", group=group, defaultGroup=defaultGroup, nolabels=nolabels, groupname=groupname) ui.doModal() del ui # Update home window property (used to automatically refresh type=settings) homeWindow.setProperty("skinshortcuts", strftime("%Y%m%d%H%M%S", gmtime())) # Clear window properties for this group, and for backgrounds, widgets, properties homeWindow.clearProperty("skinshortcuts-" + group) homeWindow.clearProperty("skinshortcutsWidgets") homeWindow.clearProperty("skinshortcutsCustomProperties") homeWindow.clearProperty("skinshortcutsBackgrounds")
def __init__(self): # Use a service account to authenticate firebase_admin.initialize_app( credentials.Certificate("service_account.json")) client = firestore.client() self.systems = client.collection("systems") self.event_flows = client.collection("event_flows") self.widgets = [] self.systems.on_snapshot(self.on_systems_change) self.server_doc = self.systems.document("server") self.state_doc = client.collection("state").document("state") self.deps_doc = client.collection("dependencies").document( "dependencies") self.state = {} self.state_doc.on_snapshot(self.on_state_change) # This variable statically stores what widget ID an event was sent to, if one was sent. It allows us to know # where the incoming event eventually went so that we can track it in the AR app. self.EVENT_SENT_TO: List[int] = [] # Set up the listener for changes to the server document self.server_doc.on_snapshot(self.on_change) # Start the GUI gui.GUI(self)
def Single_Velocity(): # Set goals to go to GOALS = [(0.5,0,2),(0,0.5,2),(-0.5,0,2),(0,-0.5,2)] # Define the quadcopters QUADCOPTER={'q1':{'position':[0,0,0],'orientation':[0,0,0],'L':0.3,'r':0.1,'prop_size':[10,4.5],'weight':1.2}} # Controller parameters CONTROLLER_PARAMETERS = {'Motor_limits':[4000,9000], 'Tilt_limits':[-10,10], 'Yaw_Control_Limits':[-900,900], 'Z_XY_offset':500, 'Linear_PID':{'P':[2000,2000,7000],'I':[0.25,0.25,4.5],'D':[50,50,5000]}, 'Linear_To_Angular_Scaler':[1,1,0], 'Yaw_Rate_Scaler':0.18, 'Angular_PID':{'P':[22000,22000,1500],'I':[0,0,1.2],'D':[12000,12000,0]}, } # Catch Ctrl+C to stop threads signal.signal(signal.SIGINT, signal_handler) # Make objects for quadcopter, gui and controller quad = quadcopter.Quadcopter(QUADCOPTER) gui_object = gui.GUI(quads=QUADCOPTER) ctrl = controller.Controller_PID_Velocity(quad.get_state,quad.get_time,quad.set_motor_speeds,params=CONTROLLER_PARAMETERS,quad_identifier='q1') # Start the threads quad.start_thread(dt=QUAD_DYNAMICS_UPDATE,time_scaling=TIME_SCALING) ctrl.start_thread(update_rate=CONTROLLER_DYNAMICS_UPDATE,time_scaling=TIME_SCALING) # Update the GUI while switching between destination poitions while(run==True): for goal in GOALS: ctrl.update_target(goal) for i in range(150): gui_object.quads['q1']['position'] = quad.get_position('q1') gui_object.quads['q1']['orientation'] = quad.get_orientation('q1') gui_object.update() quad.stop_thread() ctrl.stop_thread()
def main(): # Clear the screen, prepare the mainlopp, create graph_list, create graph_path os.system("clear") flag = True graph_path = "./graphs/" graph_list = os.listdir(graph_path) # Print welcome message including the premade graph information print ("Project Module #2: \n" "A*-GAC \n" "\n" "Premade problems are:") for i in range(len(graph_list)): print i, graph_list[i] print ("\n" "'Run 0-X' for premade problem \n" "'Exit' ends the script \n" "\n") # This is the mainloop - It reads input from the user and executes the commands while flag: the_input = raw_input(" > ") # Run a premade graph if the_input != "Run new" and the_input.startswith("Run"): # Get the correct premade graph and add its numbers to a list number = int(the_input[4:]) f = open(graph_path + str(graph_list[number]), "r") line_list = map(int, re.findall(r'\d+', f.readline())) # Structure the input from file f number_of_vertices = line_list[0] number_of_edges = line_list[1] vertices = [] edges = [] # Fill the vertices and edges, then close f for i in range(number_of_vertices): vertex = [] for word in f.readline().split(): vertex.append(float(word)) vertices.append(vertex) for j in range(number_of_edges): edge = map(int, re.findall(r'\d+', f.readline())) edges.append(edge) f.close() # Initialize run graph = Graph(nv=number_of_vertices, ne=number_of_edges, vertices=vertices, edges=edges) graph_gui = gui.GUI(graph=graph) _run_gui(graph_gui) # Exit the loop elif the_input == "Exit": flag = False
def onPlayBackStarted(self): if xbmc.getInfoLabel('Container.FolderPath').startswith(self.trigger): self.ui = gui.GUI( 'script-chatdialog-main.xml', xbmcaddon.Addon().getAddonInfo('path').decode('utf-8')) self.callback() self.ui.doModal() del self.ui
def __init__(self, starting_player=True): self.is_player_white = starting_player pieces = self.create_pieces() b = board.Board(pieces) self.g = g.GUI(b) self.ai = ai.AI(b, self.is_player_white) self.game_loop(b)
def test_gui(self): gui_test = gui.GUI(self.log) gui_test.set_console_log_button_states(True) gui_test.set_launch_tf2_button_state(True) for state in [i for i in range(5)]: gui.test_state(gui_test, state) gui_test.safe_update() self.assertEqual((gui_test.text_state, gui_test.bg_state, gui_test.fg_state, gui_test.class_state), (('Map: cp_catwalk_a5c (hosting)', 'Players: ?/?', 'Time on map: 2:39', '06:21 elapsed'), ('bg_modes/control-point', 77, 172), 'fg_modes/control-point', 'classes/pyro')) for state in [4 - i for i in range(5)]: gui.test_state(gui_test, state) gui_test.safe_update() self.assertEqual( (gui_test.text_state, gui_test.bg_state, gui_test.fg_state, gui_test.class_state), (("Team Fortress 2 isn't running", ), ('default', 0, 0), '', '')) gui_test.bottom_text_queue_state = "Queued for Casual" self.assertEqual(gui_test.set_bottom_text('queued', True), "Queued for Casual") self.assertEqual(gui_test.set_bottom_text('discord', True), "Can't connect to Discord") self.assertEqual(gui_test.set_bottom_text('discord', False), "Queued for Casual") self.assertEqual(gui_test.set_bottom_text('queued', False), "") gui_test.pause() gui_test.unpause() gui_test.enable_update_notification() gui_test.holiday() gui_test.menu_open_settings() gui_test.menu_about(silent=True) gui_test.update_checker.initiate_update_check(True) while not gui_test.update_checker.update_check_ready(): time.sleep(0.2) gui_test.handle_update_check( gui_test.update_checker.receive_update_check()) fg_image = gui_test.fg_image_load('tf2_logo', 120) self.assertEqual((fg_image.width(), fg_image.height()), (120, 120)) gui_test.scale = 2 gui_test.fg_image_load.cache_clear() fg_image = gui_test.fg_image_load('tf2_logo', 120) self.assertEqual((fg_image.width(), fg_image.height()), (240, 240)) with self.assertRaises(SystemExit): gui_test.menu_exit() gui_test.master.destroy()
def __init__(self, start, obstacles): """ initializer start: 3d-vector with the starting coordinates of the drone obestacles: list of 6d-vectors with the rectangular obstacles. format{pos_x, pos_y, pos_z, len_x, len_y, len_z} """ self.start = start self.obs = obstacles self.path = [] self.iteration_data = [] self.planReady = False self.iterRunGo = False self.pathIter = 0 self.goalIter = 0 self.QUADCOPTER = { 'q1': { 'position': start, 'orientation': [0, 0, 0], 'L': 0.175, 'r': 0.0665, 'prop_size': [8, 3.8], 'weight': 0.5, 'motorWeight': 0.035 } } # Controller parameters self.CONTROLLER_PARAMETERS = { 'Motor_limits': [2000, 12000], #4000,12000 'Tilt_limits': [-10, 10], 'Yaw_Control_Limits': [-900, 900], 'Z_XY_offset': 500, 'Linear_PID': { 'P': [300, 300, 7000], 'I': [0.03, 0.03, 6], 'D': [450, 450, 4200] }, 'Linear_To_Angular_Scaler': [1, 1, 0], 'Yaw_Rate_Scaler': 0.18, 'Angular_PID': { 'P': [22000, 22000, 1500], 'I': [0, 0, 1.2], 'D': [12000, 12000, 0] }, } # Make objects for quadcopter, gui and controller self.quad = quadcopter.Quadcopter(self.QUADCOPTER) self.gui_object = gui.GUI(quads=self.QUADCOPTER, obs=obstacles) self.ctrl = controller.Controller_PID_Point2Point( self.quad.get_state, self.quad.get_time, self.quad.set_motor_speeds, params=self.CONTROLLER_PARAMETERS, quad_identifier='q1') self.rrt = RRTStar(obstacle_list=self.obs)
def closeDialog(self): import gui mainUI = gui.GUI("script_linux_nm-main.xml", __cwd__, "default", msg=self.msg, first=False) self.close() del mainUI
def __init__(self): self.world = world.World() self.player = player.Player(self.world) self.player.place(10, 10) self.gui = gui.GUI(self, 100, 40) self.context = list() self.key = None
def __init__(self, gps_rate=None): # initialize objects self._gui = gui.GUI() self._buttons = buttons.Buttons(on_green=self.green_callback, on_blue=self.blue_callback, on_red=self.red_callback) self.rs = RobotState() print("The first state in the state machine is: %s" % rs.state) self._gps = gps.GPS()
def run(self): try: self.root = Tk.Tk() self.gui = gui.GUI(self.root, self.dcb, self.trainer, self.player) self.root.protocol('WM_DELETE_WINDOW', self.closed_window) self.root.mainloop() except BaseException: pass finally: self.closed_window()
def __init__(self): """ This starts the Tk framework up, instantiates the Model (a Counter object), instantiates the View (a MyFrame object), and starts the event loop that waits for the user to press a Button on the View. """ root = tkinter.Tk() self.model = tempconvert.TempConvert self.view = gui.GUI(self) self.view.mainloop() root.destroy()
def update(self): self.player.update() if not self.player.died: for e in self.world.enemies: e.update() if self.player.restart: self.info = info.InfoBar() self.world = world.World(50, 50, self.info, seed=time.time()) self.player = player.Player("Frederico", self.world) self.world.create_enemies() self.gui = gui.GUI(self.player)
def PIDExperiment(): # Set goals to go to GOALS_1 = [(0, -0.5, 0), (0, 0.5, 0)] # Define the quadcopters quad_list = [ quadcopter.Quadcopter([0, 0, 0], [0, 0, 0], 0.3, 0.1, [10, 4.5], 1.2) ] # Controller parameters # Catch Ctrl+C to stop threads signal.signal(signal.SIGINT, signal_handler) # Make objects for quadcopter, gui and controllers gui_object = gui.GUI(quads=quad_list) #quad = quadcopter.Quadcopter(quads=QUADCOPTERS) quad_manager = quadcopter.QuadManager(quad_list) ctrl1 = controller.Controller_PID_Velocity(quad_list[0].get_state, quad_manager.get_time, quad_list[0].set_motor_speeds, [4000, 9000], [-10, 10], [-900, 900], 500, { 'P': [300, 300, 7000], 'I': [0.04, 0.04, 4.5], 'D': [450, 450, 5000] }, [1, 1, 0], 0.18, { 'P': [22000, 22000, 1500], 'I': [0, 0, 1.2], 'D': [12000, 12000, 0] }) # Start the threads quad_manager.start_thread(dt=QUAD_DYNAMICS_UPDATE, time_scaling=TIME_SCALING) ctrl1.start_thread(update_rate=CONTROLLER_DYNAMICS_UPDATE, time_scaling=TIME_SCALING) # ctrl2.start_thread(update_rate=CONTROLLER_DYNAMICS_UPDATE,time_scaling=TIME_SCALING) # Update the GUI while switching between destination poitions update_rate = 0.01 while (run == True): for goal1 in GOALS_1: ctrl1.update_target(goal1) last_update = datetime.datetime.now() #ctrl2.update_target(goal2) #for i in range(10): while ((datetime.datetime.now() - last_update).total_seconds() < update_rate): for q in gui_object.quads: q.position = q.get_position() q.orientation = q.get_orientation() gui_object.update() quad_manager.stop_thread() ctrl1.stop_thread()
def __init__(self, gps_rate=None): # initialize objects self.stop_blink = threading.Event() self._gui = gui.GUI() self._buttons = buttons.Buttons(on_green=self.green_callback, on_blue=self.blue_callback, on_red=self.red_callback) self.rs = RobotState() print("The first state in the state machine is: %s" % self.rs.state) print("Mac Address: " + gma()) self._gps = gpsCode.GPS()
def __init__(self): try: self.loader = fileLoad.FileLoad() except IOError: messagebox.showerror('Error', 'Missing data files') else: root = tk.Tk() # root to contain GUI savedFilePath = self.loader.loadSavedFilePath( ) # user's file path for ISO self.gui = gui.GUI(self, root, savedFilePath, self.versionName) root.mainloop() # start GUI
def __init__(self,background_img,splat_img,food_no): self.gui = gui.GUI(splat_img) self.player = player.Player() self.background = pygame.image.load(os.path.join('images', background_img)).convert() self.foods = [] for x in range(food_no): x = food.Food() self.foods.append(x) self.time = 70 t = threading.Timer(1.0,self.countdown) t.start()
def run(self): self.parseArgs() # GUI, if -g option if self.args.g: self.gui = gui.GUI(self.shutdown) self.gui.start(self.logFiles) # Reader self.reader = self.readerFactory(self.args[0]) # Everything starts with my load method reactor.callWhenRunning(self.load) # GO! reactor.run()
def wc_main(): args = parse_test() if args.x: args.c = True args.w = True args.l = True args.a = True args.directory = "" gui.GUI(args) else: wc = WC(args) wc.main()
def chkFEED(self, user): log('chkFEED, user = '******'img' , {'class': 'ProfileAvatar-image'})[0].attrs['src'] twitterAlt = soup('img' , {'class': 'ProfileAvatar-image'})[0].attrs['alt'] twitterVer = True if soup.find(href='/help/verified') else False tweetTimes = soup('a' , {'class': 'tweet-timestamp js-permalink js-nav js-tooltip'}) tweetMsgs = soup('div' , {'class': 'js-tweet-text-container'}) tweetAtts = soup('div' , {'class': 'AdaptiveMediaOuterContainer'}) tweetStats = soup('span', {'class': 'ProfileTweet-actionCountForAria'}) twitterPin = len(soup('span' , {'class': 'js-pinned-text'})) > 0 tmpThumb = None tmpVideo = None tmpImage = None for idx, item in enumerate(tweetTimes): if idx == 0 and twitterPin == True and user.lower() in item.attrs['href'].lower(): continue elif self.incRetweets == True: break elif user.lower() in item.attrs['href'].lower(): break try: tmpAttach = tweetMsgs[idx]('a', {'class': 'twitter-timeline-link u-hidden'})[0].get_text() tmpImage = tweetAtts[idx].find('img').attrs['src'] if tmpAttach.startswith('pic.twitter.com') else None except: tmpImage = None try: tmpThumb = tweetAtts[idx]('div', {'class': 'PlayableMedia-container'}) tmpThumb = tmpThumb[0]('div', {'class': 'PlayableMedia-player'})[0] tmpThumb = re.findall("background-image:url(.*)'", str(tmpThumb))[0].replace("('",'') except: tmpThumb = None if tmpThumb is not None: tmpVideo = tmpThumb.replace('pbs.twimg.com/tweet_video_thumb/','video.twimg.com/tweet_video/').replace('.jpg','.mp4') tmpImage = tmpImage if tmpThumb is None else tmpThumb tweetTime = self.correctTime(tweetTimes[idx]["title"].encode("utf-8")) tweetMsg = self.cleanString((tweetMsgs[idx]('p' , {'class': 'TweetTextSize TweetTextSize--normal js-tweet-text tweet-text'})[0].get_text()).encode("utf-8")) tweetStats = [stat.get_text().encode("utf-8") for stat in tweetStats] tweetStats = [tweetStats[x:x+3] for x in xrange(0, len(tweetStats), 3)] tweetStats = tweetStats[idx] if len(tweetMsg) == 0: return # test # tmpImage = 'https://pbs.twimg.com/tweet_video_thumb/DOubaqGWAAEBPWn.jpg' # tmpVideo = 'https://video.twimg.com/tweet_video/DOubaqGWAAEBPWn.mp4' # test if getProperty('%s.%s.time' %(ADDON_ID,user)) != tweetTime: setProperty('%s.%s.time'%(ADDON_ID,user),tweetTime) ui = gui.GUI("%s.default.xml" %ADDON_ID,ADDON_PATH,"default",params=({'user':user,'video':tmpVideo,'image':tmpImage,'icon':twitterPic,'username':twitterAlt,'title':tweetMsg,'time':tweetTime,'stats':tweetStats,'verified':twitterVer})) ui.doModal() except Exception as e: log('chkFEED, failed! ' + str(e))
def main(args): """Hauptfenster, Hauptanwendung Initialisierung und Schliessen Signal anbinden""" app = QtGui.QApplication(args) win = gui.GUI() win.show() app.connect( app, # Sender-Widget Qt.SIGNAL('lastWindowClosed()'), # Signal app, # Empfaenger Qt.SLOT('quit()') # aktivierter Slot ) return app.exec_()
def __init__(self, isdebug): pygame.init() pygame.font.init() pygame.mixer.init() self.is_running = False self.to_move = [0, 0, 0] self.isdebug = isdebug '''GameInit''' frame_size = (gui.card_size[0] * 3, gui.card_size[1] * 2 + gui.height_interface_bottom + gui.height_interface_top ) # init frame print(frame_size) if os.uname().nodename == 'raspberrypi' and not self.isdebug: self.screen = pygame.display.set_mode( frame_size, pygame.FULLSCREEN | pygame.HWSURFACE | pygame.DOUBLEBUF) # display frame ,pygame.FULLSCREEN else: self.screen = pygame.display.set_mode( frame_size) # display frame ,pygame.FULLSCREEN self.clock = pygame.time.Clock() self.sound_no_money = pygame.mixer.Sound("../sounds/error0.wav") self.sound_chatter = pygame.mixer.Sound( "../sounds/chattering_teeth.wav") self.sound_win = pygame.mixer.Sound( "../sounds/win.wav") # init all sound effects self.interface = gui.GUI(self) # init GUI reel_rect = pygame.Rect(0, gui.height_interface_top, gui.card_size[0] * 3, gui.card_size[1] * 2) self.reel_screen = self.screen.subsurface( reel_rect) # define reel subsurface self.reel = [ model.Reel(self.reel_screen, 0), model.Reel(self.reel_screen, gui.card_size[0]), model.Reel(self.reel_screen, gui.card_size[0] * 2) ] # init all reels self.roll = [0, 0, 0] self.roll_speed = [0, 0, 0] self.result = [NO_RESULT, NO_RESULT, NO_RESULT] self.extra_rolls = 50 self.coinLock = Lock() self.coins = 0 pygame.mouse.set_visible(False) self.photo_seconds = 0 self.camera = cam.Camera() if os.uname( ).nodename == 'raspberrypi': # first check if the os is windows(windows doesn't provide uname) | os.name is not 'nt' and print('CoinThread started') from coins import CoinThread from trigger import TriggerThread self.triggerThread = TriggerThread(self) self.coinThread = CoinThread(self)
def setUp(self): # self.training_set = model.TrainingSets() # self.face_detector = fd.FaceDetector() # self.gui = gui.GUI() app = QtGui.QApplication('') win = gui.GUI() win.show() app.connect( app, # Sender-Widget Qt.SIGNAL('lastWindowClosed()'), # Signal app, # Empfaenger Qt.SLOT('quit()') # aktivierter Slot )
def main(): data_in = LaptopCamera() data_out = GameController() gui = g.GUI() autonomous_control = m.ML() gui.setDataIn(data_in) gui.setDataOut(data_out) gui.setAutonomousControl(autonomous_control) autonomous_control.setDataIn(data_in) #Empieza La GUI gui.start()
def start(self): pingur = threading.Thread(target=pinger.Pinger().timer,args=(self.sharedFile,0)) pingur.daemon=True pingur.start() g = threading.Thread(target=gui.GUI().p,args=(self.sharedFile,)) g.daemon=True g.start() status = threading.Thread(target=self.status_print) status.daemon=True status.start()