def new(self): """ re inits the window. gui doesnt get imported till now to protect against import loops and other shenanigans """ self._exit() import gui as Gui Gui.gui()
def main(args): if len(args) == 2 and args[1] in ["help", "-h", "--help"]: usage(args[0]) elif len(args) == 3: maker(args[1], args[2]) else: import gui gui.gui(args)
def main(): try: if len(sys.argv) == 1: gui() elif len(sys.argv) == 2: print('Enter command and webpage address, please') else: command = sys.argv[1] web_page_address = sys.argv[2] work_with_db(web_page_address, command) except Exception as error: print("Enter correct command, please") print(error)
def main(): global output_mode, gui_class # Check if there are any command line arguments of the correct format. if len(sys.argv) > 1 and sys.argv[1] == '-o' and len(sys.argv) > 2: # Set the output mode according to the argument. if sys.argv[2] == 'none': output_mode = 1 elif sys.argv[2] == 'fancy': output_mode = 2 elif sys.argv[2] == 'gui': output_mode = 3 # If we are using a GUI, then set up the GUI on the main thread, and run the core loop on a separate thread. back_process = Thread(target=run_loop) gui_class = gui.gui(io, 600, 300) try: back_process.start() gui_class.run_gui() except KeyboardInterrupt: handle_interrupt() return # Run the core loop on the main thread, if we aren't using a GUI. try: run_loop() except KeyboardInterrupt: handle_interrupt()
def __init__(self): self.version = gamemod.VERSION self.bannedservers = serverlist() self.registeredservers = serverlist(banned=self.bannedservers) self.pendingservers = serverlist(banned=self.bannedservers) self.masterclient = masterclient(self.pendingservers) # fetch gameservers from sauerbraten.org self.additionalservers = additionalservers(self.registeredservers, self.pendingservers, self.bannedservers) # fetch additional gameserver from servers.cfg and ban servers in banned.cfg self.additionalservers.load() self.gui = gui(self) self.gui.load() self.masterserver = masterserver(self.registeredservers, self.pendingservers) # let gameservers register at this (regserv) and let gameservers be registered by someone else (suggest) self.guiprovider = guiprovider(self.onguirequest) # provide the gamemod gui & server list self.statsprovider = statsprovider(self) # provide access to stats via additional commands # listen for connections from both clients requesting list of servers and servers trying to register and forward them to all functions in list respectively, until one of them returns a reply self.netserver = netserver([self.onrequest, self.masterserver.onrequest, self.guiprovider.onrequest, self.statsprovider.onrequest]) # ping servers and kick them out if they time out / add pending servers as registered if they reply in time # handle replies from servers self.servercommunicator = servercommunicator(self.registeredservers, self.pendingservers)
def __init__(self, width, height, size): self.width = width self.height = height self.gui = gui(self.width, self.height, "Level editor") self.widthRes = int(self.gui.winWidth / size) self.heightRes = int(self.gui.winHeight / size) self.size = size self.maze = [] self.selectedCells = [] makeMaze(self.maze, self.widthRes, self.heightRes, self.size) self.drawMaze() btn = Button(self.gui.master, text='Done', command=self.gui.master.destroy) btn.pack() self.gui.master.bind('<Button-1>', self.placeCell) self.gui.master.bind('<B1-Motion>', self.placeCell) self.gui.master.bind('<Button-3>', self.removeCell) self.gui.master.bind('<B3-Motion>', self.removeCell) self.gui.mainloop()
def __init__(self, options): gr.top_block.__init__(self) self.options = options # create a QT application self.qapp = QtGui.QApplication(sys.argv) # give Ctrl+C back to system signal.signal(signal.SIGINT, signal.SIG_DFL) # socket addresses rpc_adr_server = "tcp://localhost:6666" rpc_adr_reply = "tcp://*:6666" probe_adr_gui = "tcp://localhost:5556" probe_adr_fg = "tcp://*:5556" sink_adr = "tcp://*:5555" source_adr = "tcp://localhost:5555" # create the main window self.ui = gui.gui("Loop", rpc_adr_server, rpc_adr_server, probe_adr_gui) self.ui.show() # the strange sampling rate gives a nice movement in the plot :P self.samp_rate = samp_rate = 48200 # blocks self.gr_sig_source = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, 1000, 1, 0) self.null_source = blocks.null_source(gr.sizeof_float) self.throttle = blocks.throttle(gr.sizeof_float, samp_rate) self.zmq_source = zmqblocks.source_pushpull_feedback( gr.sizeof_float, source_adr) self.mult_a = blocks.multiply_const_ff(1) self.mult_b = blocks.multiply_const_ff(0.5) self.add = blocks.add_ff(1) #self.zmq_sink = zmqblocks.sink_reqrep_nopoll(gr.sizeof_float, sink_adr) #self.zmq_sink = zmqblocks.sink_reqrep(gr.sizeof_float, sink_adr) self.zmq_sink = zmqblocks.sink_pushpull(gr.sizeof_float, sink_adr) self.zmq_probe = zmqblocks.sink_pushpull(gr.sizeof_float, probe_adr_fg) #self.null_sink = blocks.null_sink(gr.sizeof_float) # connects self.connect(self.gr_sig_source, self.mult_a) self.connect(self.zmq_source, self.mult_b, (self.add, 1)) # self.connect(self.null_source, (self.add,1)) self.connect(self.mult_a, (self.add, 0), self.throttle, self.zmq_sink) self.connect(self.throttle, self.zmq_probe) # ZeroMQ self.rpc_manager = zmqblocks.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr_reply) self.rpc_manager.add_interface("start_fg", self.start_fg) self.rpc_manager.add_interface("stop_fg", self.stop_fg) self.rpc_manager.add_interface("set_waveform", self.set_waveform) self.rpc_manager.add_interface("set_k", self.mult_a.set_k) self.rpc_manager.add_interface("get_sample_rate", self.throttle.sample_rate) self.rpc_manager.start_watcher()
def main(): chessdatabase = "database" #Name of directory containing all databases databaselist = read_database(chessdatabase) #Creates list of I/O wrappers for all databases listed print("Initialization complete!") while True: print() print("Please select from the options:") print("1. Search \n2. Create game \n3. Analytics \n4. Display game\n5. Exit") enterinput = input() if enterinput in "1": #Search option selected searchcriteria = search.enter_search() #Asks user for search criteria showfirstgame = True pgnresult = [] print("Please wait, searching through database...") for i in range(len(databaselist)): pgnresult += search.query_database(databaselist[i],searchcriteria) #Store filtered results if showfirstgame: #Show an example game found in the GUI showfirstgame = False search.save_pgn(pgnresult,"FilteredGames.pgn") print("Export complete! Results are stored in database/FilteredGames.pgn") break elif enterinput in "2": #Create game try: import gui_pgn except: command_line_board(None, False) elif enterinput in "3": pgnlist = analytic.getlist(databaselist) analytic.graphTypes(pgnlist) break elif enterinput in "4": try: try: game = chess.pgn.read_game(databaselist[0]) gui.gui(game) except: #If GUI fails to display, use database_games to show every game in command-line database_games(game, showpgn=False, cmdboard=True) except IndexError: print("Search found no games within the database!") elif enterinput in "5": print("Exiting program") break else: print("Invalid input")
def run(self): if self.gs.guiOn: window = Tk() GUI = gui(window, self.gs) self.GUI = GUI GUI.window.bind("<Button-1>", lambda event: self.gamePlay(event, GUI), GUI) window.mainloop() else: self.gamePlay()
def __init__(self, options): gr.top_block.__init__(self) self.options = options # create a QT application self.qapp = QtGui.QApplication(sys.argv) # give Ctrl+C back to system signal.signal(signal.SIGINT, signal.SIG_DFL) # socket addresses rpc_adr_server = "tcp://localhost:6666" rpc_adr_reply = "tcp://*:6666" probe_adr_gui = "tcp://localhost:5556" probe_adr_fg = "tcp://*:5556" sink_adr = "tcp://*:5555" source_adr = "tcp://localhost:5555" # create the main window self.ui = gui.gui("Loop",rpc_adr_server,rpc_adr_server,probe_adr_gui) self.ui.show() # the strange sampling rate gives a nice movement in the plot :P self.samp_rate = samp_rate = 48200 # blocks self.gr_sig_source = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE , 1000, 1, 0) self.null_source = blocks.null_source(gr.sizeof_float) self.throttle = blocks.throttle(gr.sizeof_float, samp_rate) self.zmq_source = zmqblocks.source_pushpull_feedback(gr.sizeof_float,source_adr) self.mult_a = blocks.multiply_const_ff(1) self.mult_b = blocks.multiply_const_ff(0.5) self.add = blocks.add_ff(1) #self.zmq_sink = zmqblocks.sink_reqrep_nopoll(gr.sizeof_float, sink_adr) #self.zmq_sink = zmqblocks.sink_reqrep(gr.sizeof_float, sink_adr) self.zmq_sink = zmqblocks.sink_pushpull(gr.sizeof_float, sink_adr) self.zmq_probe = zmqblocks.sink_pushpull(gr.sizeof_float, probe_adr_fg) #self.null_sink = blocks.null_sink(gr.sizeof_float) # connects self.connect(self.gr_sig_source, self.mult_a) self.connect(self.zmq_source, self.mult_b, (self.add,1)) # self.connect(self.null_source, (self.add,1)) self.connect(self.mult_a, (self.add, 0), self.throttle, self.zmq_sink) self.connect(self.throttle, self.zmq_probe) # ZeroMQ self.rpc_manager = zmqblocks.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr_reply) self.rpc_manager.add_interface("start_fg",self.start_fg) self.rpc_manager.add_interface("stop_fg",self.stop_fg) self.rpc_manager.add_interface("set_waveform",self.set_waveform) self.rpc_manager.add_interface("set_k",self.mult_a.set_k) self.rpc_manager.add_interface("get_sample_rate",self.throttle.sample_rate) self.rpc_manager.start_watcher()
def launch(self): if self.type == "gui": self.g = gui() self.g.launch(self.modPath) if self.type == "console": try : self.c.cmdloop() except AttributeError: loader().do_load(self.modPath) self.c = console() self.c.cmdloop()
def main(): # User GUI input gui_input = gui.gui() directory = gui_input["datadir"] gantry_name = gui_input["gantry"] outputdir = gui_input["outputdir"] operator1 = gui_input["op1"] operator2 = gui_input["op2"] gantry_angles_in = gui_input["angles"] energies_in = gui_input["energies"] comment = gui_input["comment"] # Make energies and GA lists from input; ensure -180 < ga < 180 energies = [int(e) for e in energies_in.split(",")] gas = [int(ga) for ga in gantry_angles_in.split(",")] gantry_angles = [ga - 360 if ga > 180 else ga for ga in gas] print(f"GAs: {gantry_angles}") print(f"Es: {energies}") filenames = get_filenames(directory) filesok = check_files(filenames, gantry_angles, energies) # Get acquisition date and time from from Logos output.txt file adate, atime = get_acquisition_date_time(join(directory, "output.txt")) # New directory for results res_dir_name = gantry_name + " " + str(adate) result_dir = make_results_directory(outputdir, res_dir_name) print("Results will be printed to {}".format(result_dir)) if filesok: print("Full data set found") beams = get_ordered_beams(filenames) full_analysis(gantry_angles, energies, operator1, operator2, directory, beams, gantry_name, adate, atime, comment, result_dir) else: msg = ("\nINCORRECT NUMBER OF FILES FOUND\n" "- Did you choose correct directory?\n" "- Are GANTRY and ENERGY correct in config.py?\n") print(msg) ask = True while ask: ans = input("Yes/No (Y/N): ") if ans.lower().strip([0]) == "n": print("Exiting program") exit(0) elif ans.lower().strip()[0] == "y": partial_analyze.analysis() ask = False
def main(): parser = argparse.ArgumentParser( description='Python based event display core, doesn\'t draw data.') geom = parser.add_mutually_exclusive_group() geom.add_argument('-A', '-a', '--argoneut', action='store_true', help="Run with the argoneut geometry") geom.add_argument('-U', '-u', '--uboone', action='store_true', help="Run with the microboone geometry") geom.add_argument('-L', '-l', '--lariat', action='store_true', help="Run with the lariat geometry") parser.add_argument('file', nargs='*', help="Optional input file to use") args = parser.parse_args() app = QtGui.QApplication(sys.argv) if args.uboone: geom = evdmanager.microboone() elif args.lariat: geom = evdmanager.lariat() else: geom = evdmanager.argoneut() # If a file was passed, give it to the manager: thisgui = gui.gui(geom) thisgui.initManager() thisgui.initUI() # manager = larlite_manager(geom) # manager.setInputFiles(args.file) # manager.goToEvent(0) signal.signal(signal.SIGINT, sigintHandler) timer = QtCore.QTimer() timer.start(500) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. app.exec_()
def __init__(self): #gobject.GObject.__init__(self) #gobject.threads_init() gtk.gdk.threads_init() # Para la simulacion, llamar al procedimiento simular cada segundo. #gobject.timeout_add(1000, self.simular) # Definiciones generales self.ALARMA = False self.DEBUG = True self.modulos_activos = [] self.pila_sql = Queue.Queue(maxsize=100) self.pila_tramas_leidas = Queue.Queue() self.logs = logging.getLogger("logtoc") self.logs.setLevel(logging.DEBUG) path_logs = os.path.join(os.path.dirname(__file__), "toc.log") self.logs_h = logging.FileHandler(path_logs) self.logs_f = logging.Formatter("%(name)s: %(levelname)s %(asctime)s %(module)s:%(funcName) %(lineno)d: %(message)s") self.logs_h.setFormatter(self.logs_f) self.logs_h.setLevel(logging.DEBUG) self.logs.addHandler(self.logs_h) self.validar = validador(self) self.alarmas = alarmas_email(self) # Obtener configuracion del archivo. self.configuracion = SafeConfigParser() self.cargar_configuracion() self.id_localizacion = self.configuracion.get("lugar", "id") self.base = conectorBD(self) self.ventana = gui(self) self.tarjeta = tarjetaTOC(self) if self.base.conectar(): self.ventana.cambiar_estado_base("Conectada") else: self.ventana.cambiar_estado_base("Falló") # Comentar esta linea cuando ya no sea necesaria la simulacion #self.simular() self.guardar_en_pila(self.guardar_evento("Se inicio la aplicación", "0")) self.logs.debug("Se inicio la aplicacion")
def launch(self): if self.type == "gui": self.g = gui(self.debug) try: self.c self.g.launch() except AttributeError: self.g.launch(self.modPath) if self.type == "console": try : self.c.cmdloop() except AttributeError: loader().do_load(self.modPath) self.c = console(DEBUG = self.debug, VERBOSITY = self.verbosity) self.c.cmdloop()
def main(): root = Tk() screen = gui.gui(root) root.geometry("700x600") commands.Commands(screen) voice = voiceRec(screen) data("goodreads_library_export.csv") root.resizable(width=False, height=False) p = Process(target=voice.main) p.start() p2 = Process(target=root.mainloop) p2.start() threading.Thread(target=voice.main()).start() threading.Thread(target=root.mainloop()).start()
def login(): global hook global email_auth global pass_auth email_auth = emailEntry.get() pass_auth = passEntry.get() hook = EmailHook(email_auth, pass_auth, 'imap.gmail.com') try: g = gui(root, hook) login_root.destroy() loginPrompt.destroy() g.startInbox() except: emailEntry.delete(0, len(email_auth)) passEntry.delete(0, len(pass_auth))
def guiBase(self): ## Create gui self.gui = gui.gui() ## Add simulator gui items self.sim = simulatorGui.simulatorGui() ## Add controller items self.control = controller.controller() self.updateValues() self.gui.master.mainloop() try: self.gui.master.destroy() finally: print("App has been destroyed")
def main(): print('Main rutine started') dir = os.path.dirname(os.path.abspath(__file__)) print(dir) dir = os.path.abspath(dir + '/../') print(dir) uploadDir = (dir +'/uploadPictures/') uploadPrivDir = (dir + '/uploadPrivate/') cam = camera() g = gui(cam,uploadDir,uploadPrivDir) deamon = uploaderThread(uploadDir, uploadPrivDir, g) deamon.start() g.run() deamon.stop() deamon.join()
def init(self): # load the config file self.nettester_config = config() # initialize the gui self.nettester_gui = gui( self.nettester_config.config["resolution"], self.nettester_config.config["fg_color"], self.nettester_config.config["bg_color"], self.nettester_config.config["font_size_correction"], self.nettester_config.config["show_mouse_cursor"], ) # initialize the networking self.nettester_net = net() # create the buttons self.create_buttons() self.switch_to_wired() return True
def main(): parser = argparse.ArgumentParser(description='Python based event display core, doesn\'t draw data.') geom = parser.add_mutually_exclusive_group() geom.add_argument('-A', '-a', '--argoneut', action='store_true', help="Run with the argoneut geometry") geom.add_argument('-U', '-u', '--uboone', action='store_true', help="Run with the microboone geometry") geom.add_argument('-L', '-l', '--lariat', action='store_true', help="Run with the lariat geometry") parser.add_argument('file', nargs='*', help="Optional input file to use") args = parser.parse_args() app = QtGui.QApplication(sys.argv) if args.uboone: geom = evdmanager.microboone() elif args.lariat: geom = evdmanager.lariat() else: geom = evdmanager.argoneut() # If a file was passed, give it to the manager: thisgui = gui.gui(geom) thisgui.initManager() thisgui.initUI() # manager = larlite_manager(geom) # manager.setInputFiles(args.file) # manager.goToEvent(0) signal.signal(signal.SIGINT, sigintHandler) timer = QtCore.QTimer() timer.start(500) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. app.exec_()
def __init__(self, name): widget.__init__(self, name) # debug self.debug = config_var("debug", True) self.debug.hook = self.update_debug #enable / disable debug self.debug.set(True) #config path config_file_reader.config_path = "conf" cfr = config_file_reader() cfr.debug() self.gui = gui("gui") self.apps = apps("apps") self.log_debug("init liquidsand done")
def __init__(self, filename): with open(filename) as data_file: data = json.load(data_file) self.domain = {} for var in data["variables"]: self.domain[var["name"]] = var["domain"] self.constraints = {} for c in data["constraints"]: a = c["scope"][0] b = c["scope"][1] self.constraints[(a, b)] = c["relation"] self.order = data["ordering"] self.assign = {} self.pruned = {} self.gui = gui.gui(self.domain, self.constraints, self.order)
def main(): global ch, code, view, init_done ch = channel('BPSK') code = hamming_code(2, ch) get_input(None) view = gui.gui() view.add_radio_button([0.0, 0.0, 0.18, 0.15], ('BPSK', 'QPSK'), set_modulation) view.add_radio_button([0.0, 0.15, 0.18, 0.15], ('Syndrome', 'Chase'), set_ecc) view.add_radio_button([0.0, 0.30, 0.18, 0.15], ('(5,2,3)', '(7,4,3)'), set_code) view.add_button([0.0, 0.90, 0.18, 0.1], 'Decode', decode_now) view.add_button([0.0, 0.80, 0.18, 0.1], 'New Input', get_input) view.add_button([0.0, 0.70, 0.18, 0.1], 'Select Symbol', select_symbol) view.add_button([0.0, 0.60, 0.18, 0.1], 'Deselect Symbol', deselect_symbol) view.add_button([0.0, 0.50, 0.18, 0.1], 'Cust. Soft Values', custom_noise) view.add_slider([0.25, 0.05, 0.65, 0.08], 'Noise', (0, 3.0), set_noise) set_modulation('BPSK') init_done = True update() view.go() return
def Create_interaction(**kwargs): #fig,ax = plt.subplots() m = mi.build_basemap() plt.gca().set_title('line segments') lat0, lon0 = mi.pll('22 58.783S'), mi.pll('14 38.717E') x0, y0 = m(lon0, lat0) line, = m.plot([x0], [y0], 'ro-') text = ('Press s to stop interaction\\n' 'Press i to restart interaction\\n') #plt.text(1.0,0.1,text) wb = ex.dict_position(**kwargs) lines = mi.LineBuilder(line, m=m, ex=wb) print 'after line builder' plt.show() print 'after show' plt.gcf().canvas._tkcanvas.master.geometry("900x1000") print 'after canvas' g = gui.gui(lines) g.make_gui() print 'after gui' return lines
def Create_interaction(**kwargs): #fig,ax = plt.subplots() m = mi.build_basemap() plt.gca().set_title('line segments') lat0,lon0 = mi.pll('22 58.783S'), mi.pll('14 38.717E') x0,y0 = m(lon0,lat0) line, = m.plot([x0],[y0],'ro-') text = ('Press s to stop interaction\\n' 'Press i to restart interaction\\n') #plt.text(1.0,0.1,text) wb = ex.dict_position(**kwargs) lines = mi.LineBuilder(line,m=m,ex=wb) print 'after line builder' plt.show() print 'after show' plt.gcf().canvas._tkcanvas.master.geometry("900x1000") print 'after canvas' g = gui.gui(lines) g.make_gui() print 'after gui' return lines
def main(): parser = argparse.ArgumentParser(description="Display space points") group = parser.add_mutually_exclusive_group() parser.add_argument("file", help = "The file you wish " + \ "to read.", type = str) args = parser.parse_args() input_file = args.file app = QtGui.QApplication(sys.argv) manager = view_manager.view_manager() manager.setInputFile(input_file) thisgui = gui.gui() thisgui.setManager(manager) thisgui.initUI() manager.eventChanged.connect(thisgui.update) sys.exit(app.exec_())
def run(): validator = validation() human_visible_map = game_table() computer_invisible_map = game_table() computer_visible_map = game_table() human_invisible_map = game_table() human_player = player(human_visible_map, computer_invisible_map, computer_visible_map) computer_player = player(computer_visible_map, human_invisible_map, human_visible_map) game_controller = game_development(validator, human_player, computer_player) try: with open("settings.properties", "r") as settings_file: chosen_ui = settings_file.readlines()[2].split()[2] if chosen_ui == "ConsoleUI": chosen_ui = console_ui(game_controller) chosen_ui.run() elif chosen_ui == "GUI": chosen_ui = gui(game_controller) chosen_ui.run() else: raise InvalidUI("Invalid UI! Please check the 'settings.properties' file!") except InvalidUI as exception_message: print(exception_message)
def __init__(self): self.version = gamemod.VERSION self.bannedservers = serverlist() self.registeredservers = serverlist(banned=self.bannedservers) self.pendingservers = serverlist(banned=self.bannedservers) self.masterclient = masterclient( self.pendingservers) # fetch gameservers from sauerbraten.org self.additionalservers = additionalservers( self.registeredservers, self.pendingservers, self.bannedservers ) # fetch additional gameserver from servers.cfg and ban servers in banned.cfg self.additionalservers.load() self.gui = gui(self) self.gui.load() self.masterserver = masterserver( self.registeredservers, self.pendingservers ) # let gameservers register at this (regserv) and let gameservers be registered by someone else (suggest) self.guiprovider = guiprovider( self.onguirequest) # provide the gamemod gui & server list self.statsprovider = statsprovider( self) # provide access to stats via additional commands # listen for connections from both clients requesting list of servers and servers trying to register and forward them to all functions in list respectively, until one of them returns a reply self.netserver = netserver([ self.onrequest, self.masterserver.onrequest, self.guiprovider.onrequest, self.statsprovider.onrequest ]) # ping servers and kick them out if they time out / add pending servers as registered if they reply in time # handle replies from servers self.servercommunicator = servercommunicator(self.registeredservers, self.pendingservers)
from PySimpleGUI import WIN_CLOSED from utils import * from get_music import * from gui import gui if __name__ == "__main__": window = gui() def error(error): window.Element("error").Update(value=error) def download_visible(bool=True): window.Element('music_title').Update(visible=bool) if not bool: window.Element('-IMAGE-').Update('') window.Element('download').Update(visible=bool) window.Element('sucess').Update(visible=False) while True: event, values = window.read() if event == "search": url = values["url"] download_visible(False) if not url: error("Insira um link!") else: error("") music = get_music(url)
def __init__(self): gui()
def build_buttons(ui,lines,vertical=True): 'Program to set up the buttons' import gui import Tkinter as tk from matplotlib.colors import cnames if vertical: side = tk.TOP h = 2 w = 20 else: side = tk.LEFT h = 20 w = 2 g = gui.gui(lines,root=ui.root,noplt=True) g.refresh = tk.Button(g.root,text='Refresh', command=g.refresh, bg='chartreuse') g.bopenfile = tk.Button(g.root,text='Open Excel file', command=g.gui_open_xl) g.bsavexl = tk.Button(g.root,text='Save Excel file', command=g.gui_save_xl) g.bsavetxt = tk.Button(g.root,text='Save text file', command=g.gui_save_txt) g.bsaveas2kml = tk.Button(g.root,text='SaveAs to Kml', command=g.gui_saveas2kml) g.bsave2kml = tk.Button(g.root,text='Update Kml', command=g.gui_save2kml) g.bsave2gpx = tk.Button(g.root,text='Save to GPX', command=g.gui_save2gpx) g.refresh.pack(in_=ui.top,side=side,fill=tk.X,pady=8) tk.Label(g.root,text='File options').pack(in_=ui.top,side=side) g.bopenfile.pack(in_=ui.top,side=side) g.bsavexl.pack(in_=ui.top,side=side) g.bsavetxt.pack(in_=ui.top,side=side) g.bsaveas2kml.pack(in_=ui.top,side=side) g.bsave2kml.pack(in_=ui.top,side=side) g.bsave2gpx.pack(in_=ui.top,side=side) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) tk.Label(g.root,text='Other plots').pack(in_=ui.top,side=side) g.bplotalt = tk.Button(g.root,text='Plot alt vs time', command=g.gui_plotalttime) g.bplotalt.pack(in_=ui.top,side=side) g.bplotsza = tk.Button(g.root,text='Plot SZA', command=g.gui_plotsza) g.bplotsza.pack(in_=ui.top,side=side) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) g.frame_select = tk.Frame(g.root,relief=tk.SUNKEN,bg='white') g.frame_select.pack(in_=ui.top,side=side,fill=tk.BOTH) tk.Label(g.root,text='Flight paths:',bg='white').pack(in_=g.frame_select,side=side) g.newflight_off = False g.flightselect_arr = [] g.flightselect_arr.append(tk.Radiobutton(g.root,text=lines.ex.name, fg=lines.ex.color, variable=g.iactive,value=0, indicatoron=0, command=g.gui_changeflight, state=tk.ACTIVE,bg='white')) g.flightselect_arr[0].pack(in_=g.frame_select,side=side,padx=4,pady=2,fill=tk.BOTH) g.flightselect_arr[0].select() g.iactive.set(0) g.newflightpath = tk.Button(g.root,text='New flight path', command = g.gui_newflight) g.newflightpath.pack(in_=ui.top,padx=5,pady=2) #g.removeflightpath = tk.Button(g.root,text='Remove flight path', # command = g.gui_removeflight) #g.removeflightpath.pack(in_=ui.top,padx=5,pady=5) g.addpoint = tk.Button(g.root,text='Add point dialog', command = g.gui_addpoint) g.addpoint.pack(in_=ui.top,padx=5,pady=2) g.movepoints = tk.Button(g.root,text='Move points', command = g.gui_movepoints) g.movepoints.pack(in_=ui.top,padx=5,pady=2) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) tk.Label(g.root,text='Extra info:').pack(in_=ui.top,side=side) g.baddsat = tk.Button(g.root,text='Add Satellite tracks', command = g.gui_addsat_tle) g.baddsat.pack(in_=ui.top) g.baddbocachica = tk.Button(g.root,text='Add Forecast\nfrom Bocachica', command = g.gui_addbocachica) g.baddbocachica.pack(in_=ui.top) g.baddfigure = tk.Button(g.root,text='Add Forecast\nfrom image', command = g.gui_addfigure) g.baddfigure.pack(in_=ui.top) #g.baddgeos = tk.Button(g.root,text='Add GEOS', # command = g.gui_addgeos) #g.baddgeos.pack(in_=ui.top) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) tk.Button(g.root,text='Quit',command=g.stopandquit,bg='lightcoral' ).pack(in_=ui.top,side=side) ui.g = g
def run(self): g=gui.gui() g.run()
import gtk import gobject if __name__ == "__main__": gobject.threads_init() config = ConfigParser.ConfigParser() conf_file = os.path.abspath(os.path.dirname(__file__)+"/kaeruftpload.conf") config.read(conf_file) host = config.get("config", "host"); user = config.get("config", "user"); password = config.get("config", "password"); directory = config.get("config", "directory"); url = config.get("config", "url"); if not sys.argv == None: file_names = sys.argv del file_names[0] else: file_names = [] gui = gui.gui() gui.ftp_details(host, user, password, directory, url) gui.file_names(file_names) gui.run() gtk.main()
port1.tx.down() port2.tx.down() GPIO.cleanup() #p0.terminate() sys.exit(-1) signal.signal(signal.SIGHUP, hup_handler) signal.signal(signal.SIGINT, int_handler) # lists of the data that will be stored in the xml configuration xmlvars = () GPIO.setmode(GPIO.BOARD) q1 = queue.Queue() q2 = queue.Queue() gui = gui.gui(top) globalState = state.state(top, gui) port1 = radioPort.radioPort(1, q1, globalState) port2 = radioPort.radioPort(2, q2, globalState) port1.other = port2 port2.other = port1 hwio = hwio.hwio(top) port1.hwio = hwio port2.hwio = hwio top.port1 = port1 top.port2 = port2 top.gui = gui top.hwio = hwio top.globalState = globalState fp = fpPixels.fpPixels(top.globalState) cmdSock = tcpSocketCmd.tcpSocketCmd(globals(), q1, q2)
def build_buttons(ui,lines,vertical=True): 'Program to set up the buttons' import gui import Tkinter as tk from matplotlib.colors import cnames if vertical: side = tk.TOP h = 2 w = 20 else: side = tk.LEFT h = 20 w = 2 g = gui.gui(lines,root=ui.root,noplt=True) g.refresh = tk.Button(g.root,text='Refresh', command=g.refresh, bg='chartreuse') g.refreshspeed = tk.Button(g.root,text='Refresh without Speeds', command=g.refresh_nospeed) g.bopenfile = tk.Button(g.root,text='Open', command=g.gui_open_xl) g.bsavexl = tk.Button(g.root,text='Save', command=g.gui_save_xl) g.bsavexl_pilot = tk.Button(g.root,text='for pilot', command=g.gui_save_xl_pilot) g.bsavetxt = tk.Button(g.root,text='TXT', command=g.gui_save_txt) g.bsaveas2kml = tk.Button(g.root,text='SaveAs', command=g.gui_saveas2kml) g.bsave2kml = tk.Button(g.root,text='Update', command=g.gui_save2kml) g.bsave2gpx = tk.Button(g.root,text='GPX', command=g.gui_save2gpx) g.bsave2ict = tk.Button(g.root,text='ICT', command=g.gui_save2ict) g.bsavepng = tk.Button(g.root,text='map to PNG', command=g.gui_savefig) g.bsaveall = tk.Button(g.root,text='Save All', command=g.gui_saveall,bg='lightskyblue') g.refresh.pack(in_=ui.top,side=side,fill=tk.X,pady=6) g.refreshspeed.pack(in_=ui.top,side=side,fill=tk.X,pady=2) tk.Label(g.root,text='File options').pack(in_=ui.top,side=side) g.frame_xl = tk.Frame(ui.top) g.frame_xl.pack(in_=ui.top,side=side,fill=tk.X,pady=2) tk.Label(ui.top,text='Excel file:').pack(in_=g.frame_xl,side=tk.LEFT) g.bopenfile.pack(in_=g.frame_xl,side=tk.LEFT) g.bsavexl.pack(in_=g.frame_xl,side=tk.LEFT) g.bsavexl_pilot.pack(in_=g.frame_xl,side=tk.LEFT) g.frame_kml = tk.Frame(ui.top) g.frame_kml.pack(in_=ui.top,side=side,fill=tk.X,pady=2) tk.Label(ui.top,text='Kml file:').pack(in_=g.frame_kml,side=tk.LEFT) g.bsaveas2kml.pack(in_=g.frame_kml,side=tk.LEFT) g.bsave2kml.pack(in_=g.frame_kml,side=tk.LEFT) g.frame_save = tk.Frame(ui.top) g.frame_save.pack(in_=ui.top,side=side,fill=tk.X,pady=2) tk.Label(ui.top,text='Saving to:').pack(in_=g.frame_save,side=tk.LEFT) g.bsavetxt.pack(in_=g.frame_save,side=tk.RIGHT) g.bsave2gpx.pack(in_=g.frame_save,side=tk.RIGHT) g.bsave2ict.pack(in_=g.frame_save,side=tk.RIGHT) g.frame_save2 = tk.Frame(ui.top) g.frame_save2.pack(in_=ui.top,side=side,fill=tk.X,pady=2) g.bsavepng.pack(in_=g.frame_save2,side=tk.RIGHT) g.bsaveall.pack(in_=g.frame_save2,side=tk.LEFT) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) g.frame_plot = tk.Frame(ui.top) g.frame_plot.pack(in_=ui.top,side=side,fill=tk.X,pady=2) tk.Label(ui.top,text='Plots:').pack(in_=g.frame_plot,side=tk.LEFT) g.bplotlat = tk.Button(g.root,text='Alt vs Lat', command=g.gui_plotaltlat) g.bplotlat.pack(in_=g.frame_plot,side=tk.RIGHT) g.bplotalt = tk.Button(g.root,text='Alt vs time', command=g.gui_plotalttime) g.bplotalt.pack(in_=g.frame_plot,side=tk.RIGHT) g.bplotsza = tk.Button(g.root,text='SZA', command=g.gui_plotsza) g.bplotsza.pack(in_=g.frame_plot,side=tk.RIGHT) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) g.frame_select = tk.Frame(g.root,relief=tk.SUNKEN,bg='white') g.frame_select.pack(in_=ui.top,side=side,fill=tk.BOTH) tk.Label(g.root,text='Flight paths:',bg='white').pack(in_=g.frame_select,side=side) g.newflight_off = False g.flightselect_arr = [] g.flightselect_arr.append(tk.Radiobutton(g.root,text=lines.ex.name, fg=lines.ex.color, variable=g.iactive,value=0, indicatoron=0, command=g.gui_changeflight, state=tk.ACTIVE,bg='white')) g.flightselect_arr[0].pack(in_=g.frame_select,side=side,padx=4,pady=2,fill=tk.BOTH) g.flightselect_arr[0].select() g.iactive.set(0) g.newflightpath = tk.Button(g.root,text='New flight path', command = g.gui_newflight) g.newflightpath.pack(in_=ui.top,padx=5,pady=2) #g.removeflightpath = tk.Button(g.root,text='Remove flight path', # command = g.gui_removeflight) #g.removeflightpath.pack(in_=ui.top,padx=5,pady=5) g.frame_points = tk.Frame(ui.top) g.frame_points.pack(in_=ui.top,side=side,fill=tk.X,pady=2) tk.Label(ui.top,text='Points:').pack(in_=g.frame_points,side=tk.LEFT) g.addpoint = tk.Button(g.root,text='Add', command = g.gui_addpoint) g.addpoint.pack(in_=g.frame_points,padx=0,pady=0,side=tk.LEFT) g.movepoints = tk.Button(g.root,text='Move', command = g.gui_movepoints) g.movepoints.pack(in_=g.frame_points,padx=0,pady=0,side=tk.LEFT) g.rotpoints = tk.Button(g.root,text='Rotate', command = g.gui_rotatepoints) g.rotpoints.pack(in_=g.frame_points,padx=0,pady=0,side=tk.LEFT) g.add_flt_module = tk.Button(g.root,text='Add flt module', command=g.gui_flt_module) g.add_flt_module.pack(in_=ui.top) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) #tk.Label(g.root,text='Extra info:').pack(in_=ui.top,side=side) g.baddsat = tk.Button(g.root,text='Add Satellite tracks', command = g.dummy_func) g.baddsat.pack(in_=ui.top) g.baddsat.config(command=g.gui_addsat_tle) g.baddaeronet = tk.Button(g.root,text='Add current\nAERONET AOD', command = g.dummy_func) g.baddaeronet.pack(in_=ui.top) g.baddaeronet.config(command=g.gui_addaeronet) g.baddbocachica = tk.Button(g.root,text='Add Forecast\nfrom Bocachica', command = g.gui_addbocachica) g.baddbocachica.pack(in_=ui.top) g.baddtrajectory = tk.Button(g.root,text='Add trajectory\nImage', command = g.gui_addtrajectory) g.baddtrajectory.pack(in_=ui.top) g.baddfigure = tk.Button(g.root,text='Add Forecast\nfrom image', command = g.gui_addfigure) g.baddfigure.pack(in_=ui.top) g.baddgeos = tk.Button(g.root,text='Add GEOS Forecast', command = g.gui_addgeos) g.baddgeos.pack(in_=ui.top) g.baddsua = tk.Button(g.root,text='Add Special Use Airspace', command = g.gui_add_SUA_WMS) g.baddsua.pack(in_=ui.top) g.baddwms = tk.Button(g.root,text='Add WMS layer', command = g.gui_add_any_WMS) g.baddwms.pack(in_=ui.top) #g.bpythoncmd = tk.Button(g.root,text='Python command line', # command = g.gui_python) #g.bpythoncmd.pack(in_=ui.top) tk.Frame(g.root,height=h,width=w,bg='black',relief='sunken' ).pack(in_=ui.top,side=side,padx=8,pady=5) tk.Button(g.root,text='Quit',command=g.stopandquit,bg='lightcoral' ).pack(in_=ui.top,side=side) g.bg = g.baddsat.cget('bg') ui.g = g
from connection import Connection from config import Config from gui import gui # Read configuration file for api_token and url of OctoPrint config = Config() api_token = config.get_api_token() url = config.get_url() # Make connection to OctoPrint con = Connection(url, api_token) # Start Gui gui(con, config)
def main(): """Main function """ global lock global conf global gui_thr global mail_thrs global checker global messages # parse command-line arguments usage = 'usage: %prog [options]... args...' parser = OptionParser(usage) parser.add_option('-c', '--config-file', dest = 'config', help = 'configuration file path') parser.add_option('-w', '--width', dest = 'width', type = 'int', help = 'width of the window') parser.add_option('-g', '--height', dest = 'height', type = 'int', help = 'height of the window') parser.add_option('--bg', dest = 'background', help = 'backgound color') parser.add_option('--fg', dest = 'foreground', help = 'foreground color') parser.add_option('--fgn', dest = 'foreground new', help = 'foreground color for new messages') parser.add_option('-l', '--log', dest = 'log', help = 'Log file') parser.add_option('--level', dest = 'level', help = 'Log level: critial, error, warning, info, debug') (options, args) = parser.parse_args() if options.config: exp_path = os.path.expanduser(options.config) config_file = os.path.isabs(exp_path) and exp_path or \ os.path.join(cwd, exp_path) else: # default config file location if is_posix(): config_file = os.path.expanduser('~/.pymailheadersrc') else: config_file = 'config.ini' try: # read in config file if there is any conf = config.config(config_file) except: sys.exit(1) # get all configurations # # command line arguments have higher priorities, so they can overwrite # config file options opts = conf.get_all() # this is way too ugly, it's not a proper use of optparse, but had to # use this hack to get arround. options = options.__dict__.copy() del options['config'] # don't use opts.update() because that will write all None values for k in options.iterkeys(): if not opts.has_key(k) or options[k]: opts[k] = options[k] # Logging information if 'log' in opts: TARGET = opts['log'] del opts['log'] else: TARGET = None LEVEL_LIST = {'critical': logging.CRITICAL, 'error': logging.ERROR, 'warning': logging.WARNING, 'info': logging.INFO, 'debug': logging.DEBUG} if 'level' in opts and opts['level'] in LEVEL_LIST: LEVEL = LEVEL_LIST[opts['level']] else: LEVEL = LEVEL_LIST['error'] if 'level' in opts: del opts['level'] FORMAT = '%(asctime)s [(%(threadName)-13s) %(name)-11s:%(lineno)-4d]' + \ ' %(levelname)-5s: %(message)s' logging.basicConfig(level = LEVEL, format = FORMAT, datefmt = '%H:%M:%S', filename = TARGET) # setup signal handler so that settings will be saved even if the # process is killed signal.signal(signal.SIGTERM, on_exit) # create threads gui_thr = gui.gui(opts) # set up signal handlers handlers = {'on_refresh_activate': on_refresh_activate, 'on_config_save': on_config_save, 'on_account_changed': on_account_changed, 'on_account_removed': on_account_removed} gui_thr.signal_autoconnect(handlers) new_mail_thrs(opts['accounts']) checker = mail_checker() try: # start all threads checker.start() for mail_thr in mail_thrs.itervalues(): if not mail_thr.isAlive(): mail_thr.start() gui.gtk.gdk.threads_enter() gui.gtk.main() gui.gtk.gdk.threads_leave() except KeyboardInterrupt: pass checker.quit() delete_mail_thrs()
# run_gui.py # # Init script, meant to generate gui. Called by gui thread of daq. When this # terminates, the whole app will terminate. It is run as a text file, not a # module (this affects the scope of variables defined/changed) # import gtk import posix import gui app = gui.gui() # These variables are used to change the state of user interface upon # completion of a task, to plot data, change progressbar val etc. gui_exports = {'purgatory' : app.purgatory, 'on_finished' : app.on_logic_finished, 'plot' : app.wTree.plot, 'progressbar' : app.wTree.progressbar} gtk.gdk.threads_init() gtk.gdk.threads_enter() gtk.main() gtk.gdk.threads_leave()
# that is closest to the current sonar location intersect = self.math.get_intersect_point(self.loc, ln, self.map) # calculate the distance to the intersection point, with # some parameters which limit the data to a certain range dist = self.math.intersect_distance(self.loc, intersect, self.min_range, self.max_range,) self.ranges.append(dist) # store the calculated distance # Store the other objects for drawing later if necessary self.scan_lines.append(ln) self.intersection_points.append(intersect) self.current_angle += self.step # increment the angle to the angle of the next measurement def generate_particles(self, number): """Create a number of particles.""" if not self.particles.list(): for i in range(number): # Create a particle within a gaussian range of the current sonar location self.particles.add(particle.Particle(Point(self.math.apply_point_noise(self.loc.x, self.loc.y, self.loc_noise, self.loc_noise)), self)) if __name__ == '__main__': simple_map = map_rep.map_(sys.argv[1]) mvlist = move_list.MoveList() mvlist.read_from_file(sys.argv[2]) #mvlist = move_list.MoveList([Point(0,0)]) #param = {'map_':simple_map, 'move_list':mvlist, 'max_rng':50, 'step': 15, 'particle_number': 10, 'out_file': 'data.txt', 'param_file': 'params.txt'} param = {'map_':simple_map, 'move_list':mvlist, 'max_rng':50, 'step': 15, 'particle_number': 10, 'out_file': 'data.txt'} sonar = sonar(**param) #sonar = sonar(simple_map, mvlist, rng=50, step=15, particle_number=5) #a = particle.Particle(sonar.loc, sonar) #a.get_ranges() ab = gui.gui(sonar)
def gui(cmdline): survey = model.survey.Survey.load(cmdline['project']) import gui return gui.gui(survey, cmdline)
#!/usr/bin/env python # Korean Text to ePUB Converter # # For more detail info, visit http://code.google.com/p/epubia __program__ = 'epubia' __version__ = '0.5.2' __config__ = 'config.xml' # load config file import config_file config = config_file.load(__config__) # start GUI import gui gui.gui( config ) # save config file config_file.save(__config__, config) # vim:ts=4:sw=4:et
import gui import sys if __name__ == '__main__': gui.gui() sys.exit(0)
class Model(): def __init__(self): print "MODEL INITIALIZED" self.board = createBreadboard() self.compList = [] def placeCompOnBreadBoard(self,component,board,compList): if len(compList) == 0: placeFirstComponent(component,board,compList) else: placeComponent(component,board,compList) def placeCompOnSchema(self,compList): placingCD(compList) class Controller(): pass if __name__ == '__main__': Test = Model() print Test.board[3][0].Occupied Resistor1 = resistor(1,0,0,4,5,'h',{1:[],2:[]}) Test.placeCompOnBreadBoard(Resistor1,Test.board,Test.compList) print Test.compList[0].x Test.placeCompOnSchema(Test.compList) print Test.compList[0].cx app = g.gui(None) app.title('C.I.R.C.U.I.T') app.mainloop()
import gui # temp moter class Moterz: def __init__(self, Ena, in1, in2): # in1= input 1 forward # in2=input 2 backward print("strt") def movef(self, s=30): print("f speed=", s) def ChangeSpeed(self, s=30): print("speed change ", s) def Stop(self): pass def moveB(self, s=30): print("b speed=", s) def q(self): print("GPIO cleaning up") wmoter = Moterz(1, 2, 3) emoter = Moterz(4, 5, 6) mgui = gui.gui(wmoter, emoter)
elif os.name == 'posix': from linterface import Interface pass from remapper import remapper pygame.init() # Starts pygame t = pygame.time.Clock() # Make a tracker interface = Interface() os.system('cls' if os.name=='nt' else 'clear') # Clear terminal // remove "there is no soundcard" try: print "Number of Devices:", pygame.joystick.get_count() d = pygame.joystick.Joystick(0) d.init() # Start pygame.joystick.Joystick(0) rem = remapper(d.get_name()) maingui = gui.gui(rem) # Gives info about the device print "Connected device", d.get_name() print d.get_name(), "have" print "Buttons:", d.get_numbuttons() print "Axes:", d.get_numaxes() print "Hats:", d.get_numhats() print "Balls:", d.get_numballs() print "The device ID is", d.get_id() print "Press button 0 to exit" # Start showing the info in terminal def loop(): global d, t
from InputData import input_data from calculation import cal from gui import gui from web import web web() data = input_data() maxNum, maxDay, minNum, minDay, ave, mid = cal(data) gui(maxNum, maxDay, minNum, minDay, ave, mid, data)
def __init__(self, firstHost = None, port = None, name = "temp", ip = None, testmode = False): self.name = name # set peer name self.inSocket = None # Socket für eingehende Verbindungen self.hosts = {} # Dict. der bekannten Hosts self.knownPeers = {} # Dict (ip:port) : name self.msgParts = {} # set own ip if you already know it if ip != None: self.ip = ip else: self.ip = "null" # open socket self.inSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if port == None: # bind on random port self.inSocket.bind(('', 0)) else: # bind on given port self.inSocket.bind(('', int(port))) self.port = int(self.inSocket.getsockname()[1]) # port where peer listens on logging.info("Listening on port " + str(self.port)) self.history = message.History(const.HISTORY_SAVEDMSGSLIMIT, const.HISTORY_SAVEDHASHESLIMIT) self.gui = gui.gui(self) # lock for hostlist (not needed atm) # self.hostlock = threading.RLock() # start receiveLoop self.rThread = threading.Thread(target=self.startRecvLoop) self.rThread.daemon = True self.rThread.start() # start sendLoop if testmode == True: #if testmode is true, sendLoop will drop random parts of msgs self.sThread = threading.Thread(target=self.sendLoop, args=(True,)) self.sThread.daemon = True self.sThread.start() else: self.sThread = threading.Thread(target=self.sendLoop, args=(False,)) self.sThread.daemon = True self.sThread.start() # start maintenance Loop self.counter = 0 self.mThread = threading.Thread(target=self.maintenanceLoop) self.mThread.daemon = True self.mThread.start() # send HELO to first host if you know one if firstHost != None: self.key = None (hostIP, hostPort) = firstHost h = Host(self, hostIP, hostPort) h.bootstrap = True # wait until you're connected to the network while self.key == None: time.sleep(0.5) #Initial Request for some more hosts from firstHost key = h.constructKey(hostIP, hostPort) logging.debug("Initial Request for some peers from " + key) self.requestHosts(key, const.MIN_PEERLIMIT) # and get some more hosts #Initial Request for History logging.debug("Initial Request for History from " + key) self.getHistory(key, initial=True) else: self.key = Host.constructKey(self.ip, self.port) logging.info("You created a new Hachat-network. Your key is " + self.key) if testmode == True: self.generateMsgParts(10, 3000) #generates Randome Text-Msgs #start gui self.gui.run()
def main(): app = QtGui.QApplication(sys.argv) # convert from units of photon energy to frequency in Hz def freq_hz1 (hz): # frequency (Hz) return hz def freq_thz1 (thz): # frequency (THz) return 1e12 * thz def wl_m1 (m): # wavelength (m) return const.c / m def wl_microns1(um): # wavelength (microns) return const.c / (1e-6 * um) def wl_nm1 (nm): # wavelength (nm) return const.c / (1e-9 * nm) def wn_m_inv1 (m_inv): # wavenumber (m^-1) return const.c * m_inv def wn_cm_inv1 (cm_inv): # wavenumber (cm^-1) return const.c * (1e-2 * cm_inv) # convert from frequency in Hz to units of photon energy def freq_hz2 (hz): # frequency (Hz) return hz def freq_thz2 (hz): # frequency (THz) return 1e-12 * hz def wl_m2 (hz): # wavelength (m) return const.c / hz def wl_microns2 (hz): # wavelength (microns) return 1e6 * const.c / hz def wl_nm2 (hz): # wavelength (nm) return 1e9 * const.c / hz def wn_m_inv2 (hz): # wavenumber (m^-1) return hz / const.c def wn_cm_inv2 (hz): # wavenumber (cm^-1) return 1e2 * hz / const.c # convert from units of photon energy to wavelength in m def freq_hz3 (hz): # frequency (Hz) return const.c / hz def freq_thz3 (thz): # frequency (THz) return const.c / (1e12 * thz) def wl_m3 (m): # wavelength (m) return m def wl_microns3(um): # wavelength (microns) return 1e-6 * um def wl_nm3 (nm): # wavelength (nm) return 1e-9 * nm def wn_m_inv3 (m_inv): # wavenumber (m^-1) return 1.0 / m_inv def wn_cm_inv3 (cm_inv): # wavenumber (cm^-1) return 1.0 / (1e-2 * cm_inv) energy_list = \ [aux.energy_form("Frequency", "Hz", freq_hz1, freq_hz2, freq_hz3, True), aux.energy_form("Frequency", "THz", freq_thz1, freq_thz2, freq_thz3, True), aux.energy_form("Wavelength", "m", wl_m1, wl_m2, wl_m3, False), aux.energy_form("Wavelength", "microns", wl_microns1, wl_microns2, wl_microns3, False), aux.energy_form("Wavelength", "nm", wl_nm1, wl_nm2, wl_nm3, False), aux.energy_form("Wavenumber", "m^-1", wn_m_inv1, wn_m_inv2, wn_m_inv3, True), aux.energy_form("Wavenumber", "cm^-1", wn_cm_inv1, wn_cm_inv2, wn_cm_inv3, True)] # create name file pairs atmos_files = [] add_files(atmos_files, "data/Backgrounds/Atmospheric sites/") source_files = [] add_files(source_files, "data/Sources/") galactic_files = [] add_files(galactic_files, "data/Backgrounds/Galactic Emission/") # material constants for thermal mirror emission mirror_consts = {"Aluminum (Al)" : 3.538e7, "Beryllium (Be)": 2.500e7, "Gold (Au)" : 4.060e7, "Silver (Ag)" : 6.287e7} zodiac_files = [] add_files(zodiac_files, "data/Backgrounds/Zodiacal Emission/") main_gui = gui(energy_list, atmos_files, source_files, galactic_files, mirror_consts, zodiac_files) sys.exit(app.exec_())
import os dir = os.path.dirname(os.path.abspath(__file__)) os.chdir(dir) from gui import gui import tkinter as tk root = tk.Tk() app = gui(master=root) app.mainloop()
def mainloop(stdscr): while(True): # loop for games screen=gui.gui(stdscr) screen.update() #c = stdscr.getch() theBoard = Board() mode = 'pvc' #getGameMode() playerLetter, player2letter = "X", "O" #inputPlayerLetter() #turn = whoGoesFirst() turn = 'player 1' screen.printstr('The ' + turn + ' will go first.') lastMark = None # needed for keeping track of the last mark in order to facilitate collapse rec = 2 while (True): # loop for turns #if c == ord('q'): # exit() # Exit the while() #elif c == ord('r'): # stdscr.refresh() if turn == 'player 1': screen.printstr("It's player 1's turn") # Player 1's turn. theBoard.printBoard(screen) # Check whether there is entanglement after player 2's move if lastMark: if theBoard.findCycle(lastMark.pos): col = getPlayerCollapse(theBoard, lastMark,screen) # let player 1 decide where to put the last mark theBoard.collapse(lastMark.letter, lastMark.num, col[0], col[1]) theBoard.printBoard(screen) # look at winning conditions: p1won, p1lms = theBoard.hasWon(playerLetter) p2won, p2lms = theBoard.hasWon(player2letter) if p1won: if p2won: if p1lms < p2lms: #screen.printstr("\n") theBoard.printBoard(screen) screen.printstr("Player 1 has won the game!") break else: #screen.printstr("\n") theBoard.printBoard(screen) screen.printstr("Player 2 has won the game!") break else: #screen.printstr("\n") theBoard.printBoard(screen) screen.printstr("Player 1 has won the game!") break elif p2won: #screen.printstr("\n") theBoard.printBoard(screen) screen.printstr("Player 2 has won the game!") break else: if isBoardFull(theBoard): #print("\n") theBoard.printBoard(screen) print("The game is a tie!") break turn = "player2" # if the game hasn't ended, make a move pos1, pos2 = getPlayerMove(theBoard,screen) screen.update_moves(playerLetter,pos1, pos2) if lastMark: lastMark = theBoard.addPreMark(playerLetter, lastMark.num+1, pos1, pos2) else: lastMark = theBoard.addPreMark(playerLetter, 1, pos1, pos2) if mode != 'pvp': rec = getNumRecursions(screen) else: screen.printstr("It's player 2's turn") # Player 2's turn or computer. theBoard.printBoard(screen) val = None move = None if mode != 'pvp': if lastMark: [val, moves] = minimax(theBoard, rec, rec, True, player2letter, lastMark.num+1, playerLetter, lastMove = lastMark, savedMoves = []) else: [val, moves] = minimax(theBoard, rec, rec, True, player2letter, 1, playerLetter, lastMove = None, savedMoves = []) move = random.choice(moves) # Check whether there is entanglement after player 1's move if lastMark: if theBoard.findCycle(lastMark.pos): if mode == 'pvp': # if player vs player col = getPlayerCollapse(theBoard, lastMark,screen) # let player 2 decide where to put the last mark theBoard.collapse(lastMark.letter, lastMark.num, col[0], col[1]) theBoard.printBoard(screen) else: #col = getComputerCollapse_Random(theBoard, lastMark) #theBoard.collapse(lastMark.letter, lastMark.num, col[0], col[1]) theBoard.collapse(move[0][0], move[0][1], move[0][2], move[0][3]) theBoard.printBoard(screen) p1won, p1lms = theBoard.hasWon(playerLetter) p2won, p2lms = theBoard.hasWon(player2letter) if p1won: if p2won: if p1lms < p2lms: #screen.printstr("\n") theBoard.printBoard(screen) screen.printstr("Player 1 has won the game!") break else: #screen.printstr("\n") theBoard.printBoard(screen) if mode == 'pvp': screen.printstr("Player 2 has won the game!") else: screen.printstr("The computer has won the game!") break else: #screen.printstr("\n") theBoard.printBoard(screen) screen.printstr("Player 1 has won the game!") break elif p2won: #screen.printstr("\n") theBoard.printBoard(screen) if mode == 'pvp': screen.printstr("Player 2 has won the game!") else: screen.printstr("The computer has won the game!") break else: if isBoardFull(theBoard): #print("\n") theBoard.printBoard(screen) print("The game is a tie!") break turn = "player 1" # if the game hasn't ended, make a move if mode == 'pvp': pos1, pos2 = getPlayerMove(theBoard,screen) if lastMark: lastMark = theBoard.addPreMark(player2letter, lastMark.num+1, pos1, pos2) screen.update_moves(player2letter,pos1, pos2) else: lastMark = theBoard.addPreMark(player2letter, 1, pos1, pos2) screen.update_moves(player2letter,pos1, pos2) else: #pos1, pos2 = getComputerMove_Random(theBoard) lastMark = theBoard.addPreMark(move[1][0], move[1][1], move[1][2], move[1][3]) screen.update_moves(move[1][0],move[1][2], move[1][3]) if not playAgain(screen): break
def gui_loop(gui_hard, gui_post): from gui import gui s = gui(gui_hard, gui_post) s.mainloop()
# run_gui.py # # Init script, meant to generate gui. Called by gui thread of daq. When this # terminates, the whole app will terminate. It is run as a text file, not a # module (this affects the scope of variables defined/changed) # import gtk import posix import gui app = gui.gui() # These variables are used to change the state of user interface upon # completion of a task, to plot data, change progressbar val etc. gui_exports = { 'purgatory': app.purgatory, 'on_finished': app.on_logic_finished, 'plot': app.wTree.plot, 'progressbar': app.wTree.progressbar } gtk.gdk.threads_init() gtk.gdk.threads_enter() gtk.main() gtk.gdk.threads_leave()
import gui import enemy #global constants screen_dimensions = 640, 480 #initialize pygame library pygame.init() #set up the screen screen = pygame.display.set_mode(screen_dimensions) #set window title pygame.display.set_caption("Poncho") #create the gui overlay that gives info about the game to the player gui_overlay = gui.gui() #create kid and set default position kid = character.character() #hook up the player to the gui gui_overlay.set_player(kid) #convert image for bullet to screen format bullet.bullet_image = bullet.bullet_image.convert_alpha() #create a red tile for testing red_tile = pygame.Surface((tilemap.tile_size,tilemap.tile_size)) red_tile.fill(0xFF0000) #create a blue tile for testing