Python QTimer.setInterval方法代码示例

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
    def __init__(self, process, input_queue, output_queue):
        super(MainWidget, self).__init__()
        self.done = False
        layout = QtGui.QVBoxLayout()

        logo = QtGui.QLabel()
        logo.setPixmap('./data/logo.png')
        logo.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter)
        layout.addWidget(logo)

        status_list = self.status_list = QtGui.QListWidget()
        status_list.addItem('Chowdren, the blazingly fast runtime for '
                            'Clickteam Fusion.')
        status_list.addItem(u'Copyright (c) Mathias K\xe6rlev 2012-2015.')
        status_list.addItem('Applications made with Chowdren are subject to '
                            'the GNU General Public License.')

        layout.addWidget(status_list)

        self.setLayout(layout)

        timer = QTimer(self)
        timer.setInterval(100)
        timer.timeout.connect(self.process_console)
        timer.start()

        self.process = process
        self.output_queue = output_queue
        self.input_queue = input_queue

        self.log = open('chowdrenlog.txt', 'wb')

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class Mlt(QtCore.QThread):
    s_producer_update = QtCore.Signal(object)
    s_play = QtCore.Signal(object)
    s_stop = QtCore.Signal(object)
    s_seek = QtCore.Signal(object)

    def __init__(self, parent=None):
        super(Mlt, self).__init__()
        self.parent = parent
        self.consumer = None
        self.producer = None
        self.movie_file = None
        self.profile = None

        self.position_timer = QTimer()
        self.position_timer.setInterval(125)
        self.position_timer.timeout.connect(self.onPositionTimeout)

    def onPositionTimeout(self):
        self.s_producer_update.emit(self.producer)

    def run(self):
        """
        starts thread
        """
        try:
            self.setup()
        except RuntimeError, err:
            print 'ERROR: Mlt.run: starting thread:', err
            self.quit()

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class ColumnResizer(QObject):
	def __init__(self):
		super(ColumnResizer, self).__init__()

		self._widgets = []
		self._gridColumnInfoList = []
		self._updateTimer = QTimer(self)
		self._updateTimer.setSingleShot(True)
		self._updateTimer.setInterval(0)
		self._updateTimer.timeout.connect(self._updateWidth)

	# Public methods

	def addWidgetsFromLayout(self, layout, column):
		"""
		:type layout: QGridLayout
		:type column: int
		"""
		assert column >= 0
		if isinstance(layout, QGridLayout):
			self._addWidgetsFromGridLayout(layout, column)
		else:
			print "ColumnResizerResizer does not support layouts of type:", type(layout)

	def eventFilter(self, obj, event):
		"""
		Overrides QObject.eventFilter()
		"""
		if event.type() == QEvent.Resize:
			self._scheduleWidthUpdate()
		return False

	# Private methods

	@Slot()
	def _updateWidth(self):
		width = 0
		for widget in self._widgets:
			width = max(widget.sizeHint().width(), width)
		for info in self._gridColumnInfoList:
			info[0].setColumnMinimumWidth(info[1], width)

	def _addWidget(self, widget):
		self._widgets.append(widget)
		widget.installEventFilter(self)
		self._scheduleWidthUpdate()

	def _addWidgetsFromGridLayout(self, layout, column):
		for row in range(layout.rowCount()):
			item = layout.itemAtPosition(row, column)
			if not item:
				continue
			widget = item.widget()
			if not widget:
				continue
			self._addWidget(widget)
		self._gridColumnInfoList.append([layout, column])

	def _scheduleWidthUpdate(self):
		self._updateTimer.start()

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class RecomenDesktopApp(TaskTrayApp):
    def __init__(self, parent=None):
        super(RecomenDesktopApp, self).__init__(parent)

        # :: DBへのアップデートチェック
        self.updateChecker = DBUpdateChecker()
        self.updateChecker.start()

        self.updateChecker.finished.connect(self.add_news)

        # :: DBの新規更新の定期チェック
        self.updateCheck_timer = QTimer()
        self.updateCheck_timer.setInterval(10)

        self.stack = []

    @Slot()
    def add_news(self, news):
        print "add_news"
        if not news.hasupdate:
            return

        for new in news.get_datas():
            if new in self.get_local_db():
                print "Non News late"
                continue
            self.add_stack(new)
            print "add stack"

    def add_stack(self, n):
        self.stack.append(n)


    def get_local_db(self):
        return [2,3,4,5]

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class Panel(QWidget):
    def __init__(self, parent=None, instr=None, lock=None, title="Instrument Panel"):
        # This class derivates from a Qt Widget so we have to call
        # the class builder ".__init__()"
        QWidget.__init__(self)
        # "self" is now a Qt Widget, then we load the user interface
        # generated with QtDesigner and call it self.ui
        self.ui = Keithley6221_Ui.Ui_Panel()
        # Now we have to feed the GUI building method of this object (self.ui)
        # with the current Qt Widget 'self', but the widgets from the design will actually be built as children
        # of the object self.ui
        self.ui.setupUi(self)
        self.setWindowTitle(title)
        self.reserved_access_to_instr = lock
        self.instr = instr
        self.monitor_timer = QTimer()
        # The timer would not wait for the completion of the task otherwise
        self.monitor_timer.setSingleShot(True)
        self.monitor_timer.timeout.connect(self.monitor)
        self.firsttime = 0
        # bug: if the box is checked in the .ui file, the system freezes
        # if self.ui.monitor.isChecked():self.monitor()

    def monitor(self, state=1):
        if state != 1:
            self.monitor_timer.stop()
        elif state and not (self.monitor_timer.isActive()):
            with self.reserved_access_to_instr:
                I = self.instr.query_current_source_amplitude()
                Vcomp = self.instr.query_voltage_compliance()
                outstate = self.instr.query_output_ON()
            self.ui.I_disp.setText(str(I * 1e6) + u" μA")
            self.ui.V_disp.setText(str(Vcomp) + " V")
            self.ui.outputON.setChecked(outstate)
            self.monitor_timer.start(self.ui.refresh_rate.value() * 1000)

    def update_timer_timeout(self, secs):
        # The value must be converted to milliseconds
        self.monitor_timer.setInterval(secs * 1000)

    def change_I(self, value=0):
        with self.reserved_access_to_instr:
            self.instr.set_current_source_amplitude(value * 1e6)

    def change_V_comp(self, value=0):
        with self.reserved_access_to_instr:
            self.instr.set_voltage_compliance(value)

    def switch_output(self, value=False):
        if value:
            with self.reserved_access_to_instr:
                self.instr.output_ON()
        else:
            with self.reserved_access_to_instr:
                self.instr.output_OFF()

    def reset_inst(self):
        with self.reserved_access_to_instr:
            self.instr.reset()

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class PhotoListModel(QAbstractListModel):
    URL_ROLE = Qt.UserRole + 1
    IMAGE_URL_ROLE = Qt.UserRole + 2
    HEIGHT_ROLE = Qt.UserRole + 3
    WIDTH_ROLE = Qt.UserRole + 4

    def __init__(self, album, parent=None):
        super(PhotoListModel, self).__init__(parent)
        self._album = album
        self._photos = []
        self._cache = []
        self._done = False
        keys = {}
        keys[PhotoListModel.URL_ROLE] = "url"
        keys[PhotoListModel.IMAGE_URL_ROLE] = "imageUrl"
        keys[PhotoListModel.HEIGHT_ROLE] = "height"
        keys[PhotoListModel.WIDTH_ROLE] = "width"
        self.setRoleNames(keys)
        self._load = PhotoLoad(self)
        self._load.start()
        self._timer = QTimer()
        self._timer.setInterval(1000)
        self._timer.timeout.connect(self.loadCache)
        self._timer.start()

    def rowCount(self, index):
        return len(self._photos)

    def appendCache(self, itens):
        self._cache += itens

    def loadCache(self):
        self.beginInsertRows(QModelIndex(), len(self._photos), len(self._photos) + len(self._cache))
        self._photos += self._cache
        self.endInsertRows()
        self._cache = []
        if self._done:
            self._timer.stop()

    def data(self, index, role):
        if not index.isValid():
            return None

        if index.row() > len(self._photos):
            return None

        img = self._photos[index.row()]
        if role == PhotoListModel.URL_ROLE:
            return img.url
        elif role == PhotoListModel.IMAGE_URL_ROLE:
            return img.imageUrl
        elif role == PhotoListModel.HEIGHT_ROLE:
            return img.height
        elif role == PhotoListModel.WIDTH_ROLE:
            return img.width
        else:
            return None

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class Watcher(QObject):

    fileDeleted = Signal((str,str,))
    fileAdded = Signal((str,str,))
    fileChanged = Signal((str,str,bool,))
    checked = Signal()
    ioError = Signal((str,))
    
    TOLERANCE = 15
    
    def __init__(self, parent=None):
        super(Watcher, self).__init__(parent)
       
        self.fileAdded.connect(self.added)
        self.fileChanged.connect(self.changed)
        self.fileDeleted.connect(self.deleted)
       
    @Slot()
    def checkout(self):
        raise NotImplementedError
    
    @Slot()
    def startCheckout(self):
        self.checkTimer = QTimer()
        self.checkTimer.setInterval(self.interval)
        self.checkTimer.timeout.connect(self.checkout)
        
        self.checkTimer.start()
        
    @Slot(str, str)
    def added(self, location, serverpath):
        print 'Added {0}: {1}'.format(self.LOCATION, serverpath)
        
    @Slot(str, str)
    def changed(self, location, serverpath):
        print 'Changed {0}: {1}'.format(self.LOCATION, serverpath)
        
    @Slot(str, str)
    def deleted(self, location, serverpath):
        print 'Deleted {0}: {1}'.format(self.LOCATION, serverpath)

    def localFromServer(self, serverpath):
        # Removing leading '/' so `os.path.join` doesn't treat
        # `localpath` as an absolute path
        localpath = serverpath[1:] if serverpath.startswith('/') else serverpath
        localpath = QDir.toNativeSeparators(localpath)
        localpath = os.path.join(self.localdir, localpath)
        
        return localpath
        
    def serverFromLocal(self, localpath):
        serverpath = localpath.replace(self.localdir, '')
        serverpath = QDir.fromNativeSeparators(serverpath)
        
        return serverpath

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class MidiMonitorUnit(unit.Sink, unit.Unit):
  def __init__(self, style='hex', show_time=False, *args, **kwargs):
    unit.Unit.__init__(self, *args, **kwargs)
    unit.Sink.__init__(self)
    self._style = style
    self._show_time = show_time
    self.messages = list()
    self._max_messages = 100
    self._client = jackpatch.Client('jackdaw-monitor')
    self._client.activate()
    self._sink_type = 'midi'
    self._sink_port = jackpatch.Port(client=self._client,
      name='capture', flags=jackpatch.JackPortIsInput)
    self._timer = QTimer()
    self._timer.setInterval(0)
    self._timer.timeout.connect(self.receive)
    self._timer.start()
  @property
  def style(self):
    return(self._style)
  @style.setter
  def style(self, value):
    if (value != self._style):
      self._style = value
      self.on_change()
  @property
  def show_time(self):
    return(self._show_time)
  @show_time.setter
  def show_time(self, value):
    if (value != self._show_time):
      self._show_time = value
      self.on_change()
  def receive(self):
    message_added = False
    while (True):
      result = self._sink_port.receive()
      if (result is None): break
      (data, time) = result
      self.messages.append((data, time))
      message_added = True
    if (message_added):
      # trim the message list if it gets too long to conserve memory
      if (len(self.messages) > self._max_messages):
        self.messages = self.messages[-self._max_messages:]
      self.on_change()
  def serialize(self):
    obj = unit.Unit.serialize(self)
    obj['style'] = self.style
    obj['show_time'] = self.show_time
    return(obj)

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class MyGlWidget(QGLWidget):
    "PySideApp uses Qt library to create an opengl context, listen to keyboard events, and clean up"

    def __init__(self, renderer, glformat, app):
        "Creates an OpenGL context and a window, and acquires OpenGL resources"
        super(MyGlWidget, self).__init__(glformat)
        self.renderer = renderer
        self.app = app
        # Use a timer to rerender as fast as possible
        self.timer = QTimer(self)
        self.timer.setSingleShot(True)
        self.timer.setInterval(0)
        self.timer.timeout.connect(self.render_vr)
        # Accept keyboard events
        self.setFocusPolicy(Qt.StrongFocus)

    def __enter__(self):
        "setup for RAII using 'with' keyword"
        return self

    def __exit__(self, type_arg, value, traceback):
        "cleanup for RAII using 'with' keyword"
        self.dispose_gl()

    def initializeGL(self):
        if self.renderer is not None:
            self.renderer.init_gl()
        self.timer.start()

    def paintGL(self):
        "render scene one time"
        self.renderer.render_scene()
        self.swapBuffers() # Seems OK even in single-buffer mode
        
    def render_vr(self):
        self.makeCurrent()
        self.paintGL()
        self.doneCurrent()
        self.timer.start() # render again real soon now

    def disposeGL(self):
        if self.renderer is not None:
            self.makeCurrent()
            self.renderer.dispose_gl()
            self.doneCurrent()

    def keyPressEvent(self, event):
        "press ESCAPE to quit the application"
        key = event.key()
        if key == Qt.Key_Escape:
            self.app.quit()

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class InputHandler(observable.Object):
  def __init__(self, port, target):
    observable.Object.__init__(self)
    # store the source port and the target to send data to
    self._port = port
    self._target = target
    # add an idle timer to check for input
    self._timer = QTimer()
    self._timer.setInterval(0)
    self._timer.timeout.connect(self.receive)
    self._timer.start()
  def destroy(self):
    self._timer.timeout.disconnect(self.receive)
    self._timer.stop()
  @property
  def port(self):
    return(self._port)
  @property
  def target(self):
    return(self._target)
  # check for input
  def receive(self, limit_time=True):
    # limit processing time to maintain responsiveness
    time_limit = time.time() + 0.100
    # wrap the target in a change block so each midi event doesn't waste a lot
    #  of time causing cascading changes
    target_and_refs = (self._target,)
    try:
      target_and_refs += self._target.model_refs
    except AttributeError: pass
    for model in target_and_refs:
      try:
        model.begin_change_block()
      except AttributeError: pass
    while (True):
      result = self._port.receive()
      if (result is None): break
      (data, msg_time) = result
      self.handle_message(data, msg_time)
      # handle at least one message per run, but limit overall processing time
      #  to keep the UI responsive, allowing the jackpatch buffer to handle 
      #  the backlog
      if ((limit_time) and (time.time() > time_limit)): break
    for model in target_and_refs:
      try:
        model.end_change_block()
      except AttributeError: pass
  # handle input, reimplement to pass data to the target
  def handle_message(data, time):
    pass

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
 def onLoopRequested(loopRequest):
     print 'l: ', l
     if l:
         l.pop()
         led.toggle(not led.isToggled())
     ledTimer = QTimer(toggleObject)
     ledTimer.setSingleShot(True)
     ledTimer.setInterval(200)
     ledTimer.timeout.connect(
         partial(
             loopRequest.completeRequest,
             True if l else False
         )
     )
     ledTimer.start()
     if not l: l.extend(range(20))

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class WalletController(QObject):
    onError = Signal(unicode)
    onConnected = Signal(bool)
    onTxSent = Signal(bool)
    onBusy = Signal()
    onDoubleEncrypted = Signal()
    onBalance = Signal()
    onWalletUnlocked = Signal()
    onCurrentBalance = Signal()
    onCurrentLabel = Signal()
    onCurrentAddress = Signal()
    onCurrentDoubleEncrypted = Signal()
    onCurrentPassKey = Signal()
    onCurrentWatchOnly = Signal()

    def __init__(self,):
        QObject.__init__(self,)
        self.thread = None
        self._balance = '<b>0.00</b>000000'
        self._wallet = Wallet()
        self._walletUnlocked = False
        self.settings = Settings()
        self.addressesModel = AddressesModel()
        self.transactionsModel = TransactionsModel()
        self.timer = QTimer(self)
        self.timer.setInterval(900000)  # 15 min update
        self.timer.timeout.connect(self.update)
        self.timer.start()

        if self.settings.storePassKey:
            self._currentPassKey = self.settings.passKey
            try:
                self.unlockWallet(self._currentPassKey)
            except:
                self.onError.emit('Stored pass phrase is invalid')
        else:
            self._currentPassKey = None
        self._currentAddressIndex = 0

    @Slot(unicode)
    def newAddr(self, doubleKey):
        try:
            self._wallet.createAddr(doubleKey)
            self.storeWallet()
            self.update()
        except (WrongPassword, DataError), err:
            self.onError.emit(unicode(err))

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class _VideoComponentEditor(_LaserComponentEditor):
    """
    """
    playTimer = Any
    fps = Int
    stop_timer = Event

    def init(self, parent):
        """
        Finishes initializing the editor by creating the underlying toolkit
        widget.

        """
        super(_VideoComponentEditor, self).init(parent)

        self.playTimer = QTimer(self.control)
        # self.playTimer.timeout.connect(self.update)
        self.control.connect(self.playTimer, SIGNAL('timeout()'), self.update)

        if self.value.fps:
            self.playTimer.setInterval(1000 / float(self.value.fps))
        self.playTimer.start()
        self.value.on_trait_change(self.stop, 'closed_event')

        self.value.on_trait_change(self._update_fps, 'fps')
        self.sync_value('stop_timer', 'stop_timer', mode='from')

    def _update_fps(self):
        if self.value.fps:
            self.playTimer.setInterval(1000 / float(self.value.fps))

    def stop(self):
        print 'VideoComponentEditor stop'
        try:
            self.playTimer.stop()
        except RuntimeError:
            pass

    def update(self):
        if self.control:
            # invoke_in_main_thread(self.value.request_redraw)
            self.value.request_redraw()

    def _stop_timer_fired(self):
        print 'VideoComponentEditor stopping playTimer'
        self.playTimer.stop()

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class _VideoComponentEditor(_LaserComponentEditor):
    """
    """

    playTimer = Any
    fps = Int
    stop_timer = Event

    def init(self, parent):
        """
        Finishes initializing the editor by creating the underlying toolkit
        widget.

        """
        super(_VideoComponentEditor, self).init(parent)

        self.playTimer = QTimer(self.control)
        self.playTimer.timeout.connect(self.update)
        if self.value.fps:
            self.playTimer.setInterval(1000 / self.value.fps)
        self.playTimer.start()
        self.value.on_trait_change(self.stop, "closed_event")

        self.value.on_trait_change(self._update_fps, "fps")
        self.sync_value("stop_timer", "stop_timer", mode="both")

    def _update_fps(self):
        if self.value.fps:
            self.playTimer.setInterval(1000 / self.value.fps)

    def stop(self):
        try:
            self.playTimer.stop()
        except RuntimeError:
            del self.playTimer

    def update(self):
        if self.control:
            self.value.draw_valid = False
            self.control.repaint()

    def _stop_timer_fired(self):
        print "VideoComponentEditor stopping playTimer"
        self.playTimer.stop()

# 需要导入模块: from PySide.QtCore import QTimer [as 别名]
# 或者: from PySide.QtCore.QTimer import setInterval [as 别名]
class Render(QWebView):
    def __init__(self, url, filename, image_crop, translate_page, parent=None):
        super(Render, self).__init__(parent)
        self.image_crop = image_crop
        self.fileName = time.strftime("%Y%m%d%H%M%S",time.localtime()) +"_test.jpg" 
        self.finished = False

        # Settings
        s = self.page().settings()
        s.setAttribute(QWebSettings.AutoLoadImages, True)
        s.setAttribute(QWebSettings.PluginsEnabled, True)
        s.setAttribute(QWebSettings.JavascriptEnabled, True)
        s.setAttribute(QWebSettings.JavaEnabled, False)
        s.setAttribute(QWebSettings.JavascriptCanOpenWindows, False)
        s.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)    

        #self.page().mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
        self.page().mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)

        self.timerScreen = QTimer()
        self.timerScreen.setInterval(10000)
        self.timerScreen.setSingleShot(True)
        self.timerScreen.timeout.connect(self.takeScreenshot)

        self.loadFinished.connect(self.timerScreen.start)
        self.load(QUrl(url)) 

    @Slot(QNetworkReply)           
    def takeScreenshot(self):        
        [x,y,width,height] = self.image_crop
        frame = self.page().mainFrame()
        size = frame.contentsSize()
        size.setWidth(1000)
        size.setHeight(2000)
        self.page().setViewportSize(size)
        image = QImage(self.page().viewportSize(), QImage.Format_ARGB32)
        painter = QPainter(image)
        frame.render(painter)
        painter.end()
        image1 = image.copy(x,y,width,height)
        image1.save(self.fileName)
        self.finished = True