def initialize(self): self.w1 = Window(5, 5, 15, 15, title='Window 1', framed=True, window_manager=self.window_manager) self.w2 = Window(10, 10, 20, 30, title='Window 2', framed=True, window_manager=self.window_manager) self.list_view = ListWindow(tlx=15, tly=15, width=20, height=5, title='List Window', framed=True, window_manager=self.window_manager) self.list_view.add_item('An item.', 'An item.') self.list_view.add_item('Another item.', 'Uhuh.') self.list_view.add_item('Keep going.', 'Number.') self.list_view.add_item('Scrolling yet?', 'Scroll') self.list_view.add_item('last one', 'the end.')
def __init__(self, beam_setup, root_frame): """Initialise the window""" self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 root_frame, SHARE_DIR + "twiss_setup.json") self.beam_setup = beam_setup self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def run(): Log.log_application_name = "Test" Log.log("Starting...") window = Window() window.add_workspace(WsStart) window.add_workspace(WsTest) window.activate_workspace(WsStart) window.run()
def __init__(self, main_window, parent): """Initialise the GUI window""" self.main_window = main_window self.parent = parent manipulators = {"magnet_setup_action": self.magnet_setup_action} self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, data_file=self.share_dir + "magnet_setup.json", manipulator_dict=manipulators) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
class DashboardThread(Thread): def __init__(self): super().__init__() self.window = None def run(self): logger.debug(f'{self.__class__.__name__} started') self.window = Window() logger.debug(f'{self.__class__.__name__} ready') self.window.work() logger.debug(f'{self.__class__.__name__} finished') def handle(self, state, out=None): if self.window is not None: self.window.handle(state, out) else: logger.debug('Window is None, can not handle incoming') def set_stop(self): if self.window is not None: self.window.add_event(QUIT) else: logger.debug('Window is None, can not stop') def clear(self): if self.window is not None: self.window.clear() else: logger.debug('Window is None, can not handle clear')
class Application(QtGui.QApplication): """ Main application representation. """ def __init__(self, simulation): super(Application, self).__init__(sys.argv) self.frame = Window(simulation=simulation) self.sim = simulation self.frame.show() def run(self): """ Starts the QT mainloop for application. """ sys.exit(self.exec_())
def __init__(self, main_window, parent): """Initialise the window""" self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, SHARE_DIR + "beam_setup.json") self.main_window = main_window self.parent = parent self.matrix_select = None self.matrix = None self.window.set_button_action("&Penn", self.penn_action) self.window.set_button_action("&Twiss", self.twiss_action) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def main(stdscr): test = Window(30, 30, 0, 0) while True: test.clear() test.add_str(0, 0, "Lines: {} Colums: {}".format(curses.LINES, curses.COLS)) test.add_str(1, 0, "{}".format(stdscr.getmaxyx())) stdscr.getkey()
def configure(self, parent): """ Show the configuration window """ if self.cfgWindow is None: from gui.window import Window self.cfgWindow = Window('IMStatus.ui', 'vbox1', __name__, _(MOD_NAME), 440, 290) # GTK handlers self.cfgWindow.getWidget('rad-stopDoNothing').connect('toggled', self.onRadToggled) self.cfgWindow.getWidget('rad-stopSetStatus').connect('toggled', self.onRadToggled) self.cfgWindow.getWidget('btn-ok').connect('clicked', self.onBtnOk) self.cfgWindow.getWidget('btn-cancel').connect('clicked', lambda btn: self.cfgWindow.hide()) self.cfgWindow.getWidget('btn-help').connect('clicked', self.onBtnHelp) if not self.cfgWindow.isVisible(): self.cfgWindow.getWidget('txt-status').set_text(prefs.get(__name__, 'status-msg', DEFAULT_STATUS_MSG)) self.cfgWindow.getWidget('chk-updateOnPaused').set_active(prefs.get(__name__, 'update-on-paused', DEFAULT_UPDATE_ON_PAUSED)) self.cfgWindow.getWidget('chk-updateWhenAway').set_active(prefs.get(__name__, 'update-when-away', DEFAULT_UPDATE_WHEN_AWAY)) self.cfgWindow.getWidget('rad-stopDoNothing').set_active(prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_DO_NOTHING) self.cfgWindow.getWidget('rad-stopSetStatus').set_active(prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_SET_STATUS) self.cfgWindow.getWidget('txt-stopStatus').set_sensitive(prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_SET_STATUS) self.cfgWindow.getWidget('txt-stopStatus').set_text(prefs.get(__name__, 'stop-status', DEFAULT_STOP_STATUS)) self.cfgWindow.getWidget('txt-sanitizedWords').get_buffer().set_text(prefs.get(__name__, 'sanitized-words', DEFAULT_SANITIZED_WORDS)) self.cfgWindow.getWidget('btn-ok').grab_focus() self.cfgWindow.show()
def main(): window, size = Window() sidebar = LoadSidebar(window) navigator = LoadNavigator(window, size) canvas, charts = LoadCanvas(window, size) status = StringVar(value=WAITING) # 程序状态 1. 未开始 2. 计算中 3. 结果 updateStatus = bindStatus(status) addLabel(navigator, status) addCommand(sidebar, COMPUTE_LABEL_P, startFetch(FETCH_P, updateStatus)) addCommand(sidebar, COMPUTE_LABEL_V, startFetch(FETCH_V, updateStatus)) addCommand(sidebar, CLEAR_LABEL, clearUI(updateStatus)) addCommand(sidebar, SAVE_LABEL, save) addCommand(sidebar, UPLOAD_LABEL, upload) window.mainloop()
def __init__(self, beam_setup, root_frame): """Initialise the window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 root_frame, SHARE_DIR+"twiss_setup.json") self.beam_setup = beam_setup self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def __init__(self): """Initialise the main window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable=E1101 ROOT.gClient.GetRoot(), # pylint: disable=E1101 SHARE_DIR+"main_frame.json") self.lattice = Lattice() self.beam_setup = None self.magnet_setup = None self.plot_setup = None self.plot_setup_options = [{"variable_type":0, "first_var":0, "plot_apertures":True}] self.window.set_button_action("&Beam Setup", self.beam_button_action) self.window.set_button_action("&Magnet Setup", self.magnet_button_action) self.window.set_button_action("&Plot Setup", self.plot_button_action) self.window.set_button_action("E&xit", self.exit_button_action) self.update_plot()
def __init__(self, main_window, parent, selected): """ Initialise the window """ self.main_window = main_window self.parent = parent self.selected = selected self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, self.share_dir + "plot_setup.json") for i, item in enumerate(self.selected): self.window.set_action("variable_type_" + str(i), "drop_down", "Selected(Int_t)", self.select_action) type_frame = self.window.get_frame("variable_type_" + str(i), "drop_down") type_frame.Select(item["variable_type"]) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def main(): """main函数""" app = Window() queue = Queue() watcher.start() for _ in range(4): reg = Recognize(queue, watcher.original_cmd()) reg.start() camera = CameraTools(queue, 8500) camera.start_monitor() board = BoardTools() board.start_monitor() app.show()
def __init__(self, main_window, parent): """Initialise the GUI window""" self.main_window = main_window self.parent = parent manipulators = {"magnet_setup_action":self.magnet_setup_action} self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, data_file = self.share_dir+"magnet_setup.json", manipulator_dict = manipulators) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def __init__(self, main_window, parent): """Initialise the window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, SHARE_DIR+"beam_setup.json") self.main_window = main_window self.parent = parent self.matrix_select = None self.matrix = None self.window.set_button_action("&Penn", self.penn_action) self.window.set_button_action("&Twiss", self.twiss_action) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def __init__(self, datacards): """Initialise the main window""" self.last = datetime.datetime.now() self.window = Window(ROOT.gClient.GetRoot(), ROOT.gClient.GetRoot(), SHARE_DIR + "online_gui.json") self._set_actions() self._docstore = None self._datacards = datacards self._draw_titles = Queue.Queue() for title in datacards["online_gui_default_canvases"]: self._draw_titles.put(title) self._canvases_read = Queue.Queue() self._canvases_draw = ThreadedValue([]) self._redraw_target = None self._paused = ThreadedValue(False) rotate_tmp = self.window.get_text_entry("Rotate period", type(1.)) self._rotate_period = ThreadedValue(rotate_tmp) reload_tmp = self.window.get_text_entry("Reload period", type(1.)) self._reload_period = ThreadedValue(reload_tmp) self._poll_period = ThreadedValue(0.1) self._collections = ThreadedValue([]) self._init_docstore() self._start_polling()
def configure(self, parent): """ Show the configuration window """ if self.cfgWin is None: from gui.window import Window self.cfgWin = Window('Covers.ui', 'vbox1', __name__, MOD_INFO[modules.MODINFO_L10N], 320, 265) self.cfgWin.getWidget('btn-ok').connect('clicked', self.onBtnOk) self.cfgWin.getWidget('img-lastfm').set_from_file( os.path.join(consts.dirPix, 'audioscrobbler.png')) self.cfgWin.getWidget('btn-help').connect('clicked', self.onBtnHelp) self.cfgWin.getWidget('chk-downloadCovers').connect( 'toggled', self.onDownloadCoversToggled) self.cfgWin.getWidget('btn-cancel').connect( 'clicked', lambda btn: self.cfgWin.hide()) if not self.cfgWin.isVisible(): downloadCovers = prefs.get(__name__, 'download-covers', PREFS_DFT_DOWNLOAD_COVERS) preferUserCovers = prefs.get(__name__, 'prefer-user-covers', PREFS_DFT_PREFER_USER_COVERS) userCoverFilenames = prefs.get(__name__, 'user-cover-filenames', PREFS_DFT_USER_COVER_FILENAMES) self.cfgWin.getWidget('btn-ok').grab_focus() self.cfgWin.getWidget('txt-filenames').set_text( ', '.join(userCoverFilenames)) self.cfgWin.getWidget('chk-downloadCovers').set_active( downloadCovers) self.cfgWin.getWidget('chk-preferUserCovers').set_active( preferUserCovers) self.cfgWin.getWidget('chk-preferUserCovers').set_sensitive( downloadCovers) self.cfgWin.show()
def __init__(self): self.config_path = join_path('utils/config.json') font_id = Qt.QFontDatabase.addApplicationFont( join_path("static/iconfont.ttf")) self.ico_font = Qt.QFont( Qt.QFontDatabase.applicationFontFamilies(font_id)[0], 30) self.config = {} self.load_config() self.Setting = Setting(self) self.Window = Window(self) self.Tray = Tray(self) if self.config['show_setting_window']: self.Setting.show() self.config['show_setting_window'] = False self.dump_config()
def __init__(self, main_window, parent, selected): """ Initialise the window """ self.main_window = main_window self.parent = parent self.selected = selected self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, self.share_dir+"plot_setup.json") for i, item in enumerate(self.selected): self.window.set_action("variable_type_"+str(i), "drop_down", "Selected(Int_t)", self.select_action) type_frame = self.window.get_frame("variable_type_"+str(i), "drop_down") type_frame.Select(item["variable_type"]) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action)
def __init__(self, datacards): """Initialise the main window""" self.last = datetime.datetime.now() self.window = Window(ROOT.gClient.GetRoot(), ROOT.gClient.GetRoot(), SHARE_DIR+"online_gui.json") self._set_actions() self._docstore = None self._datacards = datacards self._draw_titles = Queue.Queue() for title in datacards["online_gui_default_canvases"]: self._draw_titles.put(title) self._canvases_read = Queue.Queue() self._canvases_draw = ThreadedValue([]) self._redraw_target = None self._paused = ThreadedValue(False) rotate_tmp = self.window.get_text_entry("Rotate period", type(1.)) self._rotate_period = ThreadedValue(rotate_tmp) reload_tmp = self.window.get_text_entry("Reload period", type(1.)) self._reload_period = ThreadedValue(reload_tmp) self._poll_period = ThreadedValue(0.1) self._collections = ThreadedValue([]) self._init_docstore() self._start_polling()
def __init__(self, stdscr): curses.curs_set(0) curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_MAGENTA) self.clipbord = None self.tab_manager = Tab_manager( os.path.dirname(os.path.abspath(__file__))) self.stdscr = Window(curses.LINES, curses.COLS, 0, 0) self.stdscr.window = stdscr self.stdscr.refresh() self.parent_dir_widged = File_viewer( self.stdscr.x - 3, round(config.parent_dir_width * self.stdscr.y / 100), 1, 0, self.tab_manager.selected_tab.current_file.parent_dir, self.tab_manager.selected_tab.current_file) self.current_dir_widged = File_viewer( self.stdscr.x - 3, round(config.current_dir_width * self.stdscr.y / 100), 1, self.parent_dir_widged.y, self.tab_manager.selected_tab.current_file, self.tab_manager.selected_tab.selected_file, True) self.preview_widged = File_viewer( self.stdscr.x - 3, self.stdscr.y - self.parent_dir_widged.y - self.current_dir_widged.y - 1, 1, self.stdscr.y - (self.stdscr.y - self.parent_dir_widged.y - self.current_dir_widged.y - 1), self.tab_manager.selected_tab.selected_file) self.statusbar = Statusbar( 1, self.stdscr.y, 0, 0, getpass.getuser(), socket.gethostname(), self.tab_manager.selected_tab.current_file.path, self.tab_manager.tab_list) self.window_command = Window(1, self.stdscr.y, self.stdscr.x - 1, 0) self.window_info = Window(1, self.stdscr.y, self.stdscr.x - 2, 0) self.stdscr.refresh() #self.resize() self.stdscr.refresh() self.mainloop()
class PennSetup: """GUI window to setup a beam according to 4D Penn parameterisation""" def __init__(self, beam_setup, root_frame): """Initialise the window""" self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 root_frame, SHARE_DIR + "penn_setup.json") self.beam_setup = beam_setup self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) self.window.set_button_action("Get &B0", self.get_b0_action) self.window.set_button_action("&Constant Beta", self.constant_beta_action) def okay_action(self): """Handle a click on the Okay button, building the beam matrix""" ref = self.beam_setup.get_reference() matrix = maus_cpp.covariance_matrix.create_from_penn_parameters( mass=ref['mass'], momentum=ref['p'], emittance_t=self.window.get_text_entry("emittance_trans", type(1.)), beta_t=self.window.get_text_entry("beta_trans", type(1.)), emittance_l=self.window.get_text_entry("emittance_l", type(1.)), beta_l=self.window.get_text_entry("beta_l", type(1.)), alpha_t=self.window.get_text_entry("alpha_trans", type(1.)), alpha_l=self.window.get_text_entry("alpha_l", type(1.)), charge=ref["charge"], # BUG - multiply by -1 to fix BUG in source code bz=-self.window.get_text_entry("B0", type(1.)) * common.units['T'], ltwiddle=self.window.get_text_entry("Lc", type(1.)), dispersion_x=self.window.get_text_entry("disp_x", type(1.)), dispersion_prime_x=self.window.get_text_entry( "disp_prime_x", type(1.)), dispersion_y=self.window.get_text_entry("disp_y", type(1.)), dispersion_prime_y=self.window.get_text_entry( "disp_prime_y", type(1.))) self.beam_setup.set_matrix(matrix) self.beam_setup.get_matrix() # check for consistency self.window.close_window() self.beam_setup.matrix_select = None def cancel_action(self): """Handle a click on the Cancel button""" self.window.close_window() self.beam_setup.matrix_select = None def get_b0_action(self): """ Handle a click on the Get B0 button, getting B magnitude at the location of the reference particle """ ref = self.beam_setup.get_reference() b_vec = maus_cpp.field.get_field_value(ref['x'], ref['y'], ref['z'], ref['t']) _b0 = (b_vec[0]**2 + b_vec[1]**2 + b_vec[2]**2)**0.5 self.window.set_text_entry('B0', _b0 * common.units['T']) def constant_beta_action(self): """ Handle a click on the Constant Beta button, getting beta function that would be required to get a constant beta function, given other settings (reference particle, B0, Lc) """ _b0 = abs(self.window.get_text_entry("B0", type(1.)) * 1e-3) # kT if abs(_b0) < 1e-9: raise ValueError( "Constant beta requires B0 is not 0. "+\ "Modify the B0 field and try again." ) _lc = self.window.get_text_entry("Lc", type(1.)) # kT mom = self.beam_setup.get_reference()['p'] # MeV/c charge = abs(self.beam_setup.get_reference()['charge']) # eplus beta = (1 + _lc** 2)**0.5 * 2. * charge * mom / common.constants['c_light'] / _b0 self.window.set_text_entry('alpha_trans', 0.0) self.window.set_text_entry('beta_trans', beta) # beta in mm
class MainWindow(): """ Defines the main window for the envelope tool GUI """ def __init__(self): """Initialise the main window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable=E1101 ROOT.gClient.GetRoot(), # pylint: disable=E1101 SHARE_DIR+"main_frame.json") self.lattice = Lattice() self.beam_setup = None self.magnet_setup = None self.plot_setup = None self.plot_setup_options = [{"variable_type":0, "first_var":0, "plot_apertures":True}] self.window.set_button_action("&Beam Setup", self.beam_button_action) self.window.set_button_action("&Magnet Setup", self.magnet_button_action) self.window.set_button_action("&Plot Setup", self.plot_button_action) self.window.set_button_action("E&xit", self.exit_button_action) self.update_plot() def beam_button_action(self): """Handle a Beam Setup button press""" if self.beam_setup == None: self.beam_setup = BeamSetup(self, self.window.main_frame) ref, ellipse = self.lattice.get_beam() self.beam_setup.set_reference(ref) self.beam_setup.set_matrix(ellipse) def magnet_button_action(self): """Handle a Magnet Setup button press""" if self.magnet_setup == None: self.magnet_setup = MagnetSetup(self, self.window.main_frame) def plot_button_action(self): """Handle a Plot Setup button press""" if self.plot_setup == None: self.plot_setup = PlotSetup(self, self.window.main_frame, self.plot_setup_options) def exit_button_action(self): """Handle a Exit button press""" self.window.close_window() def update_plot(self): """Update the plot""" canvas_frame = self.window.get_frame("main_canvas", "canvas") canvas = canvas_frame.GetCanvas() Plotter(self.plot_setup_options, canvas, self.lattice.ref_list, self.lattice.ellipse_list, self.lattice.get_field_list())
class IMStatus(modules.Module): def __init__(self): """ Constructor """ handlers = { consts.MSG_EVT_PAUSED: self.onPaused, consts.MSG_EVT_STOPPED: self.onStopped, consts.MSG_EVT_UNPAUSED: self.onUnpaused, consts.MSG_EVT_APP_QUIT: self.onStopped, consts.MSG_EVT_NEW_TRACK: self.onNewTrack, consts.MSG_EVT_MOD_LOADED: self.onModLoaded, consts.MSG_EVT_APP_STARTED: self.onModLoaded, consts.MSG_EVT_MOD_UNLOADED: self.onStopped, } modules.Module.__init__(self, handlers) def __format(self, string, track): """ Replace the special fields in the given string by their corresponding value and sanitize the result """ result = track.format(string) if len(prefs.get(__name__, 'sanitized-words', DEFAULT_SANITIZED_WORDS)) != 0: lowerResult = result.lower() for word in [w.lower() for w in prefs.get(__name__, 'sanitized-words', DEFAULT_SANITIZED_WORDS).split('\n') if len(w) > 2]: pos = lowerResult.find(word) while pos != -1: result = result[:pos+1] + ('*' * (len(word)-2)) + result[pos+len(word)-1:] lowerResult = lowerResult[:pos+1] + ('*' * (len(word)-2)) + lowerResult[pos+len(word)-1:] pos = lowerResult.find(word) return result def setStatusMsg(self, status): """ Update the status of all accounts of all active IM clients """ for client in self.clients: for account in client[IM_ACCOUNTS]: client[IM_INSTANCE].setStatusMsg(account, status) # --== Message handlers ==-- def onModLoaded(self): """ Initialize the module """ self.track = None # Current track self.status = '' # The currently used status self.paused = False # True if the current track is paused self.clients = [] # Clients currently active self.cfgWindow = None # Configuration window # Detect active clients try: import dbus session = dbus.SessionBus() activeServices = session.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus').ListNames() for activeClient in [client for client in CLIENTS if client[IM_DBUS_SERVICE_NAME] in activeServices]: obj = session.get_object(activeClient[IM_DBUS_SERVICE_NAME], activeClient[IM_DBUS_OBJECT_NAME]) interface = dbus.Interface(obj, activeClient[IM_DBUS_INTERFACE_NAME]) activeClient[IM_INSTANCE] = activeClient[IM_CLASS](interface) activeClient[IM_ACCOUNTS] = activeClient[IM_INSTANCE].listAccounts() logger.info('[%s] Found %s instance' % (MOD_NAME, activeClient[IM_NAME])) self.clients.append(activeClient) except: logger.error('[%s] Error while initializing\n\n%s' % (MOD_NAME, traceback.format_exc())) def onNewTrack(self, track): """ A new track is being played """ self.track = track self.status = self.__format(prefs.get(__name__, 'status-msg', DEFAULT_STATUS_MSG), track) self.paused = False self.setStatusMsg(self.status) def onStopped(self): """ The current track has been stopped """ self.track = None self.paused = False if prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_SET_STATUS: self.setStatusMsg(prefs.get(__name__, 'stop-status', DEFAULT_STOP_STATUS)) def onPaused(self): """ The current track has been paused """ self.paused = True if prefs.get(__name__, 'update-on-paused', DEFAULT_UPDATE_ON_PAUSED): self.setStatusMsg(_('%(status)s [paused]') % {'status': self.status}) def onUnpaused(self): """ The current track has been unpaused """ self.paused = False self.setStatusMsg(self.status) # --== Configuration ==-- def configure(self, parent): """ Show the configuration window """ if self.cfgWindow is None: from gui.window import Window self.cfgWindow = Window('IMStatus.ui', 'vbox1', __name__, _(MOD_NAME), 440, 290) # GTK handlers self.cfgWindow.getWidget('rad-stopDoNothing').connect('toggled', self.onRadToggled) self.cfgWindow.getWidget('rad-stopSetStatus').connect('toggled', self.onRadToggled) self.cfgWindow.getWidget('btn-ok').connect('clicked', self.onBtnOk) self.cfgWindow.getWidget('btn-cancel').connect('clicked', lambda btn: self.cfgWindow.hide()) self.cfgWindow.getWidget('btn-help').connect('clicked', self.onBtnHelp) if not self.cfgWindow.isVisible(): self.cfgWindow.getWidget('txt-status').set_text(prefs.get(__name__, 'status-msg', DEFAULT_STATUS_MSG)) self.cfgWindow.getWidget('chk-updateOnPaused').set_active(prefs.get(__name__, 'update-on-paused', DEFAULT_UPDATE_ON_PAUSED)) self.cfgWindow.getWidget('chk-updateWhenAway').set_active(prefs.get(__name__, 'update-when-away', DEFAULT_UPDATE_WHEN_AWAY)) self.cfgWindow.getWidget('rad-stopDoNothing').set_active(prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_DO_NOTHING) self.cfgWindow.getWidget('rad-stopSetStatus').set_active(prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_SET_STATUS) self.cfgWindow.getWidget('txt-stopStatus').set_sensitive(prefs.get(__name__, 'stop-action', DEFAULT_STOP_ACTION) == STOP_SET_STATUS) self.cfgWindow.getWidget('txt-stopStatus').set_text(prefs.get(__name__, 'stop-status', DEFAULT_STOP_STATUS)) self.cfgWindow.getWidget('txt-sanitizedWords').get_buffer().set_text(prefs.get(__name__, 'sanitized-words', DEFAULT_SANITIZED_WORDS)) self.cfgWindow.getWidget('btn-ok').grab_focus() self.cfgWindow.show() def onRadToggled(self, btn): """ A radio button has been toggled """ self.cfgWindow.getWidget('txt-stopStatus').set_sensitive(self.cfgWindow.getWidget('rad-stopSetStatus').get_active()) def onBtnOk(self, btn): """ Save new preferences """ prefs.set(__name__, 'status-msg', self.cfgWindow.getWidget('txt-status').get_text()) prefs.set(__name__, 'update-on-paused', self.cfgWindow.getWidget('chk-updateOnPaused').get_active()) prefs.set(__name__, 'update-when-away', self.cfgWindow.getWidget('chk-updateWhenAway').get_active()) (start, end) = self.cfgWindow.getWidget('txt-sanitizedWords').get_buffer().get_bounds() prefs.set(__name__, 'sanitized-words', self.cfgWindow.getWidget('txt-sanitizedWords').get_buffer().get_text(start, end).strip()) if self.cfgWindow.getWidget('rad-stopDoNothing').get_active(): prefs.set(__name__, 'stop-action', STOP_DO_NOTHING) else: prefs.set(__name__, 'stop-action', STOP_SET_STATUS) prefs.set(__name__, 'stop-status', self.cfgWindow.getWidget('txt-stopStatus').get_text()) self.cfgWindow.hide() # Update status if self.track is not None: self.status = self.__format(prefs.get(__name__, 'status-msg', DEFAULT_STATUS_MSG), self.track) if self.paused: self.setStatusMsg(_('%(status)s [paused]') % {'status': self.status}) else: self.setStatusMsg(self.status) def onBtnHelp(self, btn): """ Display a small help message box """ import gui.help, media.track helpDlg = gui.help.HelpDlg(_(MOD_NAME)) helpDlg.addSection(_('Description'), _('This module detects any running instant messenger and updates your status with regards to the track ' 'you are listening to. Supported messengers are:') + '\n\n * ' + '\n * '.join(sorted([client[IM_NAME] for client in CLIENTS]))) helpDlg.addSection(_('Customizing the Status'), _('You can set the status to any text you want. Before setting it, the module replaces all fields of ' 'the form {field} by their corresponding value. Available fields are:') + '\n\n' + media.track.getFormatSpecialFields(False)) helpDlg.addSection(_('Markup'), _('You can use the Pango markup language to format the text. More information on that language is ' 'available on the following web page:') + '\n\nhttp://www.pygtk.org/pygtk2reference/pango-markup-language.html') helpDlg.addSection(_('Sanitization'), _('You can define some words that to sanitize before using them to set your status. In this ' 'case, the middle characters of matching words is automatically replaced with asterisks ' '(e.g., "Metallica - Live S**t Binge & Purge"). Put one word per line.')) helpDlg.show(self.cfgWindow)
''' The start point of the client. ''' from gui.window import Window if __name__ == '__main__': window = Window() # testing for i in range(100): window._log.add_to_log("line"+str(i)) window._contacts.load_list(("foo", "bar")) # end testing window.mainloop()
class MagnetSetup: """ GUI handler for field setup """ def __init__(self, main_window, parent): """Initialise the GUI window""" self.main_window = main_window self.parent = parent manipulators = {"magnet_setup_action":self.magnet_setup_action} self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, data_file = self.share_dir+"magnet_setup.json", manipulator_dict = manipulators) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def okay_action(self): """Handle okay button press""" field_list_out = [] field_frame = self.window.get_frame_dict("field_list", "vertical_frame") for frame in field_frame["children"]: try: name = frame["name"] scale_factor = float(frame["text_entry"].text_entry.GetText()) field_list_out.append({"field_name":name, "scale_factor":scale_factor}) except KeyError: pass self.main_window.lattice.set_fields(field_list_out) self.main_window.lattice.run_lattice() self.main_window.update_plot() self.window.close_window() self.main_window.magnet_setup = None def cancel_action(self): """Handle cancel button press""" self.window.close_window() self.main_window.magnet_setup = None def magnet_setup_action(self, item): # pylint: disable=W0613 """Iterate over magnets and add a line per magnet (special)""" field_list = self.main_window.lattice.get_field_list() geometry_list = { "type":"vertical_frame", "layout":"close", "name":"field_list", "children":[]} if len(field_list) == 0: geometry_list["children"].append({"type":"label", "name":"No fields in lattice", "label_length":30}) return geometry_list for field in field_list: geometry_list["children"].append({ "type":"named_text_entry", "default_text":str(field["scale_factor"]), "label_length":10, "name":str(field["field_name"]), "tool_tip":"Longitudinal beta function" }) return geometry_list share_dir = ""
def viewer_window_provider(title): return Window(None, -3, -1, 3, 0, self.window.internal_renderer)
class OnlineGui(): # pylint: disable = R0902 """Main frame for the online gui window""" def __init__(self, datacards): """Initialise the main window""" self.last = datetime.datetime.now() self.window = Window(ROOT.gClient.GetRoot(), ROOT.gClient.GetRoot(), SHARE_DIR+"online_gui.json") self._set_actions() self._docstore = None self._datacards = datacards self._draw_titles = Queue.Queue() for title in datacards["online_gui_default_canvases"]: self._draw_titles.put(title) self._canvases_read = Queue.Queue() self._canvases_draw = ThreadedValue([]) self._redraw_target = None self._paused = ThreadedValue(False) rotate_tmp = self.window.get_text_entry("Rotate period", type(1.)) self._rotate_period = ThreadedValue(rotate_tmp) reload_tmp = self.window.get_text_entry("Reload period", type(1.)) self._reload_period = ThreadedValue(reload_tmp) self._poll_period = ThreadedValue(0.1) self._collections = ThreadedValue([]) self._init_docstore() self._start_polling() def _set_actions(self): """ Set up actions (responses to signals) """ self.window.set_button_action("&Pause", self.pause_action) self.window.set_button_action("&Redraw", self.redraw_action) self.window.set_button_action("Re&load", self.reload_action) self.window.set_button_action("Re&connect", self.reconnect_action) self.window.set_button_action("E&xit", self.exit_action) self.window.set_button_action("&<", self.back_action) self.window.set_button_action("&>", self.forward_action) self.window.get_frame("canvas_options", "vertical_frame").\ Resize(200, 500) self.window.get_frame("canvas_select", "list_box").Resize(200, 200) self.window.set_action("canvas_select", "list_box", "SelectionChanged()", self.canvas_select_action) self.window.set_action("Rotate period", "named_text_entry", "ReturnPressed()", self.rotate_period_action) self.window.set_action("Reload period", "named_text_entry", "ReturnPressed()", self.reload_period_action) def _init_docstore(self): """ Initialise the docstore """ datacards = self._datacards self._docstore = RootDocumentStore( datacards["root_document_store_timeout"], datacards["root_document_store_poll_time"], 10, 10) self._docstore.connect({"host":datacards["online_gui_host"], "port":datacards["online_gui_port"]}) def _start_polling(self): """ Start polling the database and rotating the canvases """ my_thread = threading.Thread(target=self._poll_canvas_draw, args=()) my_thread.daemon = True my_thread.start() my_thread = threading.Thread(target=self._poll_docstore, args=()) my_thread.daemon = True my_thread.start() def pause_action(self): """Handle a Pause/Unpause button press""" pause_button = self.window.get_frame("&Pause", "button") if self._paused.get_value(): self._paused.set_value(False) pause_button.SetText("&Pause") else: self._paused.set_value(True) pause_button.SetText("&Play") def redraw_action(self): """ Handle a Redraw button press Redraws self._redraw_target """ if self._redraw_target == None: raise GuiError("No canvas to draw") self._do_redraw(self._redraw_target) def reload_action(self): """Handle a Reload button press""" self._reload() if self._redraw_target != None: go_back_fifo_queue(self._draw_titles) self._draw_next() def reconnect_action(self): """Handle a Reconnect button press""" self._docstore.disconnect() self._init_docstore() def exit_action(self): """Handle a Exit button press""" self._paused.set_value(True) # tell polling to wait time.sleep(self._poll_period.get_value()) # thinkapow self.window.close_window() def reload_period_action(self): """Handle a change to the reload period""" tmp_reload_period = self.window.get_text_entry("Reload period", type(1.)) tmp_reload_period = float(tmp_reload_period) self._reload_period.set_value(tmp_reload_period) def rotate_period_action(self): """Handle a change to the rotate period""" tmp_rotate_period = self.window.get_text_entry("Rotate period", type(1.)) tmp_rotate_period = float(tmp_rotate_period) self._rotate_period.set_value(tmp_rotate_period) def forward_action(self): """Handle a click on the > forward button""" self._draw_next() def back_action(self): """Handle a click on the < back button""" go_back_fifo_queue(self._draw_titles) go_back_fifo_queue(self._draw_titles) self._draw_next() def canvas_select_action(self): """Handle an update to the selected canvases""" selected = self._get_canvas_selected() new_draw_titles = Queue.Queue() for item in selected: new_draw_titles.put(item) self._draw_titles = new_draw_titles def _poll_canvas_draw(self): """ Iterate over the canvas_draw queue, updating the GUI as appropriate * Update the queue from the canvas_read queue * Refresh the combo box with items in the canvases_draw queue """ # poll_number = 0 while True: # poll_number += 1 self._draw_next() self._sleepish(self._rotate_period) # handle pause while self._paused.get_value(): time.sleep(self._poll_period.get_value()) def _draw_next(self): """ Draw the next canvas in the selected queue """ canvases_draw = self._filter_canvases(self._canvases_draw.get_value()) if len(canvases_draw) > 0: try: title = self._draw_titles.get_nowait() new_title = copy.deepcopy(title) self._draw_titles.put(title) for wrap in canvases_draw: if wrap.canvas_title() == new_title: self._do_redraw(wrap) break except Queue.Empty: pass # no canvas selected except ValueError: pass self._canvases_draw.set_value(canvases_draw) def _sleepish(self, sleep_length): """ Sleep - but keep polling for changes to the sleep_length * sleep_length - threaded value containing numeric sleep time """ time_slept = 0. poll_period = self._poll_period.get_value() while sleep_length.get_value() - time_slept > poll_period: time_slept += self._poll_period.get_value() time.sleep(poll_period) def _update_canvases_draw(self): """update canvases""" draw = [wrap.deepcopy() \ for wrap in generate_fifo_queue(self._canvases_read)] draw.sort(key = lambda wrap: wrap.sort_key()) return draw def _do_redraw(self, wrap): """ Draw the canvas wrap in the main_canvas """ # wrap_copy is for ROOT wrap_copy = wrap.deepcopy() embedded_canvas = self.window.get_frame("main_canvas", "canvas") # this eats the wrap_copy TCanvas wrap_copy.canvas_wrapper.EmbedCanvas(embedded_canvas) embedded_canvas.GetCanvas().Update() # this _redraw_target is for the main thread self._redraw_target = wrap.deepcopy() def _poll_docstore(self): """ Poll the doc store for documents """ while True: print "poll_docstore" self._reload() self._sleepish(self._reload_period) # handle pause while self._paused.get_value(): time.sleep(self._poll_period.get_value()) def _reload(self): """ Reload canvases; if the list of canvases changed, update the multiselect """ self._reload_canvases() # now update GUI elements (each call iterates over the whole # _canvases_draw queue) self._update_canvas_select() def _update_canvas_select(self): """ Update the list of canvases in the canvas_select frame """ all_canvas_titles = [wrap.canvas_wrapper.GetCanvas().GetTitle() \ for wrap in generate_fifo_queue(self._canvases_read)] select_box = self.window.get_frame("canvas_select", "list_box") select_box.RemoveAll() for i, title in enumerate(all_canvas_titles): select_box.AddEntry(title, i) for title in generate_fifo_queue(self._draw_titles): try: index = all_canvas_titles.index(title) select_box.Select(index) except ValueError: # item was no longer in the select - ignore it pass go_back_fifo_queue(self._draw_titles) # ROOT doesn't like redrawing the histogram titles properly - need to # force it self.window.get_frame("canvas_select", "list_box").Resize(200, 10) self.window.get_frame("canvas_select", "list_box").Resize(200, 200) def _get_canvas_selected(self): """ Get the list of canvases selected in the canvas_select frame """ select_box = self.window.get_frame("canvas_select", "list_box") selected_root = ROOT.TList() selected = [] select_box.GetSelectedEntries(selected_root) while selected_root.Last() != None: selected.insert(0, copy.deepcopy(selected_root.Last().GetText())) selected_root.RemoveLast() return selected def _reload_canvases(self): """ Reload canvases from the docstore """ # get all of the collections (one for each reducer) try: collections = self._docstore.collection_names() except (DocumentStoreException, SocketError): print "Failed to get collection names from the docstore" return self._collections.set_value(collections) temp_canvases = [] # update "last accessed" timestamp self.last = datetime.datetime.now() # get new canvases for collection_name in collections: temp_canvases += self._get_new_canvases(collection_name) # purge any duplicate canvases filtered_canvases = self._filter_canvases(temp_canvases) # build a new queue and reassign _canvases_read canvases_read = Queue.Queue() for canvas in filtered_canvases: canvases_read.put_nowait(canvas) self._canvases_read = canvases_read self._collections.set_value(collections) def _get_new_canvases(self, collection_name): """ Get a list of new canvases from the collection """ try: doc_list = self._docstore.get_since(collection_name, self.last) except DocumentStoreException: print "Failed to get documents from the docstore" return [] if len(doc_list) == 0: return [] tree = doc_list[-1]["doc"] image_data = ROOT.MAUS.ImageData() tree.SetBranchAddress("data", image_data) if tree.GetEntries() == 0: return [] tree.GetEntry() return CanvasRewrapped.new_list_from_image(collection_name, image_data.GetImage()) def _filter_canvases(self, new_canvases): """ Enforce that we only have one copy with a given (collection, title) Note that we want to keep the item with the highest input_time if there is a choice """ combined_list = [wrap.deepcopy() \ for wrap in generate_fifo_queue(self._canvases_read)] combined_list += new_canvases combined_list.sort(key=lambda wrap: wrap.sort_key()) if len(combined_list) == 0: return [] filtered_list = [] for i, item_2 in enumerate(combined_list[1:]): item_1 = combined_list[i] if item_1.collection == item_2.collection and \ item_1.canvas_title() == item_2.canvas_title(): pass else: filtered_list.append(item_1) filtered_list.append(combined_list[-1]) return filtered_list
def main_window(title): return Window(title, -2, 0, 2, 0, self)
def __init__(self, simulation): super(Application, self).__init__(sys.argv) self.frame = Window(simulation=simulation) self.sim = simulation self.frame.show()
class BeamSetup: """GUI window to setup a reference particle and beam ellipse""" def __init__(self, main_window, parent): """Initialise the window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, SHARE_DIR+"beam_setup.json") self.main_window = main_window self.parent = parent self.matrix_select = None self.matrix = None self.window.set_button_action("&Penn", self.penn_action) self.window.set_button_action("&Twiss", self.twiss_action) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def twiss_action(self): """Handle Twiss button - open a window to set up Twiss parameters""" if self.matrix_select == None: self.matrix_select = TwissSetup(self, self.parent) def penn_action(self): """Handle Penn button - open a window to set up Penn parameters""" if self.matrix_select == None: self.matrix_select = PennSetup(self, self.parent) def okay_action(self): """ Handle Okay button - set the beam in lattice and then close the window """ if self.matrix_select != None: print "Close the matrix_select window" return self.main_window.lattice.set_beam(self.get_reference(), self.get_matrix()) self.main_window.lattice.run_lattice() self.main_window.update_plot() self.window.close_window() self.main_window.beam_setup = None def cancel_action(self): """ Handle Cancel button - just close the window """ if self.matrix_select != None: print "Close the matrix_select window" return self.window.close_window() self.main_window.beam_setup = None def set_matrix(self, matrix): """ Set the beam matrix (updating GUI elements) - matrix a maus_cpp.covariance_matrix.CovarianceMatrix object """ self.matrix = matrix for i, var_i in enumerate(["t", "e", "x", "px", "y", "py"]): for j, var_j in enumerate(["t", "e", "x", "px", "y", "py"]): value = matrix.get_element(i+1, j+1) self.window.set_text_entry(var_i+var_j, value) def get_matrix(self): """ Get the beam matrix (reading from GUI elements) Returns a maus_cpp.covariance_matrix.CovarianceMatrix object """ np_matrix = numpy.zeros([6, 6]) for i, var_i in enumerate(["t", "e", "x", "px", "y", "py"]): for j, var_j in enumerate(["t", "e", "x", "px", "y", "py"]): value1 = self.window.get_text_entry(var_i+var_j, type(1.)) value2 = self.window.get_text_entry(var_j+var_i, type(1.)) delta = abs(value1 - value2) if delta > 1e-6: err = "Matrix has non-symmetric element Cov("+\ var_i+","+var_j+") with delta "+str(delta)+"." err += "This element must be symmetric - upper "+\ "diagonal should be equal to lower diagonal." raise GuiError(err) else: np_matrix[i, j] = value1 evals = numpy.linalg.eigvals(np_matrix) if not numpy.all(evals > 0): evals = [i for i in evals] raise GuiError("Beam ellipse should be positive definite but "+\ " eigenvalues were not all positive: "+str(evals)) return maus_cpp.covariance_matrix.create_from_matrix(np_matrix) def set_reference(self, ref_hit): """ Get the reference particle (writing to GUI elements) - ref_hit an xboa.Hit.Hit object """ for var in ["x", "y", "z", "px", "py", "pz", "pid"]: self.window.set_text_entry(var, ref_hit[var]) def get_reference(self): """ Get the reference particle (reading from GUI elements) Returns an xboa.Hit.Hit object """ ref_dict = {} for var in ["x", "y", "z", "px", "py", "pz"]: var_dict = self.window.get_frame_dict(var, "named_text_entry") ref_dict[var] = float(var_dict["text_entry"].text_entry.GetText()) pid_dict = self.window.get_frame_dict("pid", "named_text_entry") try: ref_dict["pid"] = int(pid_dict["text_entry"].text_entry.GetText()) ref_dict["mass"] = common.pdg_pid_to_mass[abs(ref_dict["pid"])] ref_dict["charge"] = common.pdg_pid_to_charge[abs(ref_dict["pid"])] except KeyError: raise GuiError("Did not recognise reference particle pid") try: hit = Hit.new_from_dict(ref_dict, "energy") except Exception: raise GuiError("Failed to generate a reference particle") return hit
class Covers(modules.ThreadedModule): def __init__(self): """ Constructor """ handlers = { consts.MSG_EVT_APP_QUIT: self.onModUnloaded, consts.MSG_EVT_NEW_TRACK: self.onNewTrack, consts.MSG_EVT_MOD_LOADED: self.onModLoaded, consts.MSG_EVT_APP_STARTED: self.onModLoaded, consts.MSG_EVT_MOD_UNLOADED: self.onModUnloaded, } modules.ThreadedModule.__init__(self, handlers) def _generateCover(self, inFile, outFile, format, max_width, max_height): from PIL import Image try: # Open the image cover = Image.open(inFile) width = cover.size[0] height = cover.size[1] newWidth, newHeight = tools.resize(width, height, max_width, max_height) cover = cover.resize((newWidth, newHeight), Image.ANTIALIAS) cover.save(outFile, format) except Exception: # This message will probably be displayed for the thumbnail and the big cover. logger.error( '[%s] An error occurred while generating the cover for "%s"\n\n%s' % (MOD_NAME, inFile, traceback.format_exc())) # Remove corrupted file. tools.remove(outFile) def generateFullSizeCover(self, inFile, outFile, format): """ Resize inFile if needed, and write it to outFile (outFile and inFile may be equal) """ self._generateCover(inFile, outFile, format, FULL_SIZE_COVER_WIDTH, FULL_SIZE_COVER_HEIGHT) def generateThumbnail(self, inFile, outFile, format): """ Generate a thumbnail from inFile (e.g., resize it) and write it to outFile (outFile and inFile may be equal). """ self._generateCover(inFile, outFile, format, THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT) def getUserCover(self, trackPath): """ Return the path to a cover file in trackPath, None if no cover found """ # Create a dictionary with candidates candidates = {} for (file, path) in tools.listDir(trackPath, True): (name, ext) = os.path.splitext(file.lower()) if ext in ACCEPTED_FILE_FORMATS: candidates[name] = path # Check each possible name using the its index in the list as its priority for name in prefs.get(__name__, 'user-cover-filenames', PREFS_DFT_USER_COVER_FILENAMES): if name in candidates: return candidates[name] if name == '*' and len(candidates) != 0: return next(iter(candidates.values())) return None def getFromCache(self, artist, album): """ Return the path to the cached cover, or None if it's not cached """ cachePath = os.path.join(self.cacheRootPath, str(abs(hash(artist)))) cacheIdxPath = os.path.join(cachePath, 'INDEX') try: cacheIdx = tools.pickleLoad(cacheIdxPath) cover = os.path.join(cachePath, cacheIdx[artist + album]) if os.path.exists(cover): return cover except: pass return None def __getFromInternet(self, artist, album): """ Try to download the cover from the Internet If successful, add it to the cache and return the path to it Otherwise, return None """ import socket, urllib.request, urllib.error, urllib.parse # Make sure to not be blocked by the request socket.setdefaulttimeout(consts.socketTimeout) # Request information to Last.fm # Beware of UTF-8 characters: we need to percent-encode all characters try: url = 'http://ws.audioscrobbler.com/2.0/?method=album.getinfo&api_key=%s&artist=%s&album=%s' % ( AS_API_KEY, tools.percentEncode(artist), tools.percentEncode(album)) request = urllib.request.Request( url, headers={'User-Agent': USER_AGENT}) stream = urllib.request.urlopen(request) data = stream.read().decode('utf-8') except urllib.error.HTTPError as err: if err.code == 400: logger.error('[%s] No known cover for %s / %s' % (MOD_NAME, artist, album)) else: logger.error('[%s] Information request failed\n\n%s' % (MOD_NAME, traceback.format_exc())) return None except urllib.error.URLError: logger.info('[%s] Could not fetch cover. No internet connection.' % MOD_NAME) return None except: logger.error('[%s] Information request failed\n\n%s' % (MOD_NAME, traceback.format_exc())) return None # Extract the URL to the cover image malformed = True startIdx = data.find(AS_TAG_START) endIdx = data.find(AS_TAG_END, startIdx) if startIdx != -1 and endIdx != -1: coverURL = data[startIdx + len(AS_TAG_START):endIdx] coverFormat = os.path.splitext(coverURL)[1].lower() if coverURL.startswith( ('http://', 'https://')) and coverFormat in ACCEPTED_FILE_FORMATS: malformed = False if malformed: ## Do not show the data in the log every time no cover is found if coverURL: logger.error('[%s] Received malformed data\n\n%s' % (MOD_NAME, data)) return None # Download the cover image try: request = urllib.request.Request( coverURL, headers={'User-Agent': USER_AGENT}) stream = urllib.request.urlopen(request) data = stream.read() if len(data) < 1024: raise Exception( 'The cover image seems incorrect (%u bytes is too small)' % len(data)) except: logger.error('[%s] Cover image request failed' % MOD_NAME) return None # So far, so good: let's cache the image cachePath = os.path.join(self.cacheRootPath, str(abs(hash(artist)))) cacheIdxPath = os.path.join(cachePath, 'INDEX') if not os.path.exists(cachePath): os.mkdir(cachePath) try: cacheIdx = tools.pickleLoad(cacheIdxPath) except: cacheIdx = {} nextInt = len(cacheIdx) + 1 filename = str(nextInt) + coverFormat coverPath = os.path.join(cachePath, filename) cacheIdx[artist + album] = filename tools.pickleSave(cacheIdxPath, cacheIdx) try: output = open(coverPath, 'wb') output.write(data) output.close() return coverPath except: logger.error('[%s] Could not save the downloaded cover\n\n%s' % (MOD_NAME, traceback.format_exc())) return None def getFromInternet(self, artist, album): """ Wrapper for __getFromInternet(), manage blacklist """ # If we already tried without success, don't try again if (artist, album) in self.coverBlacklist: return None # Otherwise, try to download the cover cover = self.__getFromInternet(artist, album) # If the download failed, blacklist the album if cover is None: self.coverBlacklist[(artist, album)] = None return cover # --== Message handlers ==-- def onModLoaded(self): """ The module has been loaded """ self.cfgWin = None # Configuration window self.coverMap = {} # Store covers previously requested self.currTrack = None # The current track being played, if any self.cacheRootPath = os.path.join( consts.dirCfg, MOD_NAME) # Local cache for Internet covers self.coverBlacklist = { } # When a cover cannot be downloaded, avoid requesting it again if not os.path.exists(self.cacheRootPath): os.mkdir(self.cacheRootPath) def onModUnloaded(self): """ The module has been unloaded """ if self.currTrack is not None: modules.postMsg( consts.MSG_CMD_SET_COVER, { 'track': self.currTrack, 'pathThumbnail': None, 'pathFullSize': None }) # Delete covers that have been generated by this module for covers in self.coverMap.values(): if os.path.exists(covers[CVR_THUMB]): os.remove(covers[CVR_THUMB]) if os.path.exists(covers[CVR_FULL]): os.remove(covers[CVR_FULL]) self.coverMap = None # Delete blacklist self.coverBlacklist = None def onNewTrack(self, track): """ A new track is being played, try to retrieve the corresponding cover """ # Make sure we have enough information if track.getArtist() == consts.UNKNOWN_ARTIST or track.getAlbum( ) == consts.UNKNOWN_ALBUM: modules.postMsg(consts.MSG_CMD_SET_COVER, { 'track': track, 'pathThumbnail': None, 'pathFullSize': None }) return album = track.getAlbum().lower() artist = track.getArtist().lower() rawCover = None self.currTrack = track # Let's see whether we already have the cover if (artist, album) in self.coverMap: covers = self.coverMap[(artist, album)] pathFullSize = covers[CVR_FULL] pathThumbnail = covers[CVR_THUMB] # Make sure the files are still there if os.path.exists(pathThumbnail) and os.path.exists(pathFullSize): modules.postMsg( consts.MSG_CMD_SET_COVER, { 'track': track, 'pathThumbnail': pathThumbnail, 'pathFullSize': pathFullSize }) return # Should we check for a user cover? if not prefs.get(__name__, 'download-covers', PREFS_DFT_DOWNLOAD_COVERS) \ or prefs.get(__name__, 'prefer-user-covers', PREFS_DFT_PREFER_USER_COVERS): rawCover = self.getUserCover(os.path.dirname(track.getFilePath())) # Is it in our cache? if rawCover is None: rawCover = self.getFromCache(artist, album) # If we still don't have a cover, maybe we can try to download it if rawCover is None: modules.postMsg(consts.MSG_CMD_SET_COVER, { 'track': track, 'pathThumbnail': None, 'pathFullSize': None }) if prefs.get(__name__, 'download-covers', PREFS_DFT_DOWNLOAD_COVERS): rawCover = self.getFromInternet(artist, album) # If we still don't have a cover, too bad # Otherwise, generate a thumbnail and a full size cover, and add it to our cover map if rawCover is not None: import tempfile thumbnail = tempfile.mktemp() + '.png' fullSizeCover = tempfile.mktemp() + '.png' self.generateThumbnail(rawCover, thumbnail, 'PNG') self.generateFullSizeCover(rawCover, fullSizeCover, 'PNG') if os.path.exists(thumbnail) and os.path.exists(fullSizeCover): self.coverMap[(artist, album)] = (thumbnail, fullSizeCover) modules.postMsg( consts.MSG_CMD_SET_COVER, { 'track': track, 'pathThumbnail': thumbnail, 'pathFullSize': fullSizeCover }) else: modules.postMsg(consts.MSG_CMD_SET_COVER, { 'track': track, 'pathThumbnail': None, 'pathFullSize': None }) # --== Configuration ==-- def configure(self, parent): """ Show the configuration window """ if self.cfgWin is None: from gui.window import Window self.cfgWin = Window('Covers.ui', 'vbox1', __name__, MOD_INFO[modules.MODINFO_L10N], 320, 265) self.cfgWin.getWidget('btn-ok').connect('clicked', self.onBtnOk) self.cfgWin.getWidget('img-lastfm').set_from_file( os.path.join(consts.dirPix, 'audioscrobbler.png')) self.cfgWin.getWidget('btn-help').connect('clicked', self.onBtnHelp) self.cfgWin.getWidget('chk-downloadCovers').connect( 'toggled', self.onDownloadCoversToggled) self.cfgWin.getWidget('btn-cancel').connect( 'clicked', lambda btn: self.cfgWin.hide()) if not self.cfgWin.isVisible(): downloadCovers = prefs.get(__name__, 'download-covers', PREFS_DFT_DOWNLOAD_COVERS) preferUserCovers = prefs.get(__name__, 'prefer-user-covers', PREFS_DFT_PREFER_USER_COVERS) userCoverFilenames = prefs.get(__name__, 'user-cover-filenames', PREFS_DFT_USER_COVER_FILENAMES) self.cfgWin.getWidget('btn-ok').grab_focus() self.cfgWin.getWidget('txt-filenames').set_text( ', '.join(userCoverFilenames)) self.cfgWin.getWidget('chk-downloadCovers').set_active( downloadCovers) self.cfgWin.getWidget('chk-preferUserCovers').set_active( preferUserCovers) self.cfgWin.getWidget('chk-preferUserCovers').set_sensitive( downloadCovers) self.cfgWin.show() def onBtnOk(self, btn): """ Save configuration """ downloadCovers = self.cfgWin.getWidget( 'chk-downloadCovers').get_active() preferUserCovers = self.cfgWin.getWidget( 'chk-preferUserCovers').get_active() userCoverFilenames = [ word.strip() for word in self.cfgWin.getWidget( 'txt-filenames').get_text().split(',') ] prefs.set(__name__, 'download-covers', downloadCovers) prefs.set(__name__, 'prefer-user-covers', preferUserCovers) prefs.set(__name__, 'user-cover-filenames', userCoverFilenames) self.cfgWin.hide() def onDownloadCoversToggled(self, downloadCovers): """ Toggle the "prefer user covers" checkbox according to the state of the "download covers" one """ self.cfgWin.getWidget('chk-preferUserCovers').set_sensitive( downloadCovers.get_active()) def onBtnHelp(self, btn): """ Display a small help message box """ from gui import help helpDlg = help.HelpDlg(MOD_INFO[modules.MODINFO_L10N]) helpDlg.addSection( _('Description'), _('This module displays the cover of the album the current track comes from. Covers ' 'may be loaded from local pictures, located in the same directory as the current ' 'track, or may be downloaded from the Internet.')) helpDlg.addSection( _('User Covers'), _('A user cover is a picture located in the same directory as the current track. ' 'When specifying filenames, you do not need to provide file extensions, supported ' 'file formats (%s) are automatically used.' % ', '.join(ACCEPTED_FILE_FORMATS.keys()))) helpDlg.addSection( _('Internet Covers'), _('Covers may be downloaded from the Internet, based on the tags of the current track. ' 'You can ask to always prefer user covers to Internet ones. In this case, if a user ' 'cover exists for the current track, it is used. If there is none, the cover is downloaded.' )) helpDlg.show(self.cfgWin)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from PyQt5 import QtWidgets from gui.window import Window if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) w = Window() w.show() sys.exit(app.exec_())
def OnInit(self): window = Window(title="MusicFun", size=(880, 480)) window.Show() return True
class TwissSetup: """GUI window to setup a beam according to 2D Twiss parameterisation""" def __init__(self, beam_setup, root_frame): """Initialise the window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 root_frame, SHARE_DIR+"twiss_setup.json") self.beam_setup = beam_setup self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def okay_action(self): """Handle a click on the Okay button, building the beam matrix""" ref = self.beam_setup.get_reference() matrix = maus_cpp.covariance_matrix.create_from_twiss_parameters( mass = ref['mass'], momentum = ref['p'], emittance_x = self.window.get_text_entry("emittance_x", type(1.)), beta_x = self.window.get_text_entry("beta_x", type(1.)), emittance_y = self.window.get_text_entry("emittance_y", type(1.)), beta_y = self.window.get_text_entry("beta_y", type(1.)), emittance_l = self.window.get_text_entry("emittance_l", type(1.)), beta_l = self.window.get_text_entry("beta_l", type(1.)), alpha_x = self.window.get_text_entry("alpha_x", type(1.)), alpha_y = self.window.get_text_entry("alpha_y", type(1.)), alpha_l = self.window.get_text_entry("alpha_l", type(1.)), dispersion_x = self.window.get_text_entry("disp_x", type(1.)), dispersion_prime_x = self.window.get_text_entry("disp_prime_x", type(1.)), dispersion_y = self.window.get_text_entry("disp_y", type(1.)), dispersion_prime_y = self.window.get_text_entry("disp_prime_y", type(1.)) ) self.beam_setup.set_matrix(matrix) self.beam_setup.get_matrix() # check for consistency self.window.close_window() self.beam_setup.matrix_select = None def cancel_action(self): """Handle a click on the Cancel button""" self.window.close_window() self.beam_setup.matrix_select = None
class PlotSetup(): """ GUI handler for defining data to be plotted """ def __init__(self, main_window, parent, selected): """ Initialise the window """ self.main_window = main_window self.parent = parent self.selected = selected self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, self.share_dir+"plot_setup.json") for i, item in enumerate(self.selected): self.window.set_action("variable_type_"+str(i), "drop_down", "Selected(Int_t)", self.select_action) type_frame = self.window.get_frame("variable_type_"+str(i), "drop_down") type_frame.Select(item["variable_type"]) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def okay_action(self): """ Handle Okay button press; get the plot selection and push it to the main window """ type_int = self.window.get_frame_dict("variable_type_0", "drop_down")["frame"].GetSelected() first_int = self.window.get_frame_dict("first_var_0", "drop_down")["frame"].GetSelected() plot_apertures = self.window.get_frame("plot_apertures", "check_button").IsOn() if type_int != 0 and first_int == 0: raise GuiError("Please select plot variable") self.main_window.plot_setup_options = [{ "variable_type":type_int, "first_var":first_int, "plot_apertures":plot_apertures }] self.main_window.update_plot() self.window.close_window() self.main_window.plot_setup = None def cancel_action(self): """ Handle Cancel button press; just close the window """ self.window.close_window() self.main_window.plot_setup = None def select_action(self): """ Dynamically change the list of items in first_var depending on variable_type """ for i, item in enumerate(self.selected): type_select = self.window.get_frame_dict("variable_type_"+str(i), "drop_down")["frame"] first_var_select = self.window.get_frame_dict("first_var_"+str(i), "drop_down")["frame"] selected_type_int = type_select.GetSelected() selected_type_str = self.type_list[selected_type_int] var_list_name = self.type_variables_dict[selected_type_str][0] var_list = self.select_lists[var_list_name] first_var_select.RemoveAll() for i, entry in enumerate(var_list): first_var_select.AddEntry(entry, i) first_var_select.Select(item["first_var"]) @staticmethod def get_variable_type(options): """ Return a string corresponding to integer variable_type selected """ var_type_int = options[0]["variable_type"] return PlotSetup.type_list[var_type_int] @staticmethod def get_first_var(options): """ Return a string corresponding to integer first_var selected """ var_type_string = PlotSetup.get_variable_type(options) select_list_key = PlotSetup.type_variables_dict[var_type_string][0] select_list = PlotSetup.select_lists[select_list_key] first_var_int = options[0]["first_var"] return select_list[first_var_int] my_hit_get_variables = [var for var in Hit.get_variables() if len(var)] type_list = [ "<Select plot type>", "mean", "envelope", "RMS", "beta", "alpha", "gamma", "emittance", "dispersion", "dispersion_prime" ] select_lists = { "no_var":[ "", ], "optics_var":[ "<Select plot variable>", "x", "y", "transverse", "longitudinal" ], "physics_var":[ "<Select plot variable>" ]+my_hit_get_variables, "kinematic_var":[ "<Select plot variable>", "x", "y", "px", "py", "t", "energy" ], "disp_var":[ "<Select plot variable>", "x", "y" ] } type_variables_dict = { "<Select plot type>":["no_var"], "mean":["physics_var"], "envelope":["kinematic_var"], "RMS":["kinematic_var"], "beta":["optics_var"], "alpha":["optics_var"], "gamma":["optics_var"], "emittance":["optics_var"], "dispersion":["disp_var"], "dispersion_prime":["disp_var"], } share_dir = ""
class PlotSetup(): """ GUI handler for defining data to be plotted """ def __init__(self, main_window, parent, selected): """ Initialise the window """ self.main_window = main_window self.parent = parent self.selected = selected self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, self.share_dir + "plot_setup.json") for i, item in enumerate(self.selected): self.window.set_action("variable_type_" + str(i), "drop_down", "Selected(Int_t)", self.select_action) type_frame = self.window.get_frame("variable_type_" + str(i), "drop_down") type_frame.Select(item["variable_type"]) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def okay_action(self): """ Handle Okay button press; get the plot selection and push it to the main window """ type_int = self.window.get_frame_dict( "variable_type_0", "drop_down")["frame"].GetSelected() first_int = self.window.get_frame_dict( "first_var_0", "drop_down")["frame"].GetSelected() plot_apertures = self.window.get_frame("plot_apertures", "check_button").IsOn() if type_int != 0 and first_int == 0: raise GuiError("Please select plot variable") self.main_window.plot_setup_options = [{ "variable_type": type_int, "first_var": first_int, "plot_apertures": plot_apertures }] self.main_window.update_plot() self.window.close_window() self.main_window.plot_setup = None def cancel_action(self): """ Handle Cancel button press; just close the window """ self.window.close_window() self.main_window.plot_setup = None def select_action(self): """ Dynamically change the list of items in first_var depending on variable_type """ for i, item in enumerate(self.selected): type_select = self.window.get_frame_dict("variable_type_" + str(i), "drop_down")["frame"] first_var_select = self.window.get_frame_dict( "first_var_" + str(i), "drop_down")["frame"] selected_type_int = type_select.GetSelected() selected_type_str = self.type_list[selected_type_int] var_list_name = self.type_variables_dict[selected_type_str][0] var_list = self.select_lists[var_list_name] first_var_select.RemoveAll() for i, entry in enumerate(var_list): first_var_select.AddEntry(entry, i) first_var_select.Select(item["first_var"]) @staticmethod def get_variable_type(options): """ Return a string corresponding to integer variable_type selected """ var_type_int = options[0]["variable_type"] return PlotSetup.type_list[var_type_int] @staticmethod def get_first_var(options): """ Return a string corresponding to integer first_var selected """ var_type_string = PlotSetup.get_variable_type(options) select_list_key = PlotSetup.type_variables_dict[var_type_string][0] select_list = PlotSetup.select_lists[select_list_key] first_var_int = options[0]["first_var"] return select_list[first_var_int] my_hit_get_variables = [var for var in Hit.get_variables() if len(var)] type_list = [ "<Select plot type>", "mean", "envelope", "RMS", "beta", "alpha", "gamma", "emittance", "dispersion", "dispersion_prime" ] select_lists = { "no_var": [ "", ], "optics_var": ["<Select plot variable>", "x", "y", "transverse", "longitudinal"], "physics_var": ["<Select plot variable>"] + my_hit_get_variables, "kinematic_var": ["<Select plot variable>", "x", "y", "px", "py", "t", "energy"], "disp_var": ["<Select plot variable>", "x", "y"] } type_variables_dict = { "<Select plot type>": ["no_var"], "mean": ["physics_var"], "envelope": ["kinematic_var"], "RMS": ["kinematic_var"], "beta": ["optics_var"], "alpha": ["optics_var"], "gamma": ["optics_var"], "emittance": ["optics_var"], "dispersion": ["disp_var"], "dispersion_prime": ["disp_var"], } share_dir = ""
from pyglet import app from gui.models.movable import MovableMixin from gui.window import Window if __name__ == "__main__": win = Window(width=1024, height=768) button = MovableMixin(10, 100, 10, 100) win.add_component(button) app.run()
#!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = "JuanDavid" __date__ = "$29/07/2015 08:44:56 PM$" from gui.window import Window if __name__ == "__main__": try: window = Window() except Exception as e: print e.message
def plot_window_provider(title): return Window(title, 3, 4 + len("Plot"), 0, 5 + len("Back"), self.window.internal_renderer)
class BeamSetup: """GUI window to setup a reference particle and beam ellipse""" def __init__(self, main_window, parent): """Initialise the window""" self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 parent, SHARE_DIR + "beam_setup.json") self.main_window = main_window self.parent = parent self.matrix_select = None self.matrix = None self.window.set_button_action("&Penn", self.penn_action) self.window.set_button_action("&Twiss", self.twiss_action) self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def twiss_action(self): """Handle Twiss button - open a window to set up Twiss parameters""" if self.matrix_select == None: self.matrix_select = TwissSetup(self, self.parent) def penn_action(self): """Handle Penn button - open a window to set up Penn parameters""" if self.matrix_select == None: self.matrix_select = PennSetup(self, self.parent) def okay_action(self): """ Handle Okay button - set the beam in lattice and then close the window """ if self.matrix_select != None: print "Close the matrix_select window" return self.main_window.lattice.set_beam(self.get_reference(), self.get_matrix()) self.main_window.lattice.run_lattice() self.main_window.update_plot() self.window.close_window() self.main_window.beam_setup = None def cancel_action(self): """ Handle Cancel button - just close the window """ if self.matrix_select != None: print "Close the matrix_select window" return self.window.close_window() self.main_window.beam_setup = None def set_matrix(self, matrix): """ Set the beam matrix (updating GUI elements) - matrix a maus_cpp.covariance_matrix.CovarianceMatrix object """ self.matrix = matrix for i, var_i in enumerate(["t", "e", "x", "px", "y", "py"]): for j, var_j in enumerate(["t", "e", "x", "px", "y", "py"]): value = matrix.get_element(i + 1, j + 1) self.window.set_text_entry(var_i + var_j, value) def get_matrix(self): """ Get the beam matrix (reading from GUI elements) Returns a maus_cpp.covariance_matrix.CovarianceMatrix object """ np_matrix = numpy.zeros([6, 6]) for i, var_i in enumerate(["t", "e", "x", "px", "y", "py"]): for j, var_j in enumerate(["t", "e", "x", "px", "y", "py"]): value1 = self.window.get_text_entry(var_i + var_j, type(1.)) value2 = self.window.get_text_entry(var_j + var_i, type(1.)) delta = abs(value1 - value2) if delta > 1e-6: err = "Matrix has non-symmetric element Cov("+\ var_i+","+var_j+") with delta "+str(delta)+"." err += "This element must be symmetric - upper "+\ "diagonal should be equal to lower diagonal." raise GuiError(err) else: np_matrix[i, j] = value1 evals = numpy.linalg.eigvals(np_matrix) if not numpy.all(evals > 0): evals = [i for i in evals] raise GuiError("Beam ellipse should be positive definite but "+\ " eigenvalues were not all positive: "+str(evals)) return maus_cpp.covariance_matrix.create_from_matrix(np_matrix) def set_reference(self, ref_hit): """ Get the reference particle (writing to GUI elements) - ref_hit an xboa.Hit.Hit object """ for var in ["x", "y", "z", "px", "py", "pz", "pid"]: self.window.set_text_entry(var, ref_hit[var]) def get_reference(self): """ Get the reference particle (reading from GUI elements) Returns an xboa.Hit.Hit object """ ref_dict = {} for var in ["x", "y", "z", "px", "py", "pz"]: var_dict = self.window.get_frame_dict(var, "named_text_entry") ref_dict[var] = float(var_dict["text_entry"].text_entry.GetText()) pid_dict = self.window.get_frame_dict("pid", "named_text_entry") try: ref_dict["pid"] = int(pid_dict["text_entry"].text_entry.GetText()) ref_dict["mass"] = common.pdg_pid_to_mass[abs(ref_dict["pid"])] ref_dict["charge"] = common.pdg_pid_to_charge[abs(ref_dict["pid"])] except KeyError: raise GuiError("Did not recognise reference particle pid") try: hit = Hit.new_from_dict(ref_dict, "energy") except Exception: raise GuiError("Failed to generate a reference particle") return hit
def run(self): print("Initialized the application @app class") window_generator = WindowGenerator() windows = window_generator.define_windows() # set main menu as starting window current_params = window_generator.get_windowparameters_by_title(windows, "Raspberry Pi Gaming Station") # initalize pygame submodules os.environ['SDL_VIDEO_WINDOW_POS'] = "0,0" pygame.init() # disable mouse cursor pygame.mouse.set_visible(0) # create a pygame default window info = pygame.display.Info() screen = pygame.display.set_mode((info.current_w, info.current_h), pygame.NOFRAME) while True: current_window = Window(screen=screen, title=current_params.title, choices=current_params.options, extend_window=current_params.extend_window) result = current_window.display() if result == "Exit": current_params = window_generator.get_windowparameters_by_id(windows, current_params.previous_id) if current_params == None: #TODO: ask to shutdown the system break elif '.' in result: cm = ControlManager(platform=current_params.title.lower()) cm.restore_control_config() # run a game gm = GameRunner(platform=current_params.title, file_name=result) gm.run() else: if result == "Start": result = "Platforms" new_params = window_generator.get_windowparameters_by_title(windows, result) if new_params != None: # if the window is a control window current_params = new_params # figure out how to distinguish control from hotkeys elif current_params.title == "Hotkeys": current_params.refresh_hotkeys() # run control prompt cw = ControlPrompt(screen, control_to_change=result) cw.display() # detect pressed control control = ControlDetector.detect_control() # run HotkeyManager to configure the json with hotkeys hm = create_hotkey_manager() hm.change_hotkey(opt=result, new_control=control) cw.destroy() current_params.refresh_hotkeys() elif current_params.extend_window: # show a new window to prompt for controls current_params.refresh_options(platform=current_params.title.replace(' ', '').lower()) cw = ControlPrompt(screen=screen, control_to_change=result) cw.display() # detect pressed control control = ControlDetector.detect_control() # platform is current window title minus the trailing space cm = ControlManager(platform=current_params.title.replace(' ', '').lower()) cm.update_control_value(result, control) # run ControlManager to configure the cfg file # destroy the screen cw.destroy() current_params.refresh_options(platform=current_params.title.replace(' ', '').lower()) pygame.display.quit() pygame.quit()
def main(): with qt_application(): window = Window() controller = WindowController(window) window.show()
def main(world): window = Window(width=800, height=600, caption='mine.py', resizable=True, world=world) window.set_exclusive_mouse(True) setup() pyglet.app.run()
class TwissSetup: """GUI window to setup a beam according to 2D Twiss parameterisation""" def __init__(self, beam_setup, root_frame): """Initialise the window""" self.window = Window( ROOT.gClient.GetRoot(), # pylint: disable = E1101 root_frame, SHARE_DIR + "twiss_setup.json") self.beam_setup = beam_setup self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) def okay_action(self): """Handle a click on the Okay button, building the beam matrix""" ref = self.beam_setup.get_reference() matrix = maus_cpp.covariance_matrix.create_from_twiss_parameters( mass=ref['mass'], momentum=ref['p'], emittance_x=self.window.get_text_entry("emittance_x", type(1.)), beta_x=self.window.get_text_entry("beta_x", type(1.)), emittance_y=self.window.get_text_entry("emittance_y", type(1.)), beta_y=self.window.get_text_entry("beta_y", type(1.)), emittance_l=self.window.get_text_entry("emittance_l", type(1.)), beta_l=self.window.get_text_entry("beta_l", type(1.)), alpha_x=self.window.get_text_entry("alpha_x", type(1.)), alpha_y=self.window.get_text_entry("alpha_y", type(1.)), alpha_l=self.window.get_text_entry("alpha_l", type(1.)), dispersion_x=self.window.get_text_entry("disp_x", type(1.)), dispersion_prime_x=self.window.get_text_entry( "disp_prime_x", type(1.)), dispersion_y=self.window.get_text_entry("disp_y", type(1.)), dispersion_prime_y=self.window.get_text_entry( "disp_prime_y", type(1.))) self.beam_setup.set_matrix(matrix) self.beam_setup.get_matrix() # check for consistency self.window.close_window() self.beam_setup.matrix_select = None def cancel_action(self): """Handle a click on the Cancel button""" self.window.close_window() self.beam_setup.matrix_select = None
def quick_actions(title): return Window(title, 3, 0, 0, 0, self)
class PennSetup: """GUI window to setup a beam according to 4D Penn parameterisation""" def __init__(self, beam_setup, root_frame): """Initialise the window""" self.window = Window(ROOT.gClient.GetRoot(), # pylint: disable = E1101 root_frame, SHARE_DIR+"penn_setup.json") self.beam_setup = beam_setup self.window.set_button_action("&Okay", self.okay_action) self.window.set_button_action("&Cancel", self.cancel_action) self.window.set_button_action("Get &B0", self.get_b0_action) self.window.set_button_action("&Constant Beta", self.constant_beta_action) def okay_action(self): """Handle a click on the Okay button, building the beam matrix""" ref = self.beam_setup.get_reference() matrix = maus_cpp.covariance_matrix.create_from_penn_parameters( mass = ref['mass'], momentum = ref['p'], emittance_t = self.window.get_text_entry("emittance_trans", type(1.)), beta_t = self.window.get_text_entry("beta_trans", type(1.)), emittance_l = self.window.get_text_entry("emittance_l", type(1.)), beta_l = self.window.get_text_entry("beta_l", type(1.)), alpha_t = self.window.get_text_entry("alpha_trans", type(1.)), alpha_l = self.window.get_text_entry("alpha_l", type(1.)), charge = ref["charge"], # BUG - multiply by -1 to fix BUG in source code bz = -self.window.get_text_entry("B0", type(1.))*common.units['T'], ltwiddle = self.window.get_text_entry("Lc", type(1.)), dispersion_x = self.window.get_text_entry("disp_x", type(1.)), dispersion_prime_x = self.window.get_text_entry("disp_prime_x", type(1.)), dispersion_y = self.window.get_text_entry("disp_y", type(1.)), dispersion_prime_y = self.window.get_text_entry("disp_prime_y", type(1.)) ) self.beam_setup.set_matrix(matrix) self.beam_setup.get_matrix() # check for consistency self.window.close_window() self.beam_setup.matrix_select = None def cancel_action(self): """Handle a click on the Cancel button""" self.window.close_window() self.beam_setup.matrix_select = None def get_b0_action(self): """ Handle a click on the Get B0 button, getting B magnitude at the location of the reference particle """ ref = self.beam_setup.get_reference() b_vec = maus_cpp.field.get_field_value(ref['x'], ref['y'], ref['z'], ref['t']) _b0 = (b_vec[0]**2+b_vec[1]**2+b_vec[2]**2)**0.5 self.window.set_text_entry('B0', _b0*common.units['T']) def constant_beta_action(self): """ Handle a click on the Constant Beta button, getting beta function that would be required to get a constant beta function, given other settings (reference particle, B0, Lc) """ _b0 = abs(self.window.get_text_entry("B0", type(1.))*1e-3) # kT if abs(_b0) < 1e-9: raise ValueError( "Constant beta requires B0 is not 0. "+\ "Modify the B0 field and try again." ) _lc = self.window.get_text_entry("Lc", type(1.)) # kT mom = self.beam_setup.get_reference()['p'] # MeV/c charge = abs(self.beam_setup.get_reference()['charge']) # eplus beta = (1+_lc**2)**0.5 * 2.*charge*mom/common.constants['c_light']/_b0 self.window.set_text_entry('alpha_trans', 0.0) self.window.set_text_entry('beta_trans', beta) # beta in mm