def __init__(self, parent): """Init class. Args: parent (QWidget) """ super().__init__(parent) # parameters self._filter_state = set() self._filter_empty_state = False self._search_text = '' self.search_delay = 200 # create ui elements self._ui_vertical_layout = QVBoxLayout(self) self._ui_list = QListView() self._ui_edit = QLineEdit() self._ui_edit.setPlaceholderText('Search') self._ui_edit.setClearButtonEnabled(True) self._ui_buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) self._ui_vertical_layout.addWidget(self._ui_edit) self._ui_vertical_layout.addWidget(self._ui_list) self._ui_vertical_layout.addWidget(self._ui_buttons) # add models self._search_timer = QTimer( ) # Used to limit search so it doesn't search when typing self._search_timer.setSingleShot(True) self._filter_model = None
def registerThread(self): """ This slot shall be called from each activated nexxT thread with a direct connection. :return: """ t = QThread.currentThread() logger.internal("registering thread %s", t.objectName()) with self._lockThreadSpecific: if not t in self._threadSpecificProfiling: self._threadSpecificProfiling[t] = ThreadSpecificProfItem() self._threadSpecificProfiling[t].timer = QTimer( parent=self.sender()) self._threadSpecificProfiling[t].timer.timeout.connect( self._generateRecord, Qt.DirectConnection) self._threadSpecificProfiling[t].timer.setInterval( int(ThreadSpecificProfItem.THREAD_PROFILING_PERIOD_SEC * 1e3)) self.stopTimers.connect( self._threadSpecificProfiling[t].timer.stop) self.startTimers.connect( self._threadSpecificProfiling[t].timer.start) if self._loadMonitoringEnabled: self._threadSpecificProfiling[t].timer.start() tmain = QCoreApplication.instance().thread() if self._mi is None and not tmain in self._threadSpecificProfiling: self._mi = MethodInvoker( dict(object=self, method="registerThread", thread=tmain), Qt.QueuedConnection)
def __init__(self): QObject.__init__(self) # QTimer - Run Timer self.timer = QTimer() self.timer.timeout.connect(lambda: self.setTime()) self.timer.start(1000)
def start_timer(self): if not self.timer: self.timer = QTimer(self) self.timer.timeout.connect(self.on_error_received) self.timer.setInterval(100) # self.timer.setSingleShot(True) self.timer.start()
def initializeGL(self): glMatrixMode(GL_PROJECTION) gluPerspective(45.0, self.width() / self.height(), 0.1, 100.0) glMatrixMode(GL_MODELVIEW) self.__timer = QTimer() self.__timer.timeout.connect(self.repaint) self.__timer.start(1000 / self.frameRate)
def __init__(self, *args, **kwargs): super(NetPosition, self).__init__(*args, **kwargs) self.timeout_count = 0 # 计算显示的次数,虚假显示‘正在计算’字样 self.tips_animation_timer = QTimer(self) # 显示文字提示的timer self.tips_animation_timer.timeout.connect(self.animation_tip_text) self.query_button.clicked.connect(self.get_net_position)
def __init__(self): super().__init__() self._timer = timer = QTimer() timer.setSingleShot(False) timer.setInterval(10) timer.timeout.connect(self._onTimer) timer.start()
def main(): basePath = os.path.dirname(os.path.realpath(__file__)) app = QApplication(sys.argv) contextMenu = QMenu() fixAction = QAction( "Run 'create__ap --fix-unmanaged' in the terminal as root to fix possible issues" ) contextMenu.addAction(fixAction) activeIcon = QIcon() activeIcon.addFile(os.path.join(basePath, "wifi.svg")) inactiveIcon = QIcon() inactiveIcon.addFile(os.path.join(basePath, "wifi-off.svg")) trayIcon = QSystemTrayIcon(inactiveIcon) trayIcon.setContextMenu(contextMenu) trayIcon.activated.connect(handleTrayIconClick) def syncIcon(): if serviceIsActive(): trayIcon.setIcon(activeIcon) else: trayIcon.setIcon(inactiveIcon) timer = QTimer() timer.setInterval(1000) timer.timeout.connect(syncIcon) timer.start() trayIcon.show() sys.exit(app.exec_())
def __init__(self, window, G, options, main=None): super().__init__() self.timer = QTimer() self.alive_timer = QElapsedTimer() self.g = G self.window = window self.view_menu = QMenu() self.file_menu = QMenu() self.forces_menu = QMenu() self.main_widget = window self.docks = {} self.widgets = {} self.widgets_by_type = {} available_geometry = QApplication.desktop().availableGeometry() window.move((available_geometry.width() - window.width()) / 2, (available_geometry.height() - window.height()) / 2) self.__initialize_file_menu() viewMenu = window.menuBar().addMenu(window.tr("&View")) forcesMenu = window.menuBar().addMenu(window.tr("&Forces")) actionsMenu = window.menuBar().addMenu(window.tr("&Actions")) restart_action = actionsMenu.addAction("Restart") self.__initialize_views(options, main) self.alive_timer.start() self.timer.start(500)
def __init__(self): QObject.__init__(self) # AUTO REFRESH / DYNAMIC INFOS timer = QTimer(self) timer.start(1000) timer.timeout.connect(lambda: self.setDynamicInfo())
def __init__(self, log_lvl): super(LogFileHandler, self).__init__() logging.debug('LogFileHandler::__init__() called') self.log_lvl = log_lvl self.log_path = Path.home() / 'Pythonic' / 'log' self.log_date = datetime.datetime.now() self.formatter = logging.Formatter( fmt='%(asctime)s - %(levelname)s - %(message)s', datefmt='%H:%M:%S') self.logger = logging.getLogger() # Apply log_lvl self.logger.setLevel(self.log_lvl) self.logger.propagate = False # Remove default Stream Handler self.logger.removeHandler(self.logger.handlers[0]) # Create directory structure for logging self.log_date_str = self.log_date.strftime('%Y_%m_%d') file_path = '{}/{}.txt'.format(str(self.log_path), self.log_date_str) # Setup logger file_handler = logging.FileHandler(file_path) file_handler.setLevel(self.log_lvl) file_handler.setFormatter(self.formatter) self.logger.addHandler(file_handler) self.timer = QTimer() self.timer.start(1000) self.timer.timeout.connect(self.checkLogDate)
def __init__(self, png, tank_item: TankItem, direction: Direction): QGraphicsPixmapItem.__init__(self, png) self.tank_item = tank_item self.tank = tank_item.tank self.direction = direction self.available = True if self.direction == Direction.UP: self.setX(self.tank_item.x() + cube_size / 2 - 3) self.setY(self.tank_item.y()) elif self.direction == Direction.DOWN: self.setX(self.tank_item.x() + cube_size / 2 + 3) self.setY(self.tank_item.y() + cube_size) self.setRotation(180) elif self.direction == Direction.LEFT: self.setX(self.tank_item.x()) self.setY(self.tank_item.y() + cube_size / 2 + 3) self.setRotation(270) elif self.direction == Direction.RIGHT: self.setX(self.tank_item.x() + cube_size) self.setY(self.tank_item.y() + cube_size / 2 - 3) self.setRotation(90) self.timer = QTimer() self.timer.setInterval(interval) self.timer.timeout.connect(self.move) self.timer.start()
def __init__(self, png): super().__init__(png, Direction.DOWN) self.setRotation(180) self.auto_timer = QTimer() self.auto_timer.setInterval(1000) self.auto_timer.timeout.connect(self.auto) self.auto_timer.start()
def __init__(self): self.logger = logging_util.SporeLogger(__name__) self.timer = QTimer() self.timer.timeout.connect(self.send_report) self.last_msg = 0.0 self.msg_stack = []
def __init__(self, ui): """ Initializes file drag&drop events on to the Main Window and handles the py shop layering threads. :param modules.gui.main_window.MainWindow ui: Application QMainWindow """ super(FileDrop, self).__init__(parent=ui) self.ui = ui self.ui.cancelBtn.released.connect(self.cancel_thread) # --- Install file drop on main window --- self.ui.setAttribute(Qt.WA_AcceptDrops) self.ui.installEventFilter(self) # -- Open file delay -- self.file_timer = QTimer() self.file_timer.setInterval(1500) self.file_timer.setSingleShot(True) self.file_timer.timeout.connect(self._open_psd_file) # Hide cancel btn self.ui.cancelBtn.hide() self.ui.lastFileWidget.hide() self.py_shop_thread = CreateLayeredPsdThread(self, list())
def __init__(self, qmp): QMainWindow.__init__(self) self.qmp = qmp shortcut = QShortcut(QKeySequence('Ctrl+r'), self, activated=self.disp_output) self.timer = QTimer(self) self.timer.timeout.connect(self.disp_output) # self.timer.start(100) self.activated = 0 open('/tmp/errors.log', 'w').close() self.qmp.hmp_command('logfile /tmp/errors.log') self.qmp.hmp_command('log guest_error') self.setWindowTitle('Error Log') self.setGeometry(100, 100, 600, 400) self.menu_bar() self.init_ui()
def __init__(self, app, state: State, screenFPS, fixedFPS, parent=None): """ The MainWindow is created by the application, here we handle ui/scenes and send out updates. :param state: The current state we want to start with. :param parent: The widget this held under, None by default because this is top widget """ QMainWindow.__init__(self, parent) self.app = app # the application created self.gameScreen = None # where all graphics are drawn self.uiManager = UiManager(self, customWidgets=[ GameScreen ]) # Loads widgets into window from a file self.stateManager = StateManager( self, state) # Manages state updates and transitions self.updateFPSTimer = QTimer(self) # Used to manage frame timings self.updateFPSTimer.timeout.connect(self.__calculateFPS) self.fixedFps = 0 # Calculated FPS self.screenFps = 0 self.fixedFrames = 0 # Accumulated Frames self.screenFrames = 0 self.targetFixedFPS = fixedFPS self.targetUpdateFPS = screenFPS self.fixedTiming = 1 / self.targetFixedFPS self.screenTiming = 1 / self.targetUpdateFPS self.fixedNeeded = fixedFPS self.screenNeeded = screenFPS self.lastTime = 0 self.setMouseTracking(True) self.uiManager.keepWidgets = self.children()
def exposeEvent(self, event): if self.isExposed(): self.render() if self.timer is None: self.timer = QTimer(self) self.timer.timeout.connect(self.slotTimer) self.timer.start(10)
def __init__(self): super().__init__() self.threadpool = QThreadPool() print("Multithreading with maximum %d threads" % self.threadpool.maxThreadCount()) self.counter = 0 layout = QVBoxLayout() self.l = QLabel("Start") b = QPushButton("DANGER!") b.pressed.connect(self.oh_no) layout.addWidget(self.l) layout.addWidget(b) w = QWidget() w.setLayout(layout) self.setCentralWidget(w) self.show() self.timer = QTimer() self.timer.setInterval(1000) self.timer.timeout.connect(self.recurring_timer) self.timer.start()
def __init__(self, scatter, s_data): self.scatter = scatter self._s_data = s_data self.timer = QTimer() self.series = QtDataVisualization.QScatter3DSeries() self.data = [ QVector3D(0.5, 0.5, 0.5), QVector3D(-0.3, -0.5, -0.4), QVector3D(0.0, -0.3, 0.2) ] self.series.dataProxy().addItems(self.data) self.series.setItemSize(0.5) self.series.setMeshSmooth(True) self.scatter.addSeries(self.series) self.scatter.setAspectRatio(1.0) self.scatter.setHorizontalAspectRatio(1.0) # Setting of plot limits self.scatter.axisX().setRange(0, s_data.getBoxWidth()) self.scatter.axisY().setRange(0, s_data.getBoxWidth()) self.scatter.axisZ().setRange(0, s_data.getBoxWidth()) self._time_step = s_data.getTimeStep() * 1000 self.timer.timeout.connect(self.makeStep) # Drowing of the data and starting of the timer self.drawData() self.timer.start(self._time_step)
def __init__(self, owner): super(self.__class__, self).__init__(owner) Ui_Loading.__init__(self) self.setupUi(self) self.owner = weakref.ref(owner) self.setWindowFlag(QtCore.Qt.FramelessWindowHint) self.setWindowFlag(QtCore.Qt.Dialog) self.setAttribute(QtCore.Qt.WA_TranslucentBackground) self.setWindowModality(QtCore.Qt.ApplicationModal) # frmX = self.width() # frmY = self.height() # w = QDesktopWidget() # w.width() # movePoint = QPoint(int(w.width()/2-frmX/2), int(w.height()/2 - frmY/2)) # self.move(movePoint) self.index = 1 self.qMapList = [] for i in range(1, 11): data = resources.DataMgr.GetData("loading_{}".format(str(i))) img = QImage() img.loadFromData(data) self.qMapList.append(img) self.label.setFixedSize(QPixmap.fromImage(self.qMapList[0]).size()) self.label.setPixmap(QPixmap.fromImage(self.qMapList[0])) self.label.setScaledContents(True) self.timer = QTimer(self.label) self.timer.setInterval(100) self.cnt = 0 self.closeCnt = 50 self.timer.timeout.connect(self.UpdatePic)
def reset(self) -> bool: """Reset the dimmer and start counting down again. If it was busy dimming, it will immediately stop dimming. Callback fires to set brightness back to normal.""" self.__stopped = False if self.__timer: self.__timer.stop() if self.__change_timer: self.__change_timer.stop() if self.timeout: self.__timer = QTimer() self.__timer.setSingleShot(True) self.__timer.timeout.connect(partial(self.change_brightness)) self.__timer.start(self.timeout * 1000) if self.__dimmer_brightness != self.brightness: previous_dimmer_brightness = self.__dimmer_brightness self.brightness_callback(self.brightness) self.__dimmer_brightness = self.brightness if previous_dimmer_brightness < 10: return True return False
def __init__(self, title, finish: datetime.datetime, maxRemain=3000000000, display_fmt="ms", parent=None): super().__init__(parent) self.setupUi(self) self.display_fmt = display_fmt self.finish = finish self.maxRemain = maxRemain self.remainer.setMaximum(maxRemain // 1000) self.setTitle(title) self.timerUpdate = QTimer(self) self.timerUpdate.timeout.connect(self.updateRemainer) if self.display_fmt in ("ms", "xms"): self.timerUpdate.start(47) elif self.display_fmt in ("sec", "xsec"): self.timerUpdate.start(900) elif self.display_fmt in ("min", "xmin"): self.timerUpdate.start(5000) elif self.display_fmt in ("hour", "xhr"): self.timerUpdate.start(5000) elif self.display_fmt in ("day", "xday"): self.timerUpdate.start(10000) else: self.display_fmt = "ms" self.timerUpdate.start(47) self.updateRemainer()
def __init__(self): # 按钮使能(否) gui.pushButton_3.setEnabled(False) gui.file = gui.open_video() if not gui.file: return gui.label.setText("正在读取请稍后...") # 设置时钟 self.v_timer = QTimer() # self. # 读取视频 self.cap = cv2.VideoCapture(gui.file) if not self.cap: print("打开视频失败") return # 获取视频FPS self.fps = self.cap.get(cv2.CAP_PROP_FPS) # 获得码率 # 获取视频总帧数 self.total_f = self.cap.get(cv2.CAP_PROP_FRAME_COUNT) # 获取视频当前帧所在的帧数 self.current_f = self.cap.get(cv2.CAP_PROP_POS_FRAMES) # 设置定时器周期,单位毫秒 self.v_timer.start(int(1000 / self.fps)) print("FPS:".format(self.fps)) # 连接定时器周期溢出的槽函数,用于显示一帧视频 self.v_timer.timeout.connect(self.show_pic) # 连接按钮和对应槽函数,lambda表达式用于传参 gui.pushButton_5.clicked.connect(self.go_pause) print("init OK")
def cycle_images(self): if self.radioButton.isChecked(): self.timer = QTimer(self) self.timer.timeout.connect(self.load_image) self.timer.start(1500) else: self.timer.stop()
def __init__(self): super().__init__() self.node_set = NodeSet() self.parent = QWidget() self.parent.hide() self.parent.setWindowFlags(self.parent.windowFlags() & ~QtCore.Qt.Tool) self.system_tray = SystemTray(self.parent, self.node_set) self.setQuitOnLastWindowClosed(False) self.aboutToQuit.connect(self.quit_app) self.system_tray.show() self.system_tray.showMessage('Nodes starting...', 'Bitcoin and Lightning are syncing') self.node_set.bitcoin.file.file_watcher.fileChanged.connect( self.check_restart_required) self.node_set.lnd.file.file_watcher.fileChanged.connect( self.check_restart_required) self.timer = QTimer(self) self.timer.start(1000) self.timer.timeout.connect(self.check_restart_required) self.timer.singleShot(1000, self.check_version)
def __init__(self, config, resource): """Setup each channel widget and place in QVBoxlayout""" QWidget.__init__(self) self.config = config self.resource = resource area = QScrollArea() contents = QWidget() rows = QVBoxLayout(contents) layout = QVBoxLayout(self) layout.addWidget(area) area.setWidget(contents) area.setWidgetResizable(True) layout.setContentsMargins(0, 0, 0, 0) rows.setContentsMargins(0, 0, 0, 0) rows.setSpacing(0) self.channels = [] for channel in config["channels"]: self.channels.append( ChannelWidget(channel["channel"], config, resource)) rows.addWidget(self.channels[-1]) # Set initial status and set status timer self.update_status() self.timer = QTimer() self.timer.timeout.connect(self.update_status) self.timer.start(UPDATE_INTERVAL)
def __init__(self): QMainWindow.__init__(self) self.date_view = QListView() self.forum_view = QListView() self.contentMax = 0 self.ioloop = asyncio.get_event_loop() icon = QIcon() icon.addPixmap(QPixmap(FAVICON_ICO), QIcon.Normal) self.setWindowIcon(icon) self.setWindowTitle(APP_TITLE) self.settings = QSettings('karoStudio', 'nnm-stats') self.resize(self.settings.value('main/size', QSize(640, 480))) self.move(self.settings.value('main/pos', QPoint(200, 200))) self.splitter = QSplitter() self.get_menu() self.content = QScrollArea() self.content.verticalScrollBar().valueChanged.connect( self.scrollBarChanged) self.content.verticalScrollBar().rangeChanged.connect( self.rangeChanged) self.torrents_list_view = QWidget() layout = QGridLayout() self.torrents_list_view.setLayout(layout) self.content.setWidget(self.torrents_list_view) self.splitter.addWidget(self.content) self.splitter.setSizes([160, 350]) self.setCentralWidget(self.splitter) self.timer = QTimer() self.timer.singleShot(1600, self.load_task)
def __init__(self, ui_file, parent=None): self.remaining_time = 10 super(Form, self).__init__(parent) ui_file = QFile(ui_file) ui_file.open(QFile.ReadOnly) loader = QUiLoader() self.window = loader.load(ui_file) ui_file.close() self.btn_clear = self.window.findChild(QPushButton, "btn_clear") self.btn_skip = self.window.findChild(QPushButton, "btn_skip") self.btn_undo = self.window.findChild(QPushButton, "btn_undo") self.label_timer = self.window.findChild(QLabel, "label_timer") self.log = self.window.findChild(QPlainTextEdit, "log") self.picture_holder = self.window.findChild(QLabel, "picture_holder") self.gen_line = QLine() self.timer = QTimer(self) #self.timer.timeout.connect(self.stop_game) self.timer.start(1000) #QTimer.singleShot(1000, self.redraw_label_timer) QObject.connect(self.timer, SIGNAL('timeout()'), self.redraw_label_timer) self.window.show()
def __init__(self): QWidget.__init__(self) self.setMinimumSize(800, 600) self.donuts = [] self.chart_view = QtCharts.QChartView() self.chart_view.setRenderHint(QPainter.Antialiasing) self.chart = self.chart_view.chart() self.chart.legend().setVisible(False) self.chart.setTitle("Nested donuts demo") self.chart.setAnimationOptions(QtCharts.QChart.AllAnimations) self.min_size = 0.1 self.max_size = 0.9 self.donut_count = 5 self.setup_donuts() # create main layout self.main_layout = QGridLayout(self) self.main_layout.addWidget(self.chart_view, 1, 1) self.setLayout(self.main_layout) self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_rotation) self.update_timer.start(1250)