def __init__(self):
"""The constructor, which calls the super-class-contructor (Extension).
Loads and sets all settings from settings file.
Adds .blend as a supported file extension.
Adds (stl, obj, x3d, ply) as supported file extensions for conversion.
Adds menu items and the filewatcher trigger function.
"""
global fs_watcher
super().__init__()
# Loads and sets all settings from settings file.
self.loadAndSetSettings()
self._supported_extensions = ['.blend']
self._supported_foreign_extensions = ['stl', 'obj', 'x3d', 'ply']
# Adds filewatcher and it's connection for blender files.
fs_watcher = QFileSystemWatcher()
fs_watcher.fileChanged.connect(self._fileChanged)
# Adds filewatcher and it's connection for foreign files.
self._foreign_file_watcher = QFileSystemWatcher()
self._foreign_file_watcher.fileChanged.connect(
self._foreignFileChanged)
# Builds the extension menu.
self.setMenuName(catalog.i18nc('@item:inmenu', 'CuraBlender'))
self.addMenuItem(catalog.i18nc('@item:inmenu', 'Open in Blender'),
self._setUpFilePathForBlender)
self.addMenuItem(catalog.i18nc('@item:inmenu', 'Settings'),
self._openSettingsWindow)
self.addMenuItem(catalog.i18nc('@item:inmenu', 'Debug Blenderpath'),
self._showBlenderPath)
def on_pb_SearchDir( self ):
''' Called when the user presses the Browse button
'''
logging.debug( "Browse button pressed" )
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
directoryName = QtWidgets.QFileDialog.getExistingDirectory(
None,
"Select Output Folder",
"",
options=options)
if directoryName:
logging.debug( "setting directory name: " + directoryName )
self.model.setDirectoryName( directoryName )
self.refreshDir()
if self.changeDetection == True:
self._pathToWatch = directoryName
self._fileSysWatcher = QFileSystemWatcher()
self._initialContent = os.listdir(self._pathToWatch)
for f in self._initialContent:
if (f != "trace.log"):
self._fileSysWatcher.addPath(f)
self._fileSysWatcher.fileChanged.connect(self.slotDirChanged)
self._fileSysWatcher.directoryChanged.connect(self.slotDirChanged)
def __init__(self):
"""Loads the UI-file and sets up the GUI."""
super(AutocutView, self).__init__()
uic.loadUi(Resources.files.autocut_view, self)
self.setWindowFlags(Qt.WindowCloseButtonHint
| Qt.WindowMinimizeButtonHint)
self.setFixedSize(self.size())
self.init_stylesheet()
"QSS HOT RELOAD"
self.__qss_watcher = QFileSystemWatcher()
self.__qss_watcher.addPath(Resources.files.qss_dark)
self.__qss_watcher.fileChanged.connect(self.update_qss)
# centering the window
rectangle = self.frameGeometry()
center_point = QDesktopWidget().availableGeometry().center()
rectangle.moveCenter(center_point)
self.move(rectangle.topLeft())
cross_path = Resources.images.cross
tick_path = Resources.images.tick
self.cross = QPixmap(cross_path).scaledToHeight(50, mode=1)
self.tick = QPixmap(tick_path).scaledToHeight(50, mode=1)
self.video_image_label.setPixmap(self.cross)
self.pdf_image_label.setPixmap(self.cross)
def __init__(self, parent=None):
super().__init__(parent)
self.mWatchCount = QMap()
self.mWatcher = QFileSystemWatcher(self)
self.mWatcher.fileChanged.connect(self.onFileChanged)
self.mWatcher.directoryChanged.connect(self.onDirectoryChanged)
def __init__(self, path, notebook):
"""
Class representing the actual tab pane for a plain .txt note file, including the editor,
the toolbar and the save/load logic.
path is the path to the file(which does not need to exist yet)
notebook must be the Notebook instance the note will be a part of
"""
QWidget.__init__(self)
self.notebook = notebook
self.path = path
#Set up the embedded webkit
self.edit = QTextEdit()
#set up the toolbar
self.tools = QWidget()
self.tools.lo = QHBoxLayout()
self.tools.setLayout(self.tools.lo)
if self.path:
#Watch the file so we can auto reload
self.watcher = QFileSystemWatcher()
self.watcher.addPath(self.path)
self.watcher.fileChanged.connect(self.reload)
#Put the widgets together
self.lo = QVBoxLayout()
self.setLayout(self.lo)
self.tools = NoteToolBar(self, richtext=False)
self.lo.addWidget(self.tools)
self.lo.addWidget(self.edit)
self.reload()
def test_killed_command(qtbot, tmpdir, py_proc, runner):
text_file = tmpdir / 'text'
text_file.write('This is text')
pidfile = tmpdir / 'pid'
watcher = QFileSystemWatcher()
watcher.addPath(str(tmpdir))
env = {'QUTE_TEXT': str(text_file)}
cmd, args = py_proc(r"""
import os
import time
import sys
# We can't use QUTE_FIFO to transmit the PID because that wouldn't work
# on Windows, where QUTE_FIFO is only monitored after the script has
# exited.
with open(sys.argv[1], 'w') as f:
f.write(str(os.getpid()))
time.sleep(30)
""")
args.append(str(pidfile))
with qtbot.waitSignal(watcher.directoryChanged, timeout=10000):
runner.run(cmd, *args, env=env)
# Make sure the PID was written to the file, not just the file created
time.sleep(0.5)
with qtbot.waitSignal(runner.finished):
os.kill(int(pidfile.read()), signal.SIGTERM)
assert not text_file.exists()
def __init__(self, parent=None):
QtWidgets.QSystemTrayIcon.__init__(self, parent)
self.title = 'Time Synchronisation Monitor'
self.right_click_menu = RightClickMenu()
self.setContextMenu(self.right_click_menu)
self.path = '/var/run/sdwdate'
self.status_path = '/var/run/sdwdate/status'
self.show_message_path = '/usr/lib/sdwdate-gui/show_message'
self.popup_process = None
self.update = Update(self)
self.update.update_tip.connect(self.update_tip)
self.activated.connect(self.mouse_event)
self.message_showing = False
self.clicked_once = False
self.pos_x = 0
self.pos_y = 0
self.message = ''
self.previous_message = ''
self.stripped_message = ''
self.setIcon(QtGui.QIcon('/usr/share/icons/sdwdate-gui/620px-Ambox_outdated.svg.png'))
startup_msg = 'sdwdate will probably start in a few moments.'
self.message = startup_msg
self.setToolTip(startup_msg)
self.status_changed()
self.watcher_file = QFileSystemWatcher([self.status_path])
self.watcher_file.fileChanged.connect(self.status_changed)
def __init__(self,ebeveyn=None):
super(Gonderici,self).__init__(ebeveyn)
kutu = QVBoxLayout()
self.ebeveyn = ebeveyn
self.setLayout(kutu)
kutu.setContentsMargins(5,5,5,5)
self.mesaj_liste = QListWidget()
self.mesaj_liste.setSelectionMode(QListView.ExtendedSelection)
kutu.addWidget(self.mesaj_liste)
self.tum_mesajlar_fonk()
self.dosya_izleyici = QFileSystemWatcher()
self.dosya_izleyici.addPath(self.MESAJ_DIZINI)
self.dosya_izleyici.directoryChanged.connect(self.tum_mesajlar_fonk)
kutu_h = QHBoxLayout()
kutu_h.addWidget(QLabel("<b>Mesaj Tipi :</b>"))
self.mesaj_tipi_text = QComboBox()
self.mesaj_tipi_text.addItems(["------","bilgi","sistem","kritik",])
kutu_h.addWidget(self.mesaj_tipi_text)
kutu.addLayout(kutu_h)
kutu_h = QHBoxLayout()
# kutu_h.addWidget(QLabel("<b>Mesaj :</b>"))
self.gonderilen_text = QTextEdit()
self.gonderilen_text.setFixedHeight(100)
kutu_h.addWidget(self.gonderilen_text)
self.gonder_dugme = QPushButton("Gönder")
self.gonder_dugme.setFixedHeight(100)
self.gonder_dugme.clicked.connect(self.gonder_fonk)
kutu_h.addWidget(self.gonder_dugme)
kutu.addLayout(kutu_h)
def run_masscan(self):
self.process = QProcess(self)
response = IpAsnRangeDoc().search().query('match', owner='amazon.com').execute()
tmp_file = '/tmp/masscan_in.tmp'
with open(tmp_file, 'a') as f:
for iprange_doc in response:
for range in iprange_doc.ranges:
debug('scan cidr %s' % range.cidr)
f.write('%s\n' % range.cidr)
params = ['--output-format', 'json', '--output-filename', '/tmp/masscan_out.tmp', '--source-port', '60000',
'-p%s' % ''.join(str(self.scan_ports)[1:-1]),'--rate', '%s' % self.spinBox.value(), '-iL',
'/tmp/masscan_in.tmp']
debug('masscan params' % params)
self.process.start('masscan', params)
self.startScanButton.setEnabled(False)
self.startScanButton.setText('starting..')
self.process.waitForStarted(1)
self.startScanButton.setText('stop scan')
self.startScanButton.setEnabled(True)
self.spinBox.setEnabled(False)
watch = QFileSystemWatcher(self)
watch.addPath('/tmp/masscan_out.tmp')
watch.fileChanged.connect(functools.partial(self.data_available))
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.readyReadStandardError.connect(functools.partial(self.stderrReady))
self.process.stateChanged.connect(functools.partial(self.process_state_change))
def __init__(self):
super().__init__()
self._watcher = QFileSystemWatcher(self)
self._watcher.directoryChanged.connect(self.onChanged)
self._watcher.fileChanged.connect(self.onChanged)
self._events = {}
def start_watcher(self, watcher=None):
self._files = set(self._glob_files())
self._watcher = watcher or QFileSystemWatcher()
self._watcher.addPath(str(self._book.path))
self._watcher.directory_changed.connect(self._on_directory_change)
def load_file(self, fname, check_for_changes=True):
"""
load a file's content into the application.
Parameters
----------
fname : str
full file path and name of the file to load
check_for_changes : bool
flag to check for save prompt if file has unsaved changes
Returns
-------
None
"""
if check_for_changes:
changed = self.check_for_changes()
if changed == "Cancel":
return changed
self.file_watcher = QFileSystemWatcher([fname])
self.file_watcher.fileChanged.connect(self.file_updated)
self.last_updated = time.time()
self.clear_validation()
# check that we have read write access to the file
file = QFile(fname)
if not file.open(QFile.ReadOnly | QFile.Text):
msg = "Cannot read file %s:\n%s." % (fname, file.errorString())
QMessageBox.warning(self, "Recent Files", msg)
return
file.close()
self.load_file_content(fname)
def build_menu(self):
menubar = self.menuBar()
menubar.setNativeMenuBar(False)
bar = self.menuBar()
# File Menu
fileMenu = bar.addMenu('&File')
savePresetAction = QAction('Save Current State', self)
savePresetAction.triggered.connect(self.open_save_dialog)
fileMenu.addAction(savePresetAction)
openSimAction = QAction('Open Simulation', self)
openSimAction.triggered.connect(self.open_sim_dialog)
fileMenu.addAction(openSimAction)
makeAMovieAction = QAction('Make a Movie', self)
makeAMovieAction.triggered.connect(self.open_movie_dialog)
fileMenu.addAction(makeAMovieAction)
exitAct = QAction(' &Quit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.triggered.connect(qApp.quit)
fileMenu.addAction(exitAct)
self.views_menu = bar.addMenu("Preset Views")
self.views_update()
self.view_dir_watcher = QFileSystemWatcher()
self.view_dir_watcher.addPath(
os.path.join(self.IseultDir, '.iseult_configs'))
self.view_dir_watcher.directoryChanged.connect(self.views_update)
def __init__(self, gtomain, parent=None):
try:
super(gtoRemote, self).__init__(parent)
self.gtomain = gtomain
self.iface = gtomain.iface
self.debug = gtomain.debug
self.info = gtoInfo(self)
self.fs_watcher = None
if 'remote_watch_file' in gtomain.settings:
remote_watch_path = gtomain.settings.get(
'remote_watch_file', None)
if remote_watch_path is not None and remote_watch_path != "":
remote_watch_path = self.gtomain.helper.getFilePath(
remote_watch_path)
self.remote_watch_file = os.path.basename(
remote_watch_path)
self.remote_watch_dir = os.path.dirname(remote_watch_path)
if self.debug:
self.info.log("Watching:", self.remote_watch_dir)
if not os.path.exists(self.remote_watch_dir):
os.makedirs(self.remote_watch_dir)
if self.debug:
self.info.log("Created:", self.remote_watch_dir)
self.paths = [self.remote_watch_dir]
self.fs_watcher = QFileSystemWatcher(self.paths)
#if file already exists
self.directory_changed(self.paths[0])
self.fs_watcher.directoryChanged.connect(
self.directory_changed)
self.fs_watcher.fileChanged.connect(self.file_changed)
except Exception as e:
self.info.err(e)
def __init__(self, parent=None, watch=False):
super().__init__(parent)
self._filename = None
self._proc = None
self._remove_file = None
self._watcher = QFileSystemWatcher(parent=self) if watch else None
self._content = None
def __init__(self, parent=None):
super(Editor, self).__init__(parent)
ComponentMixin.__init__(self)
self._filename = ''
self.setup_editor(linenumbers=True,
markers=True,
edge_line=False,
tab_mode=False,
show_blanks=True,
language='Python')
self._actions = \
{'File' : [QAction(icon('new'),
'New',
self,
shortcut='ctrl+N',
triggered=self.new),
QAction(icon('open'),
'Open',
self,
shortcut='ctrl+O',
triggered=self.open),
QAction(icon('save'),
'Save',
self,
shortcut='ctrl+S',
triggered=self.save),
QAction(icon('save_as'),
'Save as',
self,
shortcut='ctrl+shift+S',
triggered=self.save_as),
QAction(icon('autoreload'),
'Automatic reload and preview',
self,triggered=self.autoreload,
checkable=True,
checked=False,
objectName='autoreload'),
]}
for a in self._actions.values():
self.addActions(a)
self._fixContextMenu()
self.updatePreferences()
# autoreload support
self._file_watcher = QFileSystemWatcher(self)
self._watched_file = None
# we wait for 50ms after a file change for the file to be written completely
self._file_watch_timer = QTimer(self)
self._file_watch_timer.setInterval(50)
self._file_watch_timer.setSingleShot(True)
self._file_watcher.fileChanged.connect(
lambda val: self._file_watch_timer.start())
self._file_watch_timer.timeout.connect(self._file_changed)
def _get_watcher(self):
# Instantiate QFileSystemWatcher as late as possible. It requires a
# QApplication which isn't available in some tests.
if self._watcher is None:
self._watcher = QFileSystemWatcher()
self._watcher.directoryChanged.connect(self._on_file_changed)
self._watcher.fileChanged.connect(self._on_file_changed)
return self._watcher
def __init__(self, csspath):
self.path = csspath
#Watch the file so we can auto reload
self.csswatcher = QFileSystemWatcher()
self.csswatcher.addPath(csspath)
self.csswatcher.fileChanged.connect(self.rlcss)
print("Watching " + self.path)
def __init__(self, directory, parent=None):
super().__init__(parent)
self._pidfile = directory / 'editor_pid'
self._watcher = QFileSystemWatcher(self)
self._watcher.addPath(str(directory))
self._watcher.directoryChanged.connect(self._check_update)
self.has_pidfile = False
self._check_update()
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数，创建窗体
self.ui = Ui_MainWindow() #创建UI对象
self.ui.setupUi(self) #构造UI界面
self.ui.toolBox.setCurrentIndex(0)
self.fileWatcher = QFileSystemWatcher()
self.fileWatcher.directoryChanged.connect(self.do_directoryChanged)
self.fileWatcher.fileChanged.connect(self.do_fileChanged)
def start_watching(self):
"""Create a file system watcher and connect its fileChanged
SIGNAL to our _file_changed SLOT"""
if not self.__watcher:
self.__watcher = QFileSystemWatcher(self)
self.__watcher.fileChanged['const QString&'].connect(self._file_changed)
if self._file_path is not None:
self.__mtime = os.path.getmtime(self._file_path)
self.__watcher.addPath(self._file_path)
def setup_editor(self):
self.rom_stream = tempfile.SpooledTemporaryFile(
max_size=self.TEMP_MAX_RAM_USE, mode="w+")
self.rom_path = None
self.lst_parser = None
self.rom_watcher = QFileSystemWatcher()
self.rom_watcher.fileChanged.connect(self.reload_rom)
self.spinBox.setValue(500)
self.on_new()
def __init__(self,
fname=None,
data=None,
comment='#',
skiprows=0,
delimiter=' ',
expressions={},
autoupdate=False,
parent=None,
matplotlib=False,
plotIndex=None,
colors=None):
QDialog.__init__(self, parent=parent)
loadUi('UI_Forms/Data_Dialog.ui', self)
self.colcycler = cycle(['r', 'g', 'b', 'c', 'm', 'y', 'w'])
self.plotWidget = PlotWidget(parent=self, matplotlib=matplotlib)
self.plotTab = self.tabWidget.addTab(self.plotWidget, 'Plots')
self.tabWidget.setCurrentIndex(0)
self.show()
self.fileWatcher = QFileSystemWatcher()
self.fileWatcher.fileChanged.connect(self.fileUpdated)
self.cwd = None
self.plotNum = 0
self.xlabel = []
self.ylabel = []
self.oldPlotIndex = {}
self.oldColors = {}
self.dataAltered = False
self.expressions = expressions
if data is not None:
self.data = data
self.autoUpdateCheckBox.setEnabled(False)
elif fname is not None:
self.data = self.readData(fname,
comment=comment,
skiprows=skiprows,
delimiter=delimiter)
else:
self.data = None
self.autoUpdateCheckBox.setEnabled(False)
self.saveDataPushButton.setEnabled(False)
self.addRowPushButton.setEnabled(False)
self.removeRowsPushButton.setEnabled(False)
self.removeColumnPushButton.setEnabled(False)
if self.data is not None:
self.setMeta2Table()
self.setData2Table()
if plotIndex is None:
self.addPlots(color=None)
else:
self.addMultiPlots(plotIndex=plotIndex, colors=colors)
self.init_signals()
self.okPushButton.setAutoDefault(False)
self.make_default()
self.setWindowTitle('Data Dialog')
self.acceptData = True
def watcher(self) -> QFileSystemWatcher:
"""The QFileSystemWatcher to monitor marked paths.
This is required as during __init__ the QApplication is not created yet.
"""
if self._watcher is None:
_logger.debug("Creating watcher to monitor marked paths")
self._watcher = QFileSystemWatcher()
self._watcher.fileChanged.connect(self._on_file_changed) # type: ignore
return self._watcher
def __init__(self):
"""The constructor, which calls the super-class-contructor (MeshWriter).
Adds a filewatcher to replace the saved file from the writer job by our own generated file.
"""
super().__init__(add_to_recent_files = False)
self._write_watcher = QFileSystemWatcher()
self._write_watcher.fileChanged.connect(self._writeChanged)
def start(self):
# if the file does not exist
# create it then watch it
if not os.path.exists(self.fnam):
with open(self.fnam, 'w') as f:
pass
# watch file
self.w = QFileSystemWatcher([self.fnam])
self.w.fileChanged.connect(self.fileChanged)
def __init__(self, path, max_age):
QThread.__init__(self)
self.path = path
self.max_age = max_age
self.files = {}
self.file_reg = re.compile('(.+)_\d{8}_\d{6}' + re.escape(os.path.extsep) + 'txt$', re.IGNORECASE)
self.qtfw = QFileSystemWatcher()
self.qtfw.directoryChanged.connect(self.directory_changed)
self.qtfw.addPath(path)
self.update_watched_files(path)
def live_generate(opt, model=None):
import signal
from PyQt5.QtCore import QFileSystemWatcher
from PyQt5.QtCore import QCoreApplication, QTimer
app = QCoreApplication([])
out_dir = opt.output
shape = (opt.loadSize, opt.loadSize)
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
opt.label_nc = 0
opt.no_instance = True
opt.replace = True
model = create_model(opt)
def on_file_changed(path):
print(f"file {path} changed")
if path not in watcher.files():
if os.path.exists(path):
print("new file(s). adding to watch")
if os.path.isdir(path):
paths = get_images(path)
else:
paths = [path]
watcher.addPaths(paths)
opt.image = path
do_generate(opt, model)
imgs = []
if os.path.isdir(opt.image):
imgs = get_images(opt.image)
watcher = QFileSystemWatcher([opt.image, *imgs])
watcher.directoryChanged.connect(on_file_changed)
watcher.fileChanged.connect(on_file_changed)
timer = QTimer()
timer.start(500) # You may change this if you wish.
timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms.
def sigint_handler(*args):
QCoreApplication.quit()
signal.signal(signal.SIGTERM, sigint_handler)
app.exec_()
def __init__(self):
super(SubFolderWatcher, self).__init__()
self.base_path = ''
self.subfolder = ''
self.files = {}
self.finished_checking = False
self.watcher = QFileSystemWatcher()
self.timer = QTimer()
self.check_threshold = 3
self.check_number = 0
self.sub_folder = ''
def __init__(self, eq_directory):
super().__init__()
self._files = glob(os.path.join(eq_directory, 'eqlog*.txt'))
self._watcher = QFileSystemWatcher(self._files)
self._watcher.fileChanged.connect(self._file_changed)
self._stats = {
'log_file': '',
'last_read': 0,
}
