Python QtCore.pyqtRemoveInputHook方法代码示例

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
    def __init__(self, mainwindow, ui_mainwindow):
        self.win = mainwindow
        self.ui = ui_mainwindow
        self.ui.setupUi(self.win)
        QtCore.pyqtRemoveInputHook() # to be called in __init__ of main-dialog-class
        addMPLToolBar(self.win, self.ui.canv)
        self.canv = self.ui.canv
        self.fig = self.canv.figure

        self.filehandler = self.streamhandler = None
        self.data = None
        self.daystream = None
        self.ppsd = None

        self.timer = QtCore.QTimer()

        connect(self.timer, signal('timeout()'), self.timerEvent)
        connect(self.ui.t1, signal('editingFinished()'), self.set_dates)
        connect(self.ui.t2, signal('editingFinished()'), self.set_dates)
        connect(self.ui.button, signal('clicked()'), self.add_ppsd)
        connect(self.ui.push_open, signal('clicked()'), self.open_ppsd)
        connect(self.ui.push_save, signal('clicked()'), self.save_ppsd)
        connect(self.ui.push_plot, signal('clicked()'), self.plot_ppsd)
        connect(self.ui.actionAdd_Console, signal('triggered()'),
                self.add_console)
        connect(self.ui.actionStart_IPython, signal('triggered()'),
                self.start_ipy)
        connect(self.ui.actionLogging_to_File, signal('triggered()'),
                self.logging_file)
        connect(self.ui.actionLogging_Window, signal('triggered()'),
                self.logging_window)

        self.set_dates()
        self.logging_window()
        log.info('Hallo')

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
    def __init__(self, argv=None, user_ns=None, user_global_ns=None,
                 debug=0, shell_class=MTInteractiveShell):

        from PyQt4 import QtCore, QtGui

        try:
            # present in PyQt4-4.2.1 or later
            QtCore.pyqtRemoveInputHook()
        except AttributeError:
            pass

        if QtCore.PYQT_VERSION_STR == '4.3':
            warn('''PyQt4 version 4.3 detected.
If you experience repeated threading warnings, please update PyQt4.
''')

        self.exec_ = hijack_qt4()

        # Allows us to use both Tk and QT.
        self.tk = get_tk()

        self.IP = make_IPython(argv,
                               user_ns=user_ns,
                               user_global_ns=user_global_ns,
                               debug=debug,
                               shell_class=shell_class,
                               on_kill=[QtGui.qApp.exit])

        # HACK: slot for banner in self; it will be passed to the mainloop
        # method only and .run() needs it.  The actual value will be set by
        # .mainloop().
        self._banner = None

        threading.Thread.__init__(self)

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
    def onNewFrame(self, frame, time):
        self.mutex.acquire()
        try:
            self.frameTime = time
            self.currCvFrame = frame # may need to make a deep copy

            (found, pos, view, allFish) = self.trackWidget.findFish(self.currCvFrame)

            if found:
                self.fishPosUpdate = found
                self.fishPos = pos
                self.allFish = allFish

            if not self.currState == State.OFF:
                self.arenaData['runs'][self.currRun]['video'].append((self.frameTime, None)) 
#                if self.paramNumFish.value() == 1:
#                    self.arenaData['runs'][self.currRun]['tracking'].append((self.frameTime, self.fishPos[0], self.fishPos[1]))
#                else:
                d = [self.frameTime, pos[0], pos[1]]
                for nFish in range(1, min(self.paramNumFish.value(),len(allFish))):
                    d.append(allFish[nFish][0])
                    d.append(allFish[nFish][1])
#                print d
                self.arenaData['runs'][self.currRun]['tracking'].append(tuple(d))

            self.arenaView = view
        except:
            print 'CocaineController:onNewFrame failed'
            traceback.print_exc()
            QtCore.pyqtRemoveInputHook() 
            ipdb.set_trace()
        finally:
            self.mutex.release()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
    def updateExperimentalState(self):
        if not self.currState == State.OFF:
            self.mutex.acquire()
            try:
                t = time.time()
                #only update status bar if arena is selected.
                if self.isCurrent():
                    self.arenaMain.statusBar().showMessage('SwitchesCompleted: %d TimeSinceSwitch: %f' % (self.currSwitch, t - self.lastSwitchTime))

                #handle State Changes
                if t >= self.lastSwitchTime + self.paramSwitchTime.value():
                    self.currSwitch += 1
                    self.lastSwitchTime = t
                    if self.currSwitch > self.paramNumSwitches.value():
                        self.currState = State.OFF
                        self.arenaData['runs'][self.currRun]['endTime'] = t
                        self.startButton.setText('Start Switches')
                        self.startButton.setChecked(False)
                        self.paramGroup.setDisabled(False)
                        self.infoGroup.setDisabled(False)
                    self.updateProjectorDisplay()
                    self.arenaData['runs'][self.currRun]['switchTimes'].append(t)
                    self.saveResults()
            except:
                print 'CocaineController:updateState failed'
                traceback.print_exc()
                QtCore.pyqtRemoveInputHook() 
                ipdb.set_trace()
            finally:
                self.mutex.release()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
def main():
    """
    Consolidate running the application.
    """
    QtCore.pyqtRemoveInputHook()
    app = QtGui.QApplication(sys.argv)
    ugridviz = UgridViz()
    print app.exec_()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
def breakpoint():
    """ open up the python debugger here and poke around
    Very helpful, I should have figured this out ages ago!
    """
    QtCore.pyqtRemoveInputHook()
    import pdb

    pdb.set_trace()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
def ipython():
    debug.init()
    global main_window, app
    import __main__
    if 'IPython' in __main__.__class__.__module__:
        QtCore.pyqtRemoveInputHook()
    compileUis()
    app, main_window = createWindow()
    return app, main_window

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
 def __init__(self, reactor):
     super(PlotWindow, self).__init__()
     QtCore.pyqtRemoveInputHook()
     #dictionary in the form dataset_name: dataset_info
     self.reactor = reactor
     self.datasets = {}
     self.setup_layout()
     self.connect_layout()
     self.colors = color_chooser()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
 def pause(self):
     self.mutex.acquire()
     try:
         self.doPause()
     except:
         print 'ContextualHelplessnessController: pause failed'
         traceback.print_exc()
         QtCore.pyqtRemoveInputHook() 
         ipdb.set_trace()
     finally:
         self.mutex.release()    

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
def pdb (message=''):

    """Fall into pdb."""

    import pdb
    import PyQt4.QtCore as QtCore

    if message: print (message)
    QtCore.pyqtRemoveInputHook()
        # Essential.
    pdb.set_trace()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
 def paintEvent(self, e):
     painter = QtGui.QPainter()
     painter.begin(self)
     try:		
         self.mainwindow.drawProjectorDisplay(painter)
     except:
         print 'ArenaControllerProjectorWindow:paintEvent failed'
         traceback.print_exc()
         QtCore.pyqtRemoveInputHook() 
         ipdb.set_trace()
     finally:
         painter.end()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
 def updateExperimentalState(self):
     if not self.currState == State.OFF:
         self.mutex.acquire()
         try:
             t = time.time()
             #only update status bar if arena is selected.
             if self.isCurrent():
                 self.arenaMain.statusBar().showMessage('Running: Block:%d/%d, CurrState=%d, TimeToNextState=%f, Side=%d'%(self.numBlocks,self.paramNumShockBlocks.value(),self.currState,self.nextStateTime-t, self.currShockSide))
             if t > self.nextStateTime:
                 self.setShockState(False, False)
                 if (self.currState == State.ACCLIMATE or
                     self.currState == State.BETWEEN or
                     self.paramBetweenTime.value() == 0):
                     if self.numBlocks < self.paramNumShockBlocks.value():
                         if self.currShockSide == 2:
                             self.currState = State.SHOCKING
                             self.setShockState(True,False)
                             self.arenaData['stateinfo'].append((t, self.currState, 'On','Off'))
                             self.currShockSide = 1
                             print 'SHOCKING SIDE1'
                         else:
                             self.currState = State.SHOCKING
                             self.setShockState(False,True)
                             self.arenaData['stateinfo'].append((t, self.currState, 'Off','On'))
                             self.currShockSide = 2
                             print 'SHOCKING SIDE2'
                         self.nextStateTime = t + self.paramShockingTime.value()
                         self.numBlocks+=1
                     else:
                         self.currState = State.OFF
                         self.arenaData['stateinfo'].append((t, self.currState, 'Off','Off'))
                         self.startButton.setText('Start Switches')
                         self.startButton.setChecked(False)
                         self.paramGroup.setDisabled(False)
                         self.infoGroup.setDisabled(False)
                         self.saveResults()
                         print 'DONE'
                 elif self.paramBetweenTime.value() > 0:
                     self.currState = State.BETWEEN
                     self.nextStateTime = t + self.paramBetweenTime.value()
                     self.arenaData['stateinfo'].append((t, self.currState, 'Off','Off'))
                     print 'BETWEEN'
                 self.updateProjectorDisplay()
                 self.saveResults()
         except:
             print ':updateState failed'
             traceback.print_exc()
             QtCore.pyqtRemoveInputHook() 
             ipdb.set_trace()
         finally:
             self.mutex.release()

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
 def startSwitches(self):
     self.mutex.acquire()
     try:
         if self.currState == State.OFF:
             if self.isReadyToStart():
                 self.paramGroup.setDisabled(True)
                 self.infoGroup.setDisabled(True)
                 td = datetime.datetime.now()
                 self.saveLocation = str(self.infoDir.text())
                 [p, self.fnResults] = os.path.split(self.saveLocation)
                 self.fnResults = self.fnResults + '_' + td.strftime('%Y-%m-%d-%H-%M-%S')
                 self.jsonFileName = str(self.infoDir.text()) + os.sep + self.fnResults  + '.json'
                 self.initArenaData()
                 
                 t = time.time()
                 self.currState = State.ACCLIMATE
                 self.nextStateTime = t + self.paramAcclimate.value()*60
                 self.bInShockBout = False
                 self.nextShockBoutTime = float('inf')
                 self.setShockState(False,False)
                 self.stopOMR()
                 self.arenaData['stateinfo'].append((t, self.currState, self.getSide1ColorName(), self.getSide2ColorName()))
                 self.updateProjectorDisplay()
                 self.startButton.setText('Stop')
             else:
                 self.startButton.setChecked(False)
                 self.arenaMain.statusBar().showMessage('Arena not ready to start.  Information is missing.')
         else: 
             t = time.time()
             self.currState = State.OFF
             self.nextStateTime = float('inf')
             self.bInShockBout = False
             self.nextShockBoutTime = float('inf')
             self.setShockState(False,False)
             self.stopOMR()
             self.startButton.setText('Start Switches')
             self.arenaData['stateinfo'].append((t, self.currState, self.getSide1ColorName(), self.getSide2ColorName()))
             self.updateProjectorDisplay()
             self.saveResults()
             self.paramGroup.setDisabled(False) 
             self.infoGroup.setDisabled(False)
             self.pauseButton.setChecked(False)
     except:
         print 'ContextualHelplessnessController:startSwitches failed'
         traceback.print_exc()
         QtCore.pyqtRemoveInputHook() 
         ipdb.set_trace()
     finally:
         self.mutex.release()    

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
def unexpected_exception(e, tb=None, frame=None):
    """Marks an exception that we might want to debug.

    Before logging an exception or showing a message (potentially with
    format_exception()), you might want to call this. It's a no-op unless
    debugging is enabled in the configuration, in which case it will start a
    debugger.
    """
    if tb is None:
        tb = sys.exc_info()[2]
    if frame is None:
        tb_it = tb
        while tb_it.tb_next is not None:
            tb_it = tb_it.tb_next
        frame = tb_it.tb_frame

    # Whether to use the debugger
    try:
        from vistrails.core.configuration import get_vistrails_configuration
        debugger = getattr(get_vistrails_configuration(),
                           'developperDebugger',
                           False)
    except Exception:
        debugger = False
    if not debugger:
        return

    # Removes PyQt's input hook
    try:
        from PyQt4 import QtCore
    except ImportError:
        pass
    else:
        QtCore.pyqtRemoveInputHook()

    # Prints the exception and traceback
    print >>sys.stderr, "!!!!!!!!!!"
    print >>sys.stderr, "Got unexpected exception, starting debugger"
    traceback.print_tb(tb, file=sys.stderr)
    if e is not None:
        print >>sys.stderr, format_exception(e)

    # Starts the debugger
    print >>sys.stderr, "!!!!!!!!!!"
    # pdb.post_mortem()
    p = pdb.Pdb()
    p.reset()
    p.interaction(frame, tb)

# 需要导入模块: from PyQt4 import QtCore [as 别名]
# 或者: from PyQt4.QtCore import pyqtRemoveInputHook [as 别名]
    def startstop(self):
        self.mutex.acquire()
        try:
            self.t = time.time()

            if self.is_off():
                self.begin()
            else:
                self.quit(); 
        except:
            print 'Start Failed:'
            traceback.print_exc()
            QtCore.pyqtRemoveInputHook()
            ipdb.set_trace()
        finally:
            self.mutex.release()