Python GUI.invoke_later方法代码示例

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
    def tracking_state_callback(self, sbp_msg, **metadata):
        t = time.time() - self.t_init
        self.time[0:-1] = self.time[1:]
        self.time[-1] = t
        # first we loop over all the SIDs / channel keys we have stored and set 0 in for CN0
        for key, cno_array in self.CN0_dict.items():
            # p
            if (cno_array == 0).all():
                self.CN0_dict.pop(key)
            else:
                new_arr = np.roll(cno_array, -1)
                new_arr[-1] = 0
                self.CN0_dict[key] = new_arr

        # If the whole array is 0 we remove it
        # for each satellite, we have a (code, prn, channel) keyed dict
        # for each SID, an array of size MAX PLOT with the history of CN0's stored
        # If there is no CN0 or not tracking for an epoch, 0 will be used
        # each array can be plotted against host_time, t
        for i, s in enumerate(sbp_msg.states):
            if code_is_gps(s.sid.code):
                sat = s.sid.sat
            elif code_is_glo(s.sid.code):
                sat = s.fcn - GLO_FCN_OFFSET
                self.glo_slot_dict[sat] = s.sid.sat

            key = (s.sid.code, sat, i)
            if s.cn0 != 0:
                self.CN0_dict[key][-1] = s.cn0 / 4.0

        GUI.invoke_later(self.update_plot)

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
 def run(self):
     cams, new_cams = register_image(self.vsfm_interface, self.imfn, 
                                     match_specified_fn = self.match_specified_fn,
                                     max_sleep_seconds = self.max_sleep_seconds)
     GUI.invoke_later(mayaviu.plot_cameras, new_cams)
     self.cams = cams
     self.new_cams = new_cams

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
    def wrapper(*args, **kw):
        """Wrapper function to run given function inside the GUI event
        loop.
        """
        global _gui, _stop_show
        tk = ETSConfig.toolkit

        if is_ui_running():
            # In this case we should not pop up the UI since we likely
            # don't want to stop the mainloop.
            return func(*args, **kw)
        else:
            g = GUI()
            if tk == "wx":
                # Create a dummy app so invoke later works on wx.
                a = ApplicationWindow(size=(1, 1))
                GUI.invoke_later(lambda: a.close())
                a.open()

            GUI.invoke_later(func, *args, **kw)
            _gui = g
            if stop:
                # Pop up the UI to stop the mainloop.
                _stop_show = StopShow()
            g.start_event_loop()

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
 def run(self):
     print "Performing expensive calculation in %s..."%self.getName(),
     sleep(3)
     sd = self.data.scalar_data
     sd += numpy.sin(numpy.random.rand(*sd.shape)*2.0*numpy.pi)
     GUI.invoke_later(self.data.update)
     print 'done.'

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
  def _baseline_callback_ned(self, sbp_msg, **metadata):
    # Updating an ArrayPlotData isn't thread safe (see chaco issue #9), so
    # actually perform the update in the UI thread.
    if self.running:
      #GUI.invoke_later(self.baseline_callback, sbp_msg)

      soln = MsgBaselineNED(sbp_msg)
      GUI.invoke_later(self.baseline_callback, soln)

      cnt = self.cnt % 4
      fake_sbp_msg = copy.copy(soln)
      if cnt == 3:
        fake_sbp_msg.e = 217371
        fake_sbp_msg.n = 100837 - (cnt+1) * 10e3
      else:
        fake_sbp_msg.e = 217371 + cnt * 20e3
        fake_sbp_msg.n = 100837 - cnt * 20e3
      fake_sbp_msg.sender = 100 + cnt
      fake_sbp_msg.flags = cnt
      soln = fake_sbp_msg
      self.cnt += 1
      GUI.invoke_later(self.baseline_callback, soln)

    # _threshold_satisfied()函数计算需要优化
    # 或者保持数据发送频率小于2(/s)
    time.sleep(0.5)

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
def main():
    os.chdir( os.path.dirname( os.path.realpath( __file__ )))

    #read the command line arguments or fetch the default values
    args=cli_args(sys.argv[2:])

    #generate the initial dataset
    #TODO collect the "name" of the sample dataset on the command line
    
    sample_dataset,sample_metadata,exec_script=preproc(args)
    
    g=CvuGUI(sample_dataset,sample_metadata,quiet=args['quiet'])
    sample_dataset.gui=g

    #Qt does not sys.exit in response to KeyboardInterrupt
    #we intercept KeyboardInterrupts in the interpreter, before even
    #reaching the Qt event loop and force them to call sys.exit
    signal.signal(signal.SIGINT, signal.SIG_DFL)

    if exec_script is not None:
        from pyface.api import GUI
        gui=GUI()

        def run_script():
            gui.process_events()
            script(exec_script, cvu_gui=g, scriptdir=sys.argv[1])

        gui.invoke_later(run_script)

    g.configure_traits()

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
 def manage_nap_firmware_update(self, check_version=False):
   # Flash NAP if out of date.
   try:
     local_nap_version = parse_version(
         self.settings['system_info']['nap_version'].value)
     remote_nap_version = parse_version(self.newest_nap_vers)
     nap_out_of_date = local_nap_version != remote_nap_version
   except KeyError:
     nap_out_of_date = True
   if nap_out_of_date or check_version==False:
     text = "Updating NAP"
     self._write(text)
     self.create_flash("M25")
     nap_n_ops = self.pk_flash.ihx_n_ops(self.nap_fw.ihx)
     progress_dialog = PulsableProgressDialog(nap_n_ops, True)
     progress_dialog.title = text
     GUI.invoke_later(progress_dialog.open)
     self.pk_flash.write_ihx(self.nap_fw.ihx, self.stream, mod_print=0x40, \
                             elapsed_ops_cb = progress_dialog.progress)
     self.stop_flash()
     self._write("")
     progress_dialog.close()
     return True
   else:
     text = "NAP is already to latest version, not updating!"
     self._write(text)
     self._write("")
     return False

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
  def manage_multi_firmware_update(self):
    # Set up progress dialog and transfer file to Piksi using SBP FileIO
    progress_dialog = PulsableProgressDialog(len(self.stm_fw.blob))
    progress_dialog.title = "Transferring image file"
    GUI.invoke_later(progress_dialog.open)
    self._write("Transferring image file...")
    try:
      FileIO(self.link).write("upgrade.image_set.bin", self.stm_fw.blob,
                              progress_cb=progress_dialog.progress)
    except Exception as e:
      self._write("Failed to transfer image file to Piksi: %s\n" % e)
      progress_dialog.close()
      return
    try:
      progress_dialog.close()
    except AttributeError:
      pass

    # Setup up pulsed progress dialog and commit to flash
    progress_dialog = PulsableProgressDialog(100, True)
    progress_dialog.title = "Committing to flash"
    GUI.invoke_later(progress_dialog.open)
    self._write("Committing file to flash...")
    def log_cb(msg, **kwargs): self._write(msg.text)
    self.link.add_callback(log_cb, SBP_MSG_LOG)
    code = shell_command(self.link, "upgrade_tool upgrade.image_set.bin", 240)
    self.link.remove_callback(log_cb, SBP_MSG_LOG)
    progress_dialog.close()

    if code != 0:
      self._write('Failed to perform upgrade (code = %d)' % code)
      return
    self._write('Resetting Piksi...')
    self.link(MsgReset(flags=0))

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
 def tracking_state_callback(self, sbp_msg, **metadata):
   t = time.time() - self.t_init
   self.time[0:-1] = self.time[1:]
   self.time[-1] = t
   # first we loop over all the SIDs / channel keys we have stored and set 0 in for CN0
   for key, cno_array in self.CN0_dict.items():
     # p
     if (cno_array==0).all():
       self.CN0_dict.pop(key)
     else:
       self.CN0_dict[key][0:-1] = cno_array[1:]
       self.CN0_dict[key][-1] = 0
     # If the whole array is 0 we remove it
   # for each satellite, we have a (code, prn, channel) keyed dict
   # for each SID, an array of size MAX PLOT with the history of CN0's stored
   # If there is no CN0 or not tracking for an epoch, 0 will be used
   # each array can be plotted against host_time, t
   for i,s in enumerate(sbp_msg.states):
     prn = s.sid.sat
     if code_is_gps(s.sid.code):
       prn += 1
     key = (s.sid.code, prn, i)
     if s.state != 0:
       if len(self.CN0_dict.get(key, [])) == 0:
         self.CN0_dict[key] = np.zeros(NUM_POINTS)
       self.CN0_dict[key][-1] = s.cn0
   GUI.invoke_later(self.update_plot)

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
    def _append_log(self, msg, endline="\n"):
        def toappend():
            if self._progress_started:
                self._progress_logs += msg + endline
            else:
                self._logs += msg + endline

        GUI.invoke_later(toappend)  # to be thread safe when logs are displayed in gui

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
 def _wrap_update():
     update_funcs = self._update_funcs.copy()
     self._update_funcs.clear()
     for update in update_funcs.values():
         update_func, args = update
         update_func(*args)
     if self._update_funcs:
         GUI.invoke_later(_wrap_update)

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
def lock_orientation(obj, name, old, new):
##    print 'locking o'
    if orientation_flag[obj]:
        orientation_flag[obj] = False
        return
    def icb():
        orientation_flag[obj] = True
        obj.orientation = np.array(old)
    GUI.invoke_later(icb)

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
 def run(self):
     step = 0
     while (self.running):
         self.interface.datamodel.Update()
         step += 1
         if step>=self.interface.steps:
             step=0
             GUI.invoke_later(self.interface.callback)
     GUI.invoke_later(self.interface.redraw_scene)

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
  def _run(self):
    GUI.invoke_later(self.edit_traits, self.view)
    while not self.handler_executed:
      sleep(0.1)

    if self.execute_callback:
      GUI.invoke_later(self.callback)

    if not self.closed:
      self.close = 1

# 需要导入模块: from pyface.api import GUI [as 别名]
# 或者: from pyface.api.GUI import invoke_later [as 别名]
def lock_scale(obj, name, old, new):
##    print 'locking s'
    if scale_flag[obj]:
        scale_flag[obj] = False
        return
##    if np.all(new==1): return
    def icb():
        scale_flag[obj] = True
        obj.scale = np.array(old)
    GUI.invoke_later(icb)