def __init__(self): self.s = None self.width = SCREEN_W self.height = SCREEN_H self.hwnd_context = sf.ContextSettings() self.hwnd_context.antialiasing_level = 4 self.hwnd = sf.RenderWindow(sf.VideoMode(self.width, self.height), "Tankz2D", sf.Style.DEFAULT, self.hwnd_context) self.hwnd.framerate_limit = 60 self.hwnd.vertical_synchronization = True self.state = STATE.IN_MENU self.turn = GameTurn() self.tank_sprites = [0] * 4 self.winner = -1 self.map_scroll = 0 for x in range(4): self.tank_sprites[x] = sf.Sprite(texture_manager.textures[x + 1]) self.tank_sprites[x].origin = (11, 6) self.tank_sprites[x].position = (SCREEN_W / 2, SCREEN_H / 2) self.tank_sprites[x].scale((16, 16)) try: with open('./data/cfg.yaml', 'r') as stream: self.cfg = yaml.safe_load(stream) except Exception as e: print(f'reading config failed: [{e}]') os._exit(-1) self.ui = GUI(self.cfg['ui']) self.ui.set_scene('main_menu') self.map = None self.map = GameMap(MAP_W, MAP_H) self.tanks = [] self.tank_id = 0 self.timer = sf.Clock() self.timer.restart() self.finished = False self.bg = Background(texture_manager.textures[TEXTURE.BACKGROUND]) self.landscape = sf.Sprite(texture_manager.textures[TEXTURE.LANDSCAPE]) self.think_callbacks = { STATE.IN_MENU: self.menu_callback, STATE.WAIT_FOR_START: self.wait_for_start_callback, STATE.IN_GAME: self.ingame_callback, STATE.RESULT: self.results_callback, } self.render_callbacks = { STATE.IN_MENU: self.menu_render_callback, STATE.WAIT_FOR_START: self.wait_for_start_render_callback, STATE.IN_GAME: self.ingame_render_callback, STATE.RESULT: self.results_render_callback } self.projectiles = [] self.cheat_active = False
def display_graph(self): gui = GUI() for edge in self.G.edges(): s = conversions.point_2_to_xy(edge[0]) t = conversions.point_2_to_xy(edge[1]) gui.add_segment(*s, *t) gui.MainWindow.show()
def __init__(self): self.parent_dir = abspath(join(dirname(__file__), "..")) self.binary_dir = join(self.parent_dir, "bin") if not isdir(self.binary_dir): mkdir(self.binary_dir) if not isfile(join(self.binary_dir, "engine.exe")): print("Error: Engine not found!") print("Place engine.exe in " + self.binary_dir) sys.exit() self.board: Chessboard = None self.analyzer: BoardAnalyzer = None self.bot: Bot = None # Instantiate the GUI self.interface = GUI(self.parent_dir, self.toggle_color, self.set_coordinates) self.interface.create_window() # Instantiate the scanner self.scanner = Scanner(self.parent_dir, self.interface) # Retrieve the coordinates of the board from mouse input self.scanner.retrieve_coordinates(self.set_coordinates) # Required main loop for any tkinter application self.interface.window.mainloop()
def display_cspace(self): gui = GUI() for he in self.cspace.edges(): s = conversions.point_2_to_xy(he.source().point()) t = conversions.point_2_to_xy(he.target().point()) gui.add_segment(*s, *t) gui.MainWindow.show()
def show_path(self, game, path): gui = GUI() if gui is not None: gui.update(game) # print "%s has hand" % self.name, self.info.hand gui.show_destinations(self.info.destinations) gui.show_path(path) raw_input("Continue?") gui.close()
def main(): gui = GUI(draw_orientation=False) rospy.init_node('gui_node') goal_sub = rospy.Subscriber('goal_pose', Pose, gui.handle_goal) arm_pose_sub = rospy.Subscriber('arm/link_poses', PoseArray, gui.handle_link_poses) rate = rospy.Rate(5) for i in range(5): rate.sleep() while not rospy.is_shutdown(): gui.redraw() rate.sleep()
def start(self): """ Displays the GUI frame. """ if self._system.get_settings().show_gui and not self.is_running(): self.frame = True app = QtWidgets.QApplication(sys.argv) self.gui = GUI(self._system) if self.is_speech_enabled: self.gui.enable_speech(True) # if not self._system._domain._xml_file is None: # self.gui.open_domain(self._system._domain) # self._system.start_system() sys.exit(app.exec_())
def __init__(self): self.si = SingleInstance(32092) self.settings = Settings('settings.json', DEFAULT_SETTINGS) self.fs_sync = FSSync() self.gui = GUI(self) self.mw_emit = self.gui.main_window.act.emit # TODO: Switch from mw_emit to mw_act self.mw_act = self.gui.main_window_act self.time_offsets = None self.sync_run = False self.sync_thread = None self.time_run = False self.time_thread = None self.live_sync_enabled = False self.now_source = "S" self.ntp_client = ntplib.NTPClient() self.ntp_delta = None self.offset = BasicTimeDelta()
def __init__(self, player): self.player = player self.gui = GUI() self.worlds = [] self.current_page = 'main_menu' self.pages = {} self.exit = False self.keys_pressed = [] keymap.add((pygame.K_ESCAPE,), self.quit)
def __init__(self): import ulogging as logging self.log = logging.getLogger("t-watch") self.log.setLevel(logging.DEBUG) self.log.debug("Starting LVGL") self.drv = driver(width=240, height=240) scr_style = lv.style_t() scr_style.set_bg_color(lv.STATE.DEFAULT, lv_colors.BLACK) lv.scr_act().add_style(lv.obj.PART.MAIN, scr_style) self.log.debug("starting splash screen") splash = Splashscreen() sleep(1) splash.set_label("Starting WiFi") try: from hardware.wifi import WiFi wifi = WiFi() wifi.connect() # # get CET time from NTP and set up the pcf8563 RTC # self.pcf8563 = self.drv.watch.rtc wifi.getTime() currentTime = wifi.cetTime() year = currentTime[0] month = currentTime[1] date = currentTime[2] hour = currentTime[3] minute = currentTime[4] second = currentTime[5] day = currentTime[6] month_short = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ] day_of_week_short = [ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" ] self.log.debug( " Setting RTC to %s %d. %s %02d %02d:%02d:%02d" % (day_of_week_short[day], date, month_short[month - 1], year, hour, minute, second)) self.pcf8563.set_datetime(currentTime) except: pass self.log.debug("Starting the power manager") if hasattr(self.drv, "watch"): print("Running on the twatch") self.powermgr = PowerManager(self.drv) splash.deinit() self.gui = GUI(self.drv)
def __init__(self): QCoreApplication.setOrganizationName('github.com/misdoro') QCoreApplication.setApplicationName('Battery tester') self.threadpool = QThreadPool() self.instr_thread() self.datastore = DataStore() signal.signal(signal.SIGTERM, self.terminate_process) signal.signal(signal.SIGINT, self.terminate_process) self.data_receivers = set() GUI(self)
class Game: def __init__(self, player): self.player = player self.gui = GUI() self.worlds = [] self.current_page = 'main_menu' self.pages = {} self.exit = False self.keys_pressed = [] keymap.add((pygame.K_ESCAPE,), self.quit) def add_world(self, setup): self.worlds.append(World(setup)) def check_events(self): for event in pygame.event.get(): if event.type == pygame.QUIT: quit() elif event.type == pygame.KEYDOWN: if self.gui.selected: if self.gui.selected.key_input(event.key): continue if event.key not in self.keys_pressed: self.keys_pressed.append(event.key) elif event.type == pygame.KEYUP: if event.key in self.keys_pressed: self.keys_pressed.remove(event.key) elif event.type == pygame.MOUSEBUTTONDOWN: mouse_pos = pygame.mouse.get_pos() for widget in self.gui.widgets: if widget.rect.collidepoint(mouse_pos): widget.select() for keys, action in keymap.keymap.items(): if all([True if key in self.keys_pressed else False for key in keys]): action() def main_loop(self): last_frame = time() while not self.exit: turn_time = time() for world in self.worlds: world.update() if turn_time - last_frame >= 1/config.FPS: self.pages[self.current_page].draw() if config.SCENT_VISIBLE: # ToDo: replace world below with self.player.world self.gui.draw_markers(world.markers) if not world.current_tick % 250: world.markers.update() self.gui.draw() self.gui.update() last_frame = time() self.check_events() def quit(self): if self.exit: pygame.quit() else: self.exit = True
def make_gui(board, main_controller, controllers, biosignal): app = QtWidgets.QApplication(sys.argv) main_scr = None if FeatureFlags.GUI: main_scr = GUI(board, biosignal, main_controller, controllers) main_scr.views.setCurrentIndex(1) if FeatureFlags.DEV_TOOLS: main_scr = DevTools(board, biosignal, main_controller, controllers) if main_scr is not None: main_scr.resize(500, 100) main_scr.show() sys.exit(app.exec_())
def __init__(self, args): # TODO добавить тесты super().__init__() lo = QVBoxLayout() self.score = Score() self.field = Field(getattr(args, '--field-size')) self.gui = GUI(getattr(args, '--cell-size'), self.field, self.score) self.restart_button = QPushButton('Restart') self.watch_records_button = QPushButton('Record Table') self.watch_records_button.clicked.\ connect(self.score.watch_record_table) self.restart_button.clicked.connect(self.gui.restart) lo.addWidget(self.score) lo.addWidget(self.gui) lo.addWidget(self.restart_button) lo.addWidget(self.watch_records_button) self.setLayout(lo) self.setWindowTitle('Lines') # подумать, как исправить self.setFixedSize(self.sizeHint())
def setup(self): # Initialization for i in range(self.player_num): self.engines[i] = TetrisEngine(self.width, self.height) self.engines[i].clear() if self.use_gui: gui = GUI(self, self.block_size) self.gui = gui else: self.stdscr = curses.initscr() curses.noecho() # Store play information self.dbs = {} self.done = False for i in range(self.player_num): # Initial rendering self.engine_states[i] = { "KO": 0, "reward": 0, "lines_sent": 0, "lines_cleared": 0, "hold_shape": None, "hold_shape_name": None, "hold_locked": False, "garbage_lines": 0, "highest_line": 0, "combo": -1 } # Initialize dbs self.dbs[i] = [] self.game_count += 1 self.start_time = time.time()
def test_raises_exception(self): with self.assertRaises(ValueError): board = Field(2) board = Field(-1) gui = GUI(1, Field(9), Score()) gui = GUI(-1, Field(9), Score())
class GUIFrame(Module): """ Main GUI frame for the OpenDial toolkit, encompassing various tabs and menus to control the application """ # logger log = logging.getLogger('PyOpenDial') def __init__(self, system): from dialogue_system import DialogueSystem if not isinstance(system, DialogueSystem): raise NotImplementedError("UNDEFINED PARAMETERS") """ Constructs (but does not yet display) a new GUI frame for OpenDial. :param system: system the dialogue system for the GUI """ self.frame = False self.tabbed_pane = None self.state_monitor_tab = None self.chat_tab = None self.editor_tab = None self.menu = None self._paused = True self._system = system self.gui = None self.is_speech_enabled = False self._audio_module = None self._settings = system.get_settings() @dispatch() def start(self): """ Displays the GUI frame. """ if self._system.get_settings().show_gui and not self.is_running(): self.frame = True app = QtWidgets.QApplication(sys.argv) self.gui = GUI(self._system) if self.is_speech_enabled: self.gui.enable_speech(True) # if not self._system._domain._xml_file is None: # self.gui.open_domain(self._system._domain) # self._system.start_system() sys.exit(app.exec_()) @dispatch(bool) def pause(self, pause): """ Pauses the GUI. """ self._paused = pause @dispatch(DialogueState, Collection) def trigger(self, state, update_vars): for variable in [ self._system.get_settings().user_input, self._system.get_settings().system_output ]: if not self._paused and variable in update_vars and state.has_chance_node( variable): if variable in [ self._settings.system_output, self._settings.user_input ]: table = self._system.get_content(variable).to_discrete() text = self._get_text_rendering(table) self.gui.chatlog.append(text) self.gui.chatlog.setAlignment(Qt.AlignLeft) self.gui.chatlog.moveCursor(QtGui.QTextCursor.End) @dispatch(CategoricalTable) def _get_text_rendering(self, table): """ Generates the text representation for the categorical table. :param table: the table :return: the text rendering of the table """ text_table = '' base_variable = table.get_variable().replace("'", '') if base_variable == self._system.get_settings().user_input: text_table += '\n[user]\t' elif base_variable == self._system.get_settings().system_output: text_table += '[system]\t' else: text_table += '[' + base_variable + ']\t' for value in table.get_values(): if not isinstance(value, NoneVal): content = str(value) if table.get_prob(value) < 0.98: content += ' (' + StringUtils.get_short_form( table.get_prob(value)) + ')' text_table += content + '\n\t\t' if base_variable == self._system.get_settings().user_input: text_table += '\n' text_table = text_table[0:-3] return text_table @dispatch() def refresh(self): pass @dispatch() def do_refresh(self): pass @dispatch(DialogueState, str) def record_state(self, state, name): pass @dispatch(str) def add_comment(self, comment): pass @dispatch(bool) def enable_speech(self, to_enable): self.is_speech_enabled = to_enable if self.gui is None: return self.gui.enable_speech(to_enable) # if self.chat_tab is not None: # self.chat_tab.enable_speech(to_enable) # # if self.menu is not None: # self.menu.enable_speech(to_enable) @dispatch(bool) def set_saved_flag(self, is_saved): pass @dispatch(int) def set_action_tab(self, i): pass @dispatch() def request_save(self): pass @dispatch() def close_window(self): pass @dispatch() def get_system(self): pass @dispatch() def get_chat_tab(self): pass @dispatch() def get_state_viewer_tab(self): pass @dispatch() def get_editor_tab(self): pass @dispatch() def get_frame(self): pass @dispatch() def is_running(self): return self.frame @dispatch() def is_speech_enabled(self): pass @dispatch() def is_domain_saved(self): pass @dispatch() def get_menu(self): pass @dispatch() def new_domain(self): pass # TODO: 'File' type @dispatch(object) def new_domain(self, file_to_save): pass @dispatch() def open_domain(self): pass @dispatch() def save_domain(self): pass # TODO: 'File' type @dispatch(object) def save_domain(self, file_to_write): pass @dispatch() def save_domain_as(self): pass @dispatch() def reset_interaction(self): pass @dispatch(bool) def import_interaction(self, is_wizard_of_oz): pass @dispatch() def save_interaction(self): pass @dispatch(str) def import_content(self, tag): pass @dispatch(str) def export_content(self, tag): pass
# TODO: ADD FROM/TO Graph generation import json from gui.gui import GUI from logic.Graph import Graph with open("resources/recipes.json", 'r') as recipes_file: recipes = json.load(recipes_file) g = Graph(recipes) a = GUI(g) a.run() # def run(): # with open("resources{}recipes.json".format(os.sep), 'r') as recipes_file: # recipes = json.load(recipes_file) # # g = Graph(recipes) # # compress_water = input("Do you want to compress water into nodes? (y/n): ") # compress_water = len(compress_water) == 0 or compress_water.lower() == "y" # # dot = g.get_dot(compress_water) # # dot.render("output", view=True) # # # if __name__ == "__main__": # run()
from tkinter import Tk from gui.gui import GUI window = Tk() window.title('TodoApp') gui = GUI(window) gui.start() window.mainloop()
class FSTimeSync: def __init__(self): self.si = SingleInstance(32092) self.settings = Settings('settings.json', DEFAULT_SETTINGS) self.fs_sync = FSSync() self.gui = GUI(self) self.mw_emit = self.gui.main_window.act.emit # TODO: Switch from mw_emit to mw_act self.mw_act = self.gui.main_window_act self.time_offsets = None self.sync_run = False self.sync_thread = None self.time_run = False self.time_thread = None self.live_sync_enabled = False self.now_source = "S" self.ntp_client = ntplib.NTPClient() self.ntp_delta = None self.offset = BasicTimeDelta() def start(self): try: self.sync_thread = threading.Thread(None, self.sync_thread_runner, "Sync Thread", daemon=True) self.sync_thread.start() self.time_thread = threading.Thread(None, self.time_thread_loop, "Time Thread", daemon=True) self.time_thread.start() self.gui.start() # locking finally: self.stop() def stop(self): self.sync_run = False self.time_run = False self.fs_sync.close_pyuipc() sys.exit(0) def get_now(self): if self.now_source == "NTP": try: if not self.ntp_delta: response = self.ntp_client.request('pool.ntp.org') print(time.ctime(response.tx_time)) self.ntp_delta = datetime.now( timezone.utc) - datetime.fromtimestamp( response.tx_time, timezone.utc) print(self.ntp_delta) self.gui.remove_message(1, 0) return datetime.utcnow() - self.ntp_delta except (ntplib.NTPException, socket.gaierror) as exc: self.gui.add_message(1, 0, "Can't reach NTP server.") print(exc) return datetime.utcnow() return datetime.utcnow() def switch_now_source(self): if self.now_source == "NTP": # Will switch to S self.now_source = "S" self.mw_emit([self.gui.main_window.ui.utc_label.setText, "UTC.S"]) self.mw_emit([ self.gui.main_window.ui.utc_label.setToolTip, "UTC.S : Using System Time" ]) elif self.now_source == "S": # Will switch to NTP self.ntp_delta = None # Refresh NTP self.now_source = "NTP" self.mw_emit( [self.gui.main_window.ui.utc_label.setText, "UTC.NTP"]) self.mw_emit([ self.gui.main_window.ui.utc_label.setToolTip, "UTC.NTP : Using Network Time Protocol, Online Time" ]) self.gui.remove_message(0, 1) # Remove will sync message def time_thread_loop(self): self.time_run = True while self.time_run: now = self.get_now() self.mw_emit([ self.gui.main_window.ui.real_time_hour.setText, "{:02d}".format(now.hour) ]) # self.mw_emit([self.gui.main_window.ui.real_time_seperator.setText, str(two_dots)) self.mw_emit([ self.gui.main_window.ui.real_time_minute.setText, "{:02d}".format(now.minute) ]) self.mw_emit([ self.gui.main_window.ui.real_time_second.setText, "{:02d}".format(now.second) ]) self.mw_emit([ self.gui.main_window.ui.real_date.setText, "{:02d}.{:02d}.{}".format(now.day, now.month, now.year) ]) # print(now) if bool(self.offset): offsetted_dt = self.offset + now self.gui.main_window_act( self.gui.main_window.ui.left_value.setText, f"{offsetted_dt.strftime('%H:%M | %d.%m.%Y')}") else: self.gui.main_window_act( self.gui.main_window.ui.left_value.setText, "") self.gui.main_window_act( self.gui.main_window.ui.left_status.setText, str(self.offset)) time.sleep(0.5) def toggle_live_sync(self): print("toggle live sync") if not self.live_sync_enabled: self.enable_live_sync() else: self.disable_live_sync() def disable_live_sync(self): self.live_sync_enabled = False self.gui.remove_message(0, 1) # Remove will sync message self.mw_emit([ self.gui.main_window.ui.live_button.setIcon, self.gui.icons["sync_disabled"] ]) self.mw_emit([ self.gui.main_window.ui.live_button.setToolTip, "Live Sync: Disabled" ]) def enable_live_sync(self): self.live_sync_enabled = True self.mw_emit([ self.gui.main_window.ui.live_button.setIcon, self.gui.icons["sync"] ]) self.mw_emit([ self.gui.main_window.ui.live_button.setToolTip, "Live Sync: Enabled" ]) def restart_sync_thread_runner(self, restart): self.mw_act(self.gui.main_window.ui.sim_label.setText, 'Waiting Simulator...') self.mw_act(self.gui.main_window.ui.sim_time_hour.setText, "") self.mw_act(self.gui.main_window.ui.sim_time_minute.setText, "") self.mw_act(self.gui.main_window.ui.sim_time_second.setText, "") self.mw_act(self.gui.main_window.ui.sim_time_second.setToolTip, "") self.mw_act(self.gui.main_window.ui.sim_time_seperator.setText, "") self.mw_act(self.gui.main_window.ui.sim_date.setText, "") self.fs_sync.reset() time.sleep(10) # Sleep, make sure FSUIPC exits completely. self.sync_thread_runner(restart=restart + 1) def sync_thread_runner(self, restart=0): # Est. FSUIPC connection. # Try every 10 seconds. self.sync_run = True while self.sync_run: if not self.fs_sync.connect_pyuipc(): # print(self.fs_sync.connect_pyuipc()) # print("Cannot connect FSUIPC.") time.sleep(10) continue self.mw_act(self.gui.main_window.ui.sim_label.setText, self.fs_sync.opened_sim) break offsets = { "TIME_SECOND": [0x023A, "b"], "TIME_HOUR": [0x023B, "b"], "TIME_MINUTE": [0x023C, "b"], "DATE_DAY": [0x023D, "b"], "DATE_MONTH": [0x0242, "b"], "DATE_YEAR": [0x0240, "H"], # Fixed from local } if self.fs_sync.pyuipc_open == SIMULATOR_XPLANE_ID: offsets["DAY_OF_YEAR"] = [0x023E, "h"] self.time_offsets = self.fs_sync.create_offset_set(offsets) try: self.sync_routine_loop() except (pyuipc.FSUIPCException, SystemError) as exc: if exc.errorCode == 12 or exc.errorCode == 13: print( f"Catched PYUIPC error, will restart. Code:{exc.errorCode}" ) self.restart_sync_thread_runner(restart=restart) def sync_routine_loop(self): two_dots = FlipFlop(":") while self.sync_run: data_delta = self.sync_sim() if not data_delta: continue data = data_delta[0] delta = data_delta[1] datetime = data_delta[2] self.mw_emit([ self.gui.main_window.ui.sim_time_hour.setText, "{:02d}".format(data["TIME_HOUR"]) ]) self.mw_emit([ self.gui.main_window.ui.sim_time_seperator.setText, str(two_dots) ]) self.mw_emit([ self.gui.main_window.ui.sim_time_minute.setText, "{:02d}".format(data["TIME_MINUTE"]) ]) self.mw_emit([ self.gui.main_window.ui.sim_time_second.setText, "{:02d}".format(data["TIME_SECOND"]) ]) self.mw_emit([ self.gui.main_window.ui.sim_date.setText, datetime.strftime('%d.%m.%Y') ]) self.mw_emit([ self.gui.main_window.ui.sim_time_second.setToolTip, "ε: ±{}s Δ: {}s".format(30, int(delta)) ]) # print(data) time.sleep(1) def sync_sim(self, force=False): """ Returns initial data if no sync. Returns new data if there has been sync. """ if not self.fs_sync.pyuipc_open: return try: data = self.time_offsets.read() if self.fs_sync.pyuipc_open == SIMULATOR_XPLANE_ID: data["DATE_YEAR"] += SIMULATOR_XPLANE_YEAR_DELTA time_from_data = datetime(data["DATE_YEAR"], 1, 1, data["TIME_HOUR"], data["TIME_MINUTE"], second=data["TIME_SECOND"]) time_from_data = time_from_data + timedelta( days=data["DAY_OF_YEAR"]) else: time_from_data = datetime(data["DATE_YEAR"], data["DATE_MONTH"], data["DATE_DAY"], data["TIME_HOUR"], data["TIME_MINUTE"], second=data["TIME_SECOND"]) now = self.offset + self.get_now() delta = (now - time_from_data).total_seconds() except ValueError as exc: # ValueError generally thrown when FSUIPC is reporting year out of range. # Happens on scenerio screen. print(exc) time.sleep(0.5) return False if self.live_sync_enabled or force: if not self.fs_sync.pyuipc_open: return if abs(delta) > 30 or force: if force: if data["TIME_SECOND"] - now.second > 20: self.time_offsets.write("TIME_SECOND", 0) else: if now.second > 3: self.gui.add_message( 0, 1, "Will Sync At: {:02d}:{:02d}z".format( now.hour, now.minute + 1)) return [data, delta, time_from_data] self.time_offsets.write("TIME_SECOND", 0) print("DOING A ZULU TIME SYNC.") if self.fs_sync.pyuipc_open == SIMULATOR_XPLANE_ID: self.time_offsets.write( "DATE_YEAR", now.year - SIMULATOR_XPLANE_YEAR_DELTA) self.time_offsets.write("DAY_OF_YEAR", int(now.strftime('%j')) - 1) self.time_offsets.write("TIME_HOUR", now.hour) self.time_offsets.write("TIME_MINUTE", now.minute) else: self.time_offsets.write("DATE_YEAR", now.year) self.time_offsets.write("DATE_MONTH", now.month) self.time_offsets.write("DATE_DAY", now.day) self.time_offsets.write("TIME_HOUR", now.hour) self.time_offsets.write("TIME_MINUTE", now.minute) self.gui.remove_message(0, 1) # Remove will sync message self.gui.add_message( 0, 2, "Last Sync: {:02d}:{:02d}:{:02d}z".format( now.hour, now.minute, now.second)) return [self.time_offsets.read(), delta, time_from_data] # Return fresh data return [data, delta, time_from_data]
class Main: def __init__(self): self.parent_dir = abspath(join(dirname(__file__), "..")) self.binary_dir = join(self.parent_dir, "bin") if not isdir(self.binary_dir): mkdir(self.binary_dir) if not isfile(join(self.binary_dir, "engine.exe")): print("Error: Engine not found!") print("Place engine.exe in " + self.binary_dir) sys.exit() self.board: Chessboard = None self.analyzer: BoardAnalyzer = None self.bot: Bot = None # Instantiate the GUI self.interface = GUI(self.parent_dir, self.toggle_color, self.set_coordinates) self.interface.create_window() # Instantiate the scanner self.scanner = Scanner(self.parent_dir, self.interface) # Retrieve the coordinates of the board from mouse input self.scanner.retrieve_coordinates(self.set_coordinates) # Required main loop for any tkinter application self.interface.window.mainloop() def set_coordinates(self, width, height, top_left): self.interface.loaded = True # Funky hack if self.scanner.task_id != -1: self.interface.cancel_task(self.scanner.task_id) self.scanner = None self.wait_for_start(self.initialize_bot, width, height, top_left) def initialize_bot(self, width, height, top_left): # Instantiate a chessboard object (wrapper for a python-chess board) self.board = Chessboard(width, height, top_left, self.interface.color) self.analyzer = BoardAnalyzer(self.board, self.interface) self.bot = Bot(self.binary_dir, self.board, self.analyzer.square_centers) if self.board.color == chess.WHITE: self.bot.play_move() self.analyzer.set_previous_state() self.loop() else: self.loop_initial_check() def wait_for_start(self, callback, *args): if self.interface.running: callback(*args) return self.interface.delay_task(100, self.wait_for_start, callback, *args) def loop(self): if not self.interface.running: self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop) return if self.board.is_game_over(): self.interface.log("Game over!") self.bot.terminate() return move = self.analyzer.analyze_changes(self.analyzer.detect_changes()) if move is None: self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop) return self.interface.log(f"Opponent move: {move}") self.board.play_move(move) self.bot.play_move() self.analyzer.set_previous_state( ) # Take a shot AFTER the bot's own move self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop) def loop_initial_check(self): if not self.interface.running: self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop_initial_check) return move = self.analyzer.detect_initial_changes() if move is None: self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop_initial_check) return self.board.play_move(move) self.bot.play_move() self.analyzer.set_previous_state() self.loop() def toggle_color(self): if self.board is not None: self.board.color = not self.board.color
def __init__(self): self._gui = GUI() self.is_COM_enabled = False self._synth = Synthesizer() self.running = False
def main(): import sys app = QtWidgets.QApplication(sys.argv) gui = GUI() gui.show() sys.exit(app.exec_())
import sys from tkinter import Tk from dataset_repository import DatasetRepository from misc.db_connection import get_database_connection from stat_analyzer import StatAnalyzer from analyses_config import get_analyses_config from gui.gui import GUI arguments = sys.argv stat_analyzer = StatAnalyzer(dataset=None, analyses=get_analyses_config()) dataset_repository = DatasetRepository(get_database_connection()) window = Tk() window.title("Stat analyzer") ui = GUI(window, stat_analyzer, dataset_repository) # If running with argument "dev". Load example data if len(arguments) > 1 and arguments[1] == 'dev': ui.load_exampledata() ui.start()
# -*- coding: UTF-8 -*- """ # Classe Principal do Trabalho # # Autores: # Data: 16/01/2021 """ import pygame from gui.gui import GUI if __name__ == "__main__": # Inicia as importações dos módulos do pygame pygame.init() # Inicia o loop do GUI gui = GUI() gui.loop() # Finaliza todos os módulos do pygame pygame.quit()
def main(): app = QApplication(sys.argv) window = GUI() window.show() sys.exit(app.exec_())
from gui.gui import GUI import logging # Logging --------------------------------------------------------------------- logging.basicConfig(level=logging.DEBUG,format='%(asctime)s (%(threadName)-2s) %(message)s') LOG = logging.getLogger() # Main method ----------------------------------------------------------------- if __name__ == '__main__': # Find the script absolute path, cut the working directory a_path = sep.join(abspath(argv[0]).split(sep)[:-1]) # Append script working directory into PYTHONPATH path.append(a_path) # Parsing arguments parser = ArgumentParser(description="Sudoku Game Client of DS Homework2", version = "RPC Version") parser.add_argument('-l','--listenaddr', \ help='RPC broadcast recv address, '\ 'defaults to %s' % DEFAULT_CLIENT_RPC_BRDCST_ADDR, \ default=DEFAULT_CLIENT_RPC_BRDCST_ADDR) parser.add_argument('-p','--listenport', \ help='RPC broadcast recv port, '\ 'defaults to %d' % DEFAULT_CLIENT_RPC_BRDCST_PORT, \ default=DEFAULT_CLIENT_RPC_BRDCST_PORT) args = parser.parse_args() try: GUI(args.listenaddr, args.listenport).gui_start() except KeyboardInterrupt: LOG.info('Terminating client ...')
class _Game: def __init__(self): self._gui = GUI() self.is_COM_enabled = False self._synth = Synthesizer() self.running = False def start(self): """ Arduino threshold setting and Loop starting """ self.running = True if self.is_COM_enabled: # Подготовка COM порта self._ser = serial.Serial(port='COM17', baudrate=9600) # fixme # Считывание установленного порога # self.threshold = int( # re.search( # "d{, 4}", # str(self._ser.readline()), # flags=re.ASCII)) self._clock = pygame.time.Clock() # Старт петли self._loop() def _loop(self): """ Main cycle """ while self.running: self._clock.tick(30) for event in pygame.event.get(): # Обработка выхода if event.type == pygame.QUIT: self.quit() # Работа с клавишами if event.type == pygame.KEYDOWN: if event.key == ord('q'): self.quit() # Обработка нажатий и отпускания. for note in self._synth.notes: if (event.key == self._synth.notes[note]['key_code']): self._synth.handle_key_down(note) if event.type == pygame.KEYUP: for note in self._synth.notes: if (event.key == self._synth.notes[note]['key_code']): self._synth.handle_key_up(note) if self.running: if self.is_COM_enabled: # Работа COM портом if self._ser.in_waiting > 0: # if self._ser. # Считываем строку из COM порта line = str(self._ser.readline()) # Ищем в строке A или !A note_tags = re.findall('[!]?[A-F]', line, flags=re.ASCII) for note_tag in note_tags: if note_tag[0] != '!': self._synth.handle_key_down(note_tag[0]) else: self._synth._handle_key_up(note_tag[1]) self._gui.update(self._synth.notes) self._synth.play() def quit(self): self.running = False if self.is_COM_enabled: self._ser.close() self._synth.close() pygame.quit()
def run_tests(): path = [] path_name = gui.get_field(5) gp = importlib.import_module(path_name) # for steer_eta in [FT(0.1), FT(0.2), FT(0.3), FT(0.4), FT(0.5), FT(0.6), FT(0.7), FT(0.8), FT(0.9), FT(1.0), FT(1.1), FT(1.2), FT(1.3), FT(1.4), FT(1.5)]: # for i in range(10): gp.generate_path(path, ps.robots, ps.obstacles, ps.destinations) # print("Generated path via", path_name + ".generate_path") def unused(): return if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) gui = GUI() ps = Polygons_scene() gui.set_program_name("Multi-robot Motion Planning") gui.set_field(0, "scenes/optimal_length_1") # gui.set_field(0, "data/scenes/warehouse0") gui.set_field(3, "run_all") gui.set_field(4, "path0.txt") gui.set_field(5, "run_tests") #gui.set_field(5, "path_out.txt") gui.set_logic(0, set_up_scene) gui.set_button_text(0, "Load scene") gui.set_logic(1, run_and_animate) gui.set_button_text(1, "run_and_animate") gui.set_logic(2, unused) gui.set_button_text(2, "unused") gui.set_logic(3, generate_path)
def run_tests(): path = [] path_name = gui.get_field(5) gp = importlib.import_module(path_name) # for steer_eta in [FT(0.1), FT(0.2), FT(0.3), FT(0.4), FT(0.5), FT(0.6), FT(0.7), FT(0.8), FT(0.9), FT(1.0), FT(1.1), FT(1.2), FT(1.3), FT(1.4), FT(1.5)]: # for i in range(10): gp.generate_path(path, ps.robots, ps.obstacles, ps.destinations) # print("Generated path via", path_name + ".generate_path") if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) gui = GUI() ps = Polygons_scene() gui.set_program_name("Multi-robot Motion Planning") gui.set_field(0, "data/scenes/scene3_very_hard_multi") # gui.set_field(0, "data/scenes/warehouse0") gui.set_field(3, "srm_drrt") gui.set_field(4, "path0.txt") gui.set_field(5, "run_tests") #gui.set_field(5, "path_out.txt") gui.set_logic(0, set_up_scene) gui.set_button_text(0, "Load scene") gui.set_logic(1, run_and_animate) gui.set_button_text(1, "run_and_animate") gui.set_logic(2, set_destinations) gui.set_button_text(2, "Set destinations") gui.set_logic(3, generate_path)
from gui.gui import GUI gui = GUI() # TODO: # - Extended sessions # - Mark invalid responses # - Weeks # - As of now, have to update to do it once a week # - Validate Excel formats
def test_gui(): pygame.init() window = pygame.display.set_mode((1024, 768)) pygame.display.set_caption("Testing GUI") screen = pygame.display.get_surface() background = pygame.Surface(screen.get_size()) background = background.convert() background.fill((0,0,0)) font = None if pygame.font: font = pygame.font.Font(None, 20) gui = GUI(None) gui.set_active(True) menu = BasicMenu(gui, h_pad=10, v_pad=10) gui.add_child(menu) menu.set_active(True) menu.add_child(BasicTextButton(menu, text = 'Select Mission', select_fxn = menu.mouse_over_callback, callback = gui.generic_click, callback_kwargs = {'target_id': 1})) menu.add_child(BasicTextButton(menu, text = 'Exit', select_fxn = menu.mouse_over_callback, callback = gui.exit_click)) gui.add_child(BasicMenu(gui)) ''' frame = Frame(gui) gui.add_child(frame) frame.set_active(True) testel = TestElement(frame) testel.image = pygame.surface.Surface((100,50)) testel.image = testel.image.convert() testel.image.fill((51, 102, 255)) testel.rect = testel.image.get_rect() testel.rect.topleft = ((window.get_width() - testel.rect.width) * 0.5, (window.get_height() - testel.rect.height) * 0.5) ''' while True: events = pygame.event.get() for event in events: if event.type == pygame.QUIT: sys.exit(0) if gui.is_active(): gui.update(events) screen.blit(background, (0,0)) if gui.is_active(): gui.draw() pygame.display.flip()
handler_controller = controller_handler.ControllerHandler( host_ip, port_controller, RUN_CONTROLLER_SERVER) handler_auto = auto_steering_handler.AutoSteeringHandler( OBSTACLE_DISTANCE, TL_STOP_DISTANCE) # Autonomous driving handler. handler_auto.load_models( F_MODEL_TO_LOAD, L_MODEL_TO_LOAD, R_MODEL_TO_LOAD) # Loading trained forward, left, and right models. # Creates a sign detector instance and starts the sign detector on a new thread. sign_detector = SignDetector(DETECT_SIGNS, DISPLAY_SIGN_DETECTED, DISPLAY_TRACKBARS) tl_detector = TrafficLightDetector(DETECT_TRAFFIC_LIGHTS) gui = GUI(handler_controller) try: while (True): # Requesting/getting the frame from the pi. raw_frame, _ = handler_cam.get_frame() if raw_frame is None: # Ensuring a frame was received and processed successfully. continue frame = raw_frame.copy( ) # Creating a copy which I can alter, while still having the raw frame. if DISPLAY_FPS: frame = handler_cam.display_fps(frame)