def eventFilter(self, watched, event): if event.type() == QC.QEvent.Resize: parent = self.parent() if isinstance(parent, ResizingScrolledPanel): # weird hack fix for a guy who was getting QPaintEvents in here if not hasattr(event, 'oldSize'): return False old_size = event.oldSize() size = event.size() width_larger = size.width() > old_size.width() and size.height( ) >= old_size.height() height_larger = size.width() >= old_size.width( ) and size.height() > old_size.height() if width_larger or height_larger: QP.CallAfter(parent.WidgetJustSized, width_larger, height_larger) return False
def THREADdo_it(): try: mappings = HydrusNATPunch.GetUPnPMappings() except Exception as e: HydrusData.ShowException( e ) QP.CallAfter( QW.QMessageBox.critical, self, 'Error', 'Could not load mappings:'+os.linesep*2+str(e) ) return QP.CallAfter( qt_code, mappings )
def __init__( self, parent, controller, read_only, can_generate_more_pages, gallery_seed_log ): ClientGUIScrolledPanels.EditPanel.__init__( self, parent ) self._controller = controller self._read_only = read_only self._can_generate_more_pages = can_generate_more_pages self._gallery_seed_log = gallery_seed_log self._text = ClientGUICommon.BetterStaticText( self, 'initialising' ) # add index control row here, hide it if needed and hook into showing/hiding and postsizechangedevent on gallery_seed add/remove self._list_ctrl = ClientGUIListCtrl.BetterListCtrl( self, CGLC.COLUMN_LIST_GALLERY_SEED_LOG.ID, 30, self._ConvertGallerySeedToListCtrlTuples ) # self._list_ctrl.AddDatas( self._gallery_seed_log.GetGallerySeeds() ) self._list_ctrl.Sort() # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._text, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._list_ctrl, CC.FLAGS_EXPAND_BOTH_WAYS ) self.widget().setLayout( vbox ) self._list_ctrl.AddMenuCallable( self._GetListCtrlMenu ) self._controller.sub( self, 'NotifyGallerySeedsUpdated', 'gallery_seed_log_gallery_seeds_updated' ) QP.CallAfter( self._UpdateText )
def CallBlockingToQt(self, win, func, *args, **kwargs): def qt_code(win: QW.QWidget, job_key: ClientThreading.JobKey): try: if win is not None and not QP.isValid(win): raise HydrusExceptions.QtDeadWindowException( 'Parent Window was destroyed before Qt command was called!' ) result = func(*args, **kwargs) job_key.SetVariable('result', result) except (HydrusExceptions.QtDeadWindowException, HydrusExceptions.DBCredentialsException, HydrusExceptions.ShutdownException) as e: job_key.SetErrorException(e) except Exception as e: job_key.SetErrorException(e) HydrusData.Print('CallBlockingToQt just caught this error:') HydrusData.DebugPrint(traceback.format_exc()) finally: job_key.Finish() job_key = ClientThreading.JobKey() QP.CallAfter(qt_code, win, job_key) while not job_key.IsDone(): if HG.model_shutdown: raise HydrusExceptions.ShutdownException( 'Application is shutting down!') time.sleep(0.05) if job_key.HasVariable('result'): # result can be None, for qt_code that has no return variable result = job_key.GetIfHasVariable('result') return result if job_key.HadError(): e = job_key.GetErrorException() raise e raise HydrusExceptions.ShutdownException()
def __init__(self, parent, title, style=QC.Qt.Dialog, position='topleft'): QP.Dialog.__init__(self, parent) self.setWindowFlags(style) self.setWindowTitle(title) if parent is not None and position == 'topleft': parent_tlw = self.parentWidget().window() pos = parent_tlw.pos() + QC.QPoint(50, 50) self.move(pos) self.setWindowFlag(QC.Qt.WindowContextHelpButtonHint, on=False) self._new_options = HG.client_controller.new_options self.setWindowIcon(QG.QIcon(HG.client_controller.frame_icon_pixmap)) self._widget_event_filter = QP.WidgetEventFilter(self) if parent is not None and position == 'center': QP.CallAfter(QP.CenterOnWindow, parent, self) HG.client_controller.ResetIdleTimer()
def publish_callable( result ): if isinstance( result, Exception ): e = result QP.CallAfter( QW.QMessageBox.critical, self, 'Error', 'Could not load mappings:'+os.linesep*2+str(e) ) self._status_st.setText( str( e ) ) return self._mappings_listctrl_panel.setEnabled( True ) mappings = result self._mappings_lookup = { ( external_port, protocol ) for ( description, internal_ip, internal_port, external_port, protocol, duration ) in mappings } self._mappings_list.SetData( mappings ) self._status_st.clear() if self._external_ip is not None: self._status_st.setText( self._external_ip ) elif not self._started_external_ip_fetch: self._started_external_ip_fetch = True self._RefreshExternalIP()
def __init__( self, parent, controller, file_seed_cache ): ClientGUIScrolledPanels.EditPanel.__init__( self, parent ) self._controller = controller self._file_seed_cache = file_seed_cache self._text = ClientGUICommon.BetterStaticText( self, 'initialising' ) # add index control row here, hide it if needed and hook into showing/hiding and postsizechangedevent on file_seed add/remove self._list_ctrl = ClientGUIListCtrl.BetterListCtrl( self, CGLC.COLUMN_LIST_FILE_SEED_CACHE.ID, 30, self._ConvertFileSeedToListCtrlTuples, activation_callback = self._ShowSelectionInNewPage, delete_key_callback = self._DeleteSelected ) # self._list_ctrl.AddDatas( self._file_seed_cache.GetFileSeeds() ) self._list_ctrl.Sort() # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._text, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._list_ctrl, CC.FLAGS_EXPAND_BOTH_WAYS ) self.widget().setLayout( vbox ) self._list_ctrl.AddMenuCallable( self._GetListCtrlMenu ) self._controller.sub( self, 'NotifyFileSeedsUpdated', 'file_seed_cache_file_seeds_updated' ) QP.CallAfter( self._UpdateText )
def do_it(service): try: success = service.EnableNoCopy(True) except Exception as e: message = 'Problem: {}'.format(str(e)) QP.CallAfter(QW.QMessageBox.critical, None, 'Error', message) success = False finally: QP.CallAfter(qt_clean_up, success)
def do_it(): try: runner.run(suite) finally: QP.CallAfter(self.win.deleteLater)
def _BootWorker(self): def qt_code(): if self._window is None or not QP.isValid(self._window): return self.Work() QP.CallAfter(qt_code)
def qt_done(quit_afterwards): if not QP.isValid(self) or not QP.isValid( self._export) or not self._export: return self._export.setEnabled(True) if quit_afterwards: QP.CallAfter(self.parentWidget().close)
def do_it(): try: result = runner.run(suite) self.run_finished = True self.was_successful = result.wasSuccessful() finally: QP.CallAfter(self.win.deleteLater)
def THREADdo_it(): try: external_ip = HydrusNATPunch.GetExternalIP() external_ip_text = 'External IP: {}'.format(external_ip) except Exception as e: external_ip_text = 'Error finding external IP: ' + str(e) QP.CallAfter(qt_code, external_ip_text)
def do_it(service_key): def qt_code(recent_tags): if not self or not QP.isValid(self): return self._last_fetched_tags = recent_tags self._UpdateTagDisplay() recent_tags = HG.client_controller.Read('recent_tags', service_key) QP.CallAfter(qt_code, recent_tags)
def THREADFetchTags(self, script, job_key, file_identifier): def qt_code(tags): if not self or not QP.isValid(self): return self._SetTags(tags) self._have_fetched = True parse_results = script.DoQuery(job_key, file_identifier) tags = ClientParsing.GetTagsFromParseResults(parse_results) QP.CallAfter(qt_code, tags)
def _doWork( self ): def qt_deliver_result( result ): if self._win is None or not QP.isValid( self._win ): self._win = None return self._publish_callable( result ) with self._lock: self._calllater_waiting = False self._work_needs_to_restart = False self._is_working = True try: result = self._work_callable() try: HG.client_controller.CallBlockingToQt( self._win, qt_deliver_result, result ) except ( HydrusExceptions.QtDeadWindowException, HydrusExceptions.ShutdownException ): self._win = None return finally: with self._lock: self._is_working = False if self._work_needs_to_restart and not self._calllater_waiting: QP.CallAfter( self.update )
def Update(self, *args, **kwargs): if self._win is None: return with self._lock: self._args = args self._kwargs = kwargs if self._is_working: self._work_needs_to_restart = True elif not self._callafter_waiting: QP.CallAfter(self.QtDoIt)
def do_it(service): try: version = service.GetDaemonVersion() result = 'Running version {}.'.format(version) is_running = True except Exception as e: result = 'Problem: {}'.format(str(e)) is_running = False finally: QP.CallAfter(qt_clean_up, result, is_running)
def do_it( service_key, hash, search_tags, max_results, max_time_to_take ): def qt_code( predicates ): if not self or not QP.isValid( self ): return self._last_fetched_predicates = predicates self._UpdateTagDisplay() self._have_fetched = True predicates = HG.client_controller.Read( 'related_tags', service_key, hash, search_tags, max_results, max_time_to_take ) predicates = ClientSearch.SortPredicates( predicates ) QP.CallAfter( qt_code, predicates )
def eventFilter(self, watched, event): if event.type() == QC.QEvent.Resize: parent = self.parent() if isinstance(parent, ResizingScrolledPanel): old_size = event.oldSize() size = event.size() width_larger = size.width() > old_size.width() and size.height( ) >= old_size.height() height_larger = size.width() >= old_size.width( ) and size.height() > old_size.height() if width_larger or height_larger: QP.CallAfter(parent.WidgetJustSized, width_larger, height_larger) return False
def QtDoIt( self ): if self._win is None or not QP.isValid( self._win ): self._win = None return with self._lock: self._callafter_waiting = False self._work_needs_to_restart = False self._is_working = True args = self._args kwargs = self._kwargs try: self._func( *args, **kwargs ) except HydrusExceptions.ShutdownException: pass finally: with self._lock: self._is_working = False if self._work_needs_to_restart and not self._callafter_waiting: self._callafter_waiting = True QP.CallAfter( self.QtDoIt )
def do_it(): def qt_code(): if not self or not QP.isValid(self): return script_names_to_scripts = { script.GetName(): script for script in scripts } for (name, script) in list(script_names_to_scripts.items()): self._script_choice.addItem(script.GetName(), script) new_options = HG.client_controller.new_options favourite_file_lookup_script = new_options.GetNoneableString( 'favourite_file_lookup_script') if favourite_file_lookup_script in script_names_to_scripts: self._script_choice.SetValue( script_names_to_scripts[favourite_file_lookup_script]) else: self._script_choice.setCurrentIndex(0) self._script_choice.setEnabled(True) self._fetch_button.setEnabled(True) scripts = HG.client_controller.Read( 'serialisable_named', HydrusSerialisable.SERIALISABLE_TYPE_PARSE_ROOT_FILE_LOOKUP) QP.CallAfter(qt_code)
def do_it(service): try: nocopy_enabled = service.GetNoCopyEnabled() if nocopy_enabled: result = 'Nocopy is enabled.' else: result = 'Nocopy is not enabled.' except Exception as e: result = 'Problem: {}'.format(str(e)) nocopy_enabled = False finally: QP.CallAfter(qt_clean_up, result, nocopy_enabled)
def do_it(service): try: nocopy_available = service.GetNoCopyAvailable() if nocopy_available: result = 'Nocopy is available.' else: result = 'Nocopy is not available.' except Exception as e: result = 'Problem: {}'.format(str(e)) nocopy_available = False finally: QP.CallAfter(qt_clean_up, result, nocopy_available)
def EventShowMenu( self ): QP.CallAfter( self._ShowMenu )
def _ClickActivated( self, activation_reason ): # if we click immediately, some users get frozen ui, I assume a mix-up with the icon being destroyed during the same click event or similar QP.CallAfter( self._WasActivated, activation_reason )
def EventText(self, text): QP.CallAfter(self._CheckText)
def boot(): args = sys.argv[1:] if len(args) > 0: only_run = args[0] else: only_run = None try: threading.Thread(target=reactor.run, kwargs={ 'installSignalHandlers': 0 }).start() QP.MonkeyPatchMissingMethods() app = QW.QApplication(sys.argv) app.call_after_catcher = QP.CallAfterEventCatcher(app) try: # we run the tests on the Qt thread atm # keep a window alive the whole time so the app doesn't finish its mainloop win = QW.QWidget(None) win.setWindowTitle('Running tests...') controller = TestController.Controller(win, only_run) def do_it(): controller.Run(win) QP.CallAfter(do_it) app.exec_() except: HydrusData.DebugPrint(traceback.format_exc()) finally: HG.started_shutdown = True HG.view_shutdown = True controller.pubimmediate('wake_daemons') HG.model_shutdown = True controller.pubimmediate('wake_daemons') controller.TidyUp() except: HydrusData.DebugPrint(traceback.format_exc()) finally: reactor.callFromThread(reactor.stop) print('This was version ' + str(HC.SOFTWARE_VERSION)) if sys.stdin.isatty(): input('Press any key to exit.') if controller.was_successful: sys.exit(0) else: sys.exit(1)
def seek_event( event ): QP.CallAfter( qt_seek_event )
def _BootWorker(self): QP.CallAfter(self._QTWork)