def loadImage(self, relativeImagePath): """ Replaces the underlying image (if any is loaded) to the image on given relative path Relative path is relative to the directory where the .imageset file resides (which is usually your project's imageset resource group path) """ # If imageMonitor is null, then no images are being watched or the # editor is first being opened up # Otherwise, the image is being changed or switched, and the monitor # should update itself accordingly if self.imageMonitor != None: self.imageMonitor.removePath(self.getAbsoluteImageFile()) self.imageFile = relativeImagePath self.setPixmap(QtGui.QPixmap(self.getAbsoluteImageFile())) self.transparencyBackground.setRect(self.boundingRect()) # go over all image entries and set their position to force them to be constrained # to the new pixmap's dimensions for imageEntry in self.imageEntries: imageEntry.setPos(imageEntry.pos()) imageEntry.updateDockWidget() self.visual.refreshSceneRect() # If imageMonitor is null, allocate and watch the loaded file if self.imageMonitor == None: self.imageMonitor = QtCore.QFileSystemWatcher(None) self.imageMonitor.fileChanged.connect(self.slot_imageChangedByExternalProgram) self.imageMonitor.addPath(self.getAbsoluteImageFile())
def addFileMonitor(self, path): """Adds a file monitor to the specified file so CEED will alert the user that an external change happened to the file""" if self.fileMonitor is None: self.fileMonitor = QtCore.QFileSystemWatcher(self.mainWindow) self.fileMonitor.fileChanged.connect(self.slot_fileChangedByExternalProgram) self.fileMonitor.addPath(path)
def __init__(self, launch_file, package=None, masteruri=None, argv=[]): ''' Creates the LaunchConfig object. The launch file will be not loaded on creation, first on request of Roscfg value. @param launch_file: The absolute or relative path with the launch file. By using relative path a package must be valid for remote launches. @type launch_file: C{str} @param package: the package containing the launch file. If None the launch_file will be used to determine the launch file. No remote launches a possible without a valid package. @type package: C{str} or C{None} @param masteruri: The URL of the ROS master. @type masteruri: C{str} or C{None} @param argv: the list the arguments needed for loading the given launch file @type argv: C{[str]} @raise roslaunch.XmlParseException: if the launch file can't be found. ''' QtCore.QObject.__init__(self) self.__launchFile = launch_file self.__package = self.packageName(os.path.dirname( self.__launchFile))[0] if package is None else package self.__masteruri = masteruri if not masteruri is None else 'localhost' self.__roscfg = None self.argv = argv self.__reqTested = False self.global_param_done = [ ] # masteruri's where the global parameters are registered self.hostname = nm.nameres().getHostname(self.__masteruri) self.file_watcher = QtCore.QFileSystemWatcher() self.file_watcher.fileChanged.connect(self.on_file_changed) self.changed = {}
def __init__(self, directory, regex, parent=None): super(NewFileWatcher, self).__init__(parent) print(u'Watching [{0}]'.format(directory)) self._directory = Path(directory) self._regex = regex self._previous_files = self._matching_files() self._watch = QtCore.QFileSystemWatcher([unicode(directory)]) self._watch.directoryChanged.connect(self.changed)
def __init__(self, pParentDialog): super(NamespaceTableModel, self).__init__() self.mParentDialog = pParentDialog self.mRefFilePath = {} self.mRefFileReload = {} self.mSys = FBSystem() self.mWatcher = QtCore.QFileSystemWatcher() self.mOnlyRef = True self.mNamespaces = [] self.mNamespacesFlag = [] # is loaded and file exist self.Init()
def __init__(self, notemodel_dict): super(NoteListWidget, self).__init__() self.session_notemodel_dict = notemodel_dict self.itemDoubleClicked.connect(self._dblclick_pin_note) self.previous_item = None self.currentItemChanged.connect(self._update_previous_item) self._notes_dir = None self.dir_watcher = QtCore.QFileSystemWatcher(self) # self.dir_watcher.directoryChanged.connect(self.update_list) self.update_list()
def open(self, filename): self.file_path = filename with open(filename) as f: self.file_contents = f.read() self.setPlainText(self.file_contents) self.parent_dir = os.path.abspath( os.path.join(self.file_path, os.pardir)) # Watch the file we've opened self.fileSysWatcher = QtCore.QFileSystemWatcher() self.fileSysWatcher.addPath(self.parent_dir) QtCore.QObject.connect(self.fileSysWatcher, QtCore.SIGNAL("directoryChanged(QString)"), self, QtCore.SLOT("slotDirChanged(QString)"))
def watch(self, widget, stylesheet_path): """ Establishes a live link between a widget and a stylesheet. When modified, the stylesheet will be reapplied to the widget. Args: widget: (QtGui.QWidget) A widget to apply style to. stylesheet_path: (str) Absolute file path on disk to a .css stylesheet. Returns: (None) """ self._widget_sheet_map[stylesheet_path].append(widget) self._watcher = QtCore.QFileSystemWatcher() self._watcher.addPath(stylesheet_path) self._watcher.fileChanged.connect(self.update) self.update()
def initUI(self): """top menu bar and the text area""" # Menu bar menuBar = QtGui.QHBoxLayout() self.saveButton = QtGui.QPushButton("&Save", self) self.saveButton.clicked.connect(self.saveText) self.readButton = QtGui.QPushButton("&Reload", self) self.readButton.clicked.connect(self.loadText) menuBar.addWidget(self.saveButton) menuBar.addWidget(self.readButton) menuBar.addStretch(1) self.layout().addLayout(menuBar) # Text self.text = CustomTextEdit(self) self.text.setTabChangesFocus(True) # Font self.font = QtGui.QFont() self.font.setFamily("Inconsolata") self.font.setStyleHint(QtGui.QFont.Monospace) self.font.setFixedPitch(True) self.font.setPointSize(self.defaultFontSize) self.text.setFont(self.font) self.highlighter = ModifiedMarkdownHighlighter(self.text.document()) # watch notebooks on the filesystem for changes self.fileSystemWatcher = QtCore.QFileSystemWatcher(self) self.layout().addWidget(self.text)
def __init__(self, handlers=None): super(QtWatcher, self).__init__(handlers=handlers) self.__watcher = QtCore.QFileSystemWatcher() self.__watcher.fileChanged.connect(self.__on_event) self.__watcher.directoryChanged.connect(self.__on_event)
def on_ex_simulate(self): """ Defines what happens on simulation button press. It shows the run window and starts a background process with dualsphysics running. Updates the window with useful info.""" refocus_cwd() if Case.the().info.needs_to_run_gencase: # Warning window about save_case warning_dialog("You should run GenCase again. Otherwise, the obtained results may not be as expected") static_params_exe = [Case.the().get_out_xml_file_path(), Case.the().get_out_folder_path(), "-{device}".format(device=self.device_selector.currentText().lower()), "-svres"] additional_parameters = list() if Case.the().info.run_additional_parameters: additional_parameters = Case.the().info.run_additional_parameters.split(" ") final_params_ex = static_params_exe + additional_parameters cmd_string = "{} {}".format(Case.the().executable_paths.dsphysics, " ".join(final_params_ex)) run_dialog = RunDialog(case_name=Case.the().name, processor=self.device_selector.currentText(), number_of_particles=Case.the().info.particle_number, cmd_string=cmd_string, parent=get_fc_main_window()) run_dialog.set_value(0) run_dialog.run_update(0, 0, None) Case.the().info.is_simulation_done = False run_fs_watcher = QtCore.QFileSystemWatcher() self.simulation_started.emit() # Cancel button handler def on_cancel(): log(__("Stopping simulation")) if process: process.kill() run_dialog.hide_all() Case.the().info.is_simulation_done = True self.simulation_cancelled.emit() run_dialog.cancelled.connect(on_cancel) # Launch simulation and watch filesystem to monitor simulation filelist = [f for f in os.listdir(Case.the().path + "/" + Case.the().name + "_out/") if f.startswith("Part")] for f in filelist: os.remove(Case.the().path + "/" + Case.the().name + "_out/" + f) def on_dsph_sim_finished(exit_code): """ Simulation finish handler. Defines what happens when the process finishes.""" # Reads output and completes the progress bar output = str(process.readAllStandardOutput().data(), encoding='utf-8') run_dialog.set_detail_text(str(output)) run_dialog.run_complete() run_fs_watcher.removePath(Case.the().path + "/" + Case.the().name + "_out/") if exit_code == 0: # Simulation went correctly Case.the().info.is_simulation_done = True Case.the().info.needs_to_run_gencase = False self.simulation_complete.emit(True) else: # In case of an error Case.the().info.needs_to_run_gencase = True if "exception" in str(output).lower(): log("There was an error on the execution. Opening an error dialog for that.") run_dialog.hide() self.simulation_complete.emit(False) error_dialog(__("An error occurred during execution. Make sure that parameters exist and are properly defined. " "You can also check your execution device (update the driver of your GPU). Read the details for more information."), str(output)) save_case(Case.the().path, Case.the()) # Launches a QProcess in background process = QtCore.QProcess(get_fc_main_window()) process.finished.connect(on_dsph_sim_finished) process.start(Case.the().executable_paths.dsphysics, final_params_ex) def on_fs_change(): """ Executed each time the filesystem changes. This updates the percentage of the simulation and its details.""" run_file_data = "" with open(Case.the().path + "/" + Case.the().name + "_out/Run.out", "r") as run_file: run_file_data = run_file.readlines() # Fill details window run_dialog.set_detail_text("".join(run_file_data)) # Set percentage scale based on timemax for l in run_file_data: if Case.the().execution_parameters.timemax == -1: if "TimeMax=" in l: Case.the().execution_parameters.timemax = float(l.split("=")[1]) current_value: float = 0.0 totalpartsout: int = 0 last_estimated_time = None # Update execution metrics last_part_lines = list(filter(lambda x: "Part_" in x and "stored" not in x and " " in x, run_file_data)) if last_part_lines: current_value = (float(last_part_lines[-1].split(None)[1]) * float(100)) / float(Case.the().execution_parameters.timemax) else: current_value = None # Update particles out last_particles_out_lines = list(filter(lambda x: "(total: " in x and "Particles out:" in x, run_file_data)) if last_particles_out_lines: totalpartsout = int(last_particles_out_lines[-1].split("(total: ")[1].split(")")[0]) try: last_estimated_time = str(" ".join(last_part_lines[-1].split(None)[-2:])) except IndexError: last_estimated_time = None # Update run dialog run_dialog.run_update(current_value, totalpartsout, last_estimated_time) # Set filesystem watcher to the out directory. run_fs_watcher.addPath(Case.the().path + "/" + Case.the().name + "_out/") run_fs_watcher.directoryChanged.connect(on_fs_change) # Handle error on simulation start if process.state() == QtCore.QProcess.NotRunning: # Probably error happened. run_fs_watcher.removePath(Case.the().path + "/" + Case.the().name + "_out/") process = None error_dialog("Error on simulation start. Check that the DualSPHysics executable is correctly set.") else: run_dialog.show()
def __init__(self, case_name: str, processor: str, number_of_particles: int, cmd_string="", parent=None): super().__init__(parent=parent) self.run_watcher = QtCore.QFileSystemWatcher() self.cmd_string = cmd_string # Title and size self.setModal(False) self.setWindowTitle(__("DualSPHysics Simulation: {}%").format("0")) self.run_dialog_layout = QtGui.QVBoxLayout() # Information GroupBox self.run_group = QtGui.QGroupBox(__("Simulation Data")) self.run_group_layout = QtGui.QVBoxLayout() self.run_group_label_case = QtGui.QLabel( __("Case name: {}").format(case_name)) self.run_group_label_proc = QtGui.QLabel( __("Simulation processor: {}").format(processor)) self.run_group_label_part = QtGui.QLabel( __("Number of particles: {}").format(number_of_particles)) self.run_group_label_partsout = QtGui.QLabel( self.PARTICLES_OUT_TEMPLATE.format(0)) self.run_group_label_eta = QtGui.QLabel(self) self.run_group_label_eta.setText( self.ETA_TEMPLATE.format("Calculating...")) self.run_group_label_completed = QtGui.QLabel("<b>{}</b>".format( __("Simulation is complete."))) self.run_group_label_completed.setVisible(False) self.run_group_layout.addWidget(self.run_group_label_case) self.run_group_layout.addWidget(self.run_group_label_proc) self.run_group_layout.addWidget(self.run_group_label_part) self.run_group_layout.addWidget(self.run_group_label_partsout) self.run_group_layout.addWidget(self.run_group_label_eta) self.run_group_layout.addWidget(self.run_group_label_completed) self.run_group_layout.addStretch(1) self.run_group.setLayout(self.run_group_layout) # Progress Bar self.run_progbar_layout = QtGui.QHBoxLayout() self.run_progbar_bar = QtGui.QProgressBar() self.run_progbar_bar.setRange(0, 100) self.run_progbar_bar.setTextVisible(False) self.run_progbar_layout.addWidget(self.run_progbar_bar) # Buttons self.run_button_layout = QtGui.QHBoxLayout() self.run_button_warnings = QtGui.QPushButton(__("Show Warnings")) self.run_button_warnings.hide() self.run_button_details = QtGui.QPushButton(__("Details")) self.run_button_cancel = QtGui.QPushButton(__("Cancel Simulation")) self.run_button_layout.addWidget(self.run_button_warnings) self.run_button_layout.addStretch(1) self.run_button_layout.addWidget(self.run_button_details) self.run_button_layout.addWidget(self.run_button_cancel) # Defines run details self.run_details = QtGui.QWidget() self.run_details.setWindowTitle(__("Simulation details")) self.run_details_layout = QtGui.QVBoxLayout() self.run_details_layout.setContentsMargins(0, 0, 0, 0) self.run_details_text = QtGui.QTextEdit() self.run_details_text.setReadOnly(True) self.run_details_layout.addWidget(h_line_generator()) self.run_details_layout.addWidget(self.run_details_text) self.run_details.hide() self.run_button_cancel.clicked.connect(self.cancelled.emit) self.run_button_details.clicked.connect(self.toggle_run_details) self.run_details.setLayout(self.run_details_layout) self.run_dialog_layout.addWidget(self.run_group) self.run_dialog_layout.addLayout(self.run_progbar_layout) self.run_dialog_layout.addLayout(self.run_button_layout) self.run_dialog_layout.addWidget(self.run_details) self.setLayout(self.run_dialog_layout) self.setMinimumWidth(self.MIN_WIDTH) self.adjustSize()
def __init__(self, path, parent=None): QtCore.QObject.__init__(self, parent) self.m_fPath = path self.m_fsWatcher = QtCore.QFileSystemWatcher() self.m_fsWatcher.addPath(path) self.m_fsWatcher.fileChanged.connect(self.onFileChange)
main_groupbox.setLayout(gp_layout) main_layout.addWidget(main_groupbox) w.setLayout(main_layout) w.show() # endregion Main window definition # region Sebastian fullscreen window sebastian_window = QtGui.QDialog() main_layout = QtGui.QHBoxLayout() main_layout.setContentsMargins(0, 0, 0, 0) _web_view = QtWebKit.QWebView() _web_view.load(QtCore.QUrl("")) _web_view.page().mainFrame().setScrollBarPolicy( QtCore.Qt.Orientation.Vertical, QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff) filewatcher = QtCore.QFileSystemWatcher() filewatcher.fileChanged.connect(on_file_change) main_layout.addWidget(_web_view) sebastian_window.setWindowState(QtCore.Qt.WindowFullScreen) sebastian_window.setLayout(main_layout) # endregion Sebastian fullscreen window # region About window about_window = QtGui.QDialog() about_window.setFixedSize(420, 180) about_window.setWindowFlags(QtCore.Qt.Dialog) about_window.setWindowTitle('About Sebastian') about_window_layout = QtGui.QVBoxLayout() name_label = QtGui.QLabel("Software Name: Sebastian") version_label = QtGui.QLabel("Software Version: " + __version__) credits_label = QtGui.QLabel("Software Credits: " + ", ".join(__credits__))