def apply_stylesheet(style: str):
from qtpy.QtCore import QDir
d = QDir()
d.setSearchPaths('icon',
[os.path.abspath('../resources/stylesheets/icons')])
from WindowTheme import WindowTheme_Dark, WindowTheme_Light
if style == 'dark':
window_theme = WindowTheme_Dark()
else:
window_theme = WindowTheme_Light()
f = open('../resources/stylesheets/style_template.css')
from jinja2 import Template
jinja_template = Template(f.read())
f.close()
app = QApplication.instance()
app.setStyleSheet(jinja_template.render(window_theme.rules))
return window_theme
def __init__(self):
super(MainWindowBase, self).__init__()
# Environment path
self.env = ""
# Alignment mode
self.alignment_mode = 0
# Entities list
self.vpoint_list = []
self.vlink_list = [VLink(VLink.FRAME, 'White', (), color_rgb)]
# Condition list of context menus
self.context = _Context()
# Preference
self.prefer = Preferences()
# Set path from command line
home_dir = QDir.home()
self.settings = QSettings(home_dir.absoluteFilePath(".pyslvs.ini"),
QSettings.IniFormat, self)
if ARGUMENTS.c:
self.set_locate(QDir(ARGUMENTS.c).absolutePath())
else:
home_dir.cd("Desktop")
env = self.settings.value("ENV", home_dir.absolutePath())
self.set_locate(str(env))
# Initialize custom UI
self.__undo_redo()
self.__appearance()
self.__alignment()
self.__free_move()
self.__options()
self.__context_menu()
def rename(self):
"""renames the selected file or folder"""
index = self.selectionModel().currentIndex()
path = self.model.filePath(index)
if path:
file_info = QFileInfo(path)
if file_info.isFile():
filename = self.rename_dialog("file")
if filename:
q_file = QFile(path)
file_info.absolutePath()
new_path = os.path.join(file_info.absolutePath(),
str(filename))
q_file.rename(new_path)
elif file_info.isDir():
filename = self.rename_dialog("directory")
if filename:
directory = QDir(path)
file_info.absolutePath()
new_path = os.path.join(file_info.absolutePath(),
str(filename))
directory.rename(path, new_path)
def get_path_list(self):
"""Get path of files including subdiretorys."""
if self.folder is None or not osp.isdir(self.folder):
self.edit.setPlaceholderText("The project is not valid.")
else:
dir_ = QDir(self.folder)
it = QDirIterator(
self.folder, ['*.py', '*.txt', '*.md'],
QDir.Files | QDir.NoDotAndDotDot | QDir.NoSymLinks,
QDirIterator.Subdirectories)
while it.hasNext():
self.path_list.append(dir_.relativeFilePath(it.next()))
self.results_old[''] = self.path_list
def setRootPath(self, path):
if os.path.isdir(path):
filter = "*"
root = path
else:
filter = os.path.basename(path)
root = path[:-len(filter)]
root = QDir(root)
super(LocalFileSystemResourcePlugin,
self).setRootPath(root.absolutePath())
self.setNameFilters([filter])
self.uri = parse.urlparse(path)
QSettings().setValue("lastlocaldir", path)
def do(self, dir_str: QDir) -> bool:
"""Output types:
+ Boundary
+ Frame
"""
file_name = dir_str.filePath(_get_name(self.filename_edit) + '.dxf')
if isfile(file_name) and self.warn_radio.isChecked():
self.exist_warning(file_name)
return False
version = self.version_option.currentText().split()[0]
if self.frame_radio.isChecked():
# Frame
dxf_frame(
self.vpoints,
self.v_to_slvs,
version,
file_name
)
elif self.assembly_radio.isChecked():
# Boundary
dxf_boundary(
self.vpoints,
self.link_radius.value(),
self.interval_option.value()
if self.interval_enable.isChecked() else 0.,
version,
file_name
)
return True
def __accepted(self) -> None:
"""Use the file path to export the project."""
qdir = QDir(_get_name(self.path_edit, ispath=True))
if self.newfolder_option.isChecked():
new_folder = self.filename_edit.placeholderText()
if (not qdir.mkdir(new_folder)) and self.warn_radio.isChecked():
self.exist_warning(new_folder, folder=True)
return
qdir.cd(new_folder)
try:
ok = self.do(qdir)
except PermissionError as error:
QMessageBox.warning(self, "Permission error", str(error))
else:
if ok:
self.accept()
def deleteItem(self):
"""Delete the selected item (either a file or folder)."""
# ToDo: use Move2Trash, instead of deleting the file
index = self.selectionModel().currentIndex()
path = self.model.filePath(index)
if path:
file_info = QFileInfo(path)
if file_info.isFile():
if not self.ask_dialog("Do you wan't to delete the selected file?"):
return
q_file = QFile(path)
q_file.remove()
elif file_info.isDir():
if not self.ask_dialog("Do you wan't to delete the selected directory?"):
return
directory = QDir(path)
directory.removeRecursively()
def handle_capture(window, capture):
file_format = 'png'
initial_path = os.path.join(QDir.currentPath(),
capture.style_name + '.' + str(file_format))
filter = '%s Files (*.%s);;All Files (*)' % (str(file_format).upper(),
file_format)
file_name, _ = QFileDialog.getSaveFileName(window, 'Save As', initial_path,
filter)
if file_name:
capture.image.save(file_name, str(file_format))
def do(self, dir_str: QDir) -> bool:
"""Output types:
+ Assembly
+ Only wire frame
"""
file_name = dir_str.filePath(_get_name(self.filename_edit) + '.slvs')
if isfile(file_name) and self.warn_radio.isChecked():
self.exist_warning(file_name)
return False
# Wire frame
slvs2_frame(self.vpoints, self.v_to_slvs, file_name)
# Open Solvespace by commend line if available.
cmd = shutil.which("solvespace")
if cmd:
Popen([cmd, file_name], stdout=DEVNULL, stderr=DEVNULL)
if self.frame_radio.isChecked():
self.accept()
return False
# Assembly
vlinks: Dict[str, Set[int]] = {}
for i, vpoint in enumerate(self.vpoints):
for link in vpoint.links:
if link in vlinks:
vlinks[link].add(i)
else:
vlinks[link] = {i}
for name, points in vlinks.items():
if name == VLink.FRAME:
continue
file_name = dir_str.filePath(name + '.slvs')
if isfile(file_name) and self.warn_radio.isChecked():
self.exist_warning(file_name)
return False
slvs2_part([
self.vpoints[i] for i in points
], self.link_radius.value(), file_name)
return True
def load(self, file_name=None):
if file_name is None:
file_name, _ = QFileDialog.getOpenFileName(
None, "Open Flow Scene", QDir.homePath(),
"Flow Scene Files (*.flow)")
if not os.path.exists(file_name):
return
with open(file_name, 'rt') as f:
doc = json.load(f)
self.__setstate__(doc)
def save(self, file_name=None):
if file_name is None:
file_name, _ = QFileDialog.getSaveFileName(
None, "Save Flow Scene", QDir.homePath(),
"Flow Scene Files (*.flow)")
if file_name:
file_name = str(file_name)
if not file_name.endswith(".flow"):
file_name += ".flow"
with open(file_name, 'wt') as f:
json.dump(self.__getstate__(), f)
def _update_files(self):
file_list = []
root = QDir.toNativeSeparators(self._project_path.toLocalFile())
for subdir, dirs, files in os.walk(root):
for f in files:
path = os.path.join(root, subdir, f)
_, ext = os.path.splitext(path)
if ext[1:].lower() in self._extensions:
# convert file separators to consistent style
url = QUrl.fromLocalFile(path).toLocalFile()
if not url.startswith('/'):
url = '/' + url
file_list.append(url)
self._qml_files = file_list
self.qmlFilesChanged.emit()
def showSelectProjectDialog(parent: QWidget = None) -> Optional[Path]:
dialog = QFileDialog(parent, Qt.Dialog)
dialog.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.Dialog)
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setLabelText(QFileDialog.LookIn, "Select project folder")
dialog.setFileMode(QFileDialog.Directory)
dialog.setOption(QFileDialog.ShowDirsOnly, True)
dialog.setViewMode(QFileDialog.Detail)
dialog.setDirectory(QDir.homePath())
if dialog.exec_():
paths = dialog.selectedFiles()
assert len(paths) == 1
path = Path(paths[0])
return path
def _dialog_export_element(self, _id: int) -> None:
element = self.viewer.get_drawable(_id).element
proposed_path = QDir(self.last_dir).filePath(element.name)
# TODO Check hints by element type
filters = 'BlastSight Mesh (*.h5m);;'\
'BlastSight Blocks/Points (*.h5p);;'
(path, selected_filter) = QFileDialog.getSaveFileName(
parent=self,
directory=proposed_path,
filter=filters)
# Execute method
if bool(path):
self.statusBar.showMessage('Exporting...')
self._thread_runner(self.viewer.export_element, path, _id)
def openFile(self):
#called when user clicks on Open or presses ctrl+o
#opens filedialog and finds file
#if filename is not None try and openwith tifffile library and store in videoviewer property 'frames'
#currently only .ome.tif image stacks are supported.
fileName, _ = QFileDialog.getOpenFileName(
self, "Choose Video or Image Stack", QDir.homePath())
if self.model is None:
self.model = QTiffStackModel()
self.model.addFrames(fileName)
if self.model.frames is not None:
self.videoviewer.updateRanges(self.model.videolength - 1)
def newFolder(self):
path = self.model.filePath(self.rootIndex())
new_name = 'New Folder'
count = 1
while os.path.exists(os.path.join(path, new_name)):
new_name = "New Folder {}".format(count)
count += 1
directory = QDir(path)
directory.mkpath(new_name)
directory.setPath(new_name)
def openFile(self):
#called when user clicks on Open or presses ctrl+o
#opens filedialog and finds file
#if filename is not None try and openwith tifffile library and store in videoviewer property 'frames'
#currently only .ome.tif image stacks are supported.
fileName, _ = QFileDialog.getOpenFileName(self,"Choose Video or Image Stack",QDir.homePath())
if fileName != '' and fileName[-4:] == '.tif':
with tf.TiffFile(fileName) as tif:
frames = tif.asarray()
if self.model is None:
self.model = QTiffStackModel(frames)
else:
self.model.addFrames(frames)
def main() -> None:
"""Startup function."""
global _app
t0 = process_time()
from qtpy.QtCore import Qt, QDir, QLockFile
from qtpy.QtWidgets import QApplication, QSplashScreen
from qtpy.QtGui import QPixmap
from .info import ARGUMENTS, logger
if ARGUMENTS.test:
from importlib import import_module
import_module('pyslvs_ui.main_window')
logger.info("All module loaded successfully.")
logger.info(f"Loaded with: {process_time() - t0:.02f}s")
shutdown()
exit(0)
_app = QApplication(argv)
lf = QLockFile(join(QDir.tempPath(), "pyslvs.lock"))
if not lf.tryLock(100):
logger.info("Pyslvs can only start one instance.")
shutdown()
exit(0)
sp = QSplashScreen(QPixmap(":/icons/splash.png"))
sp.showMessage(f"{__author__} {__copyright__}",
Qt.AlignBottom | Qt.AlignRight)
sp.show()
# Force enable fusion style on macOS
if system() == 'Darwin':
ARGUMENTS.fusion = True
if ARGUMENTS.fusion:
_app.setStyle('fusion')
from .main_window import MainWindow
sp.finish(MainWindow.new())
sp.deleteLater()
del sp
logger.info(f"Startup with: {process_time() - t0:.02f}s")
qt_exit_code = _app.exec_()
del lf
shutdown()
exit(qt_exit_code)
def createExportFileNameMask(self, keyword, current_case, report_step,
path):
impl_type = None
if self.__export_keyword_model.isFieldKw(keyword):
impl_type = self.__export_keyword_model.getImplementationType(
keyword)
elif self.__export_keyword_model.isGenDataKw(keyword):
impl_type = "Gen_Data"
elif self.__export_keyword_model.isGenKw(keyword):
impl_type = "Gen_Kw"
elif self.__export_keyword_model.isGenParamKw(keyword):
impl_type = "Gen_Param"
path = os.path.join(str(path), str(current_case), str(impl_type),
str(keyword))
if self.__export_keyword_model.isGenDataKw(keyword):
path = path + "_" + str(report_step)
if not QDir(path).exists():
os.makedirs(path)
return path
def create_file_system_tree_dock_widget(view_menu: QMenu) -> DockWidget:
'''
Create file system tree dock widget
Parameters
----------
view_menu : QMenu
Returns
-------
value : DockWidget
'''
widget = QTreeView()
widget.setFrameShape(QFrame.NoFrame)
m = QFileSystemModel(widget)
m.setRootPath(QDir.currentPath())
widget.setModel(m)
_State.file_system_count += 1
dock_widget = DockWidget("Filesystem {}".format(_State.file_system_count))
dock_widget.set_widget(widget)
view_menu.addAction(dock_widget.toggle_view_action())
return dock_widget
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setMinimumWidth(500)
self.setMinimumHeight(200)
self._dynamic = False
self.setWindowTitle("Export data")
self.activateWindow()
layout = QFormLayout()
self._column_keys_input = QLineEdit()
self._column_keys_input.setMinimumWidth(250)
self._column_keys_input.setText("*")
layout.addRow("Columns to export:", self._column_keys_input)
self._time_index_input = QLineEdit()
self._time_index_input.setMinimumWidth(250)
self._time_index_input.setText("raw")
layout.addRow("Time index:", self._time_index_input)
file_name_button = QToolButton()
file_name_button.setText("Browse")
file_name_button.clicked.connect(self.selectFileDirectory)
self._defaultPath = QDir.currentPath() + "/export.csv"
self._file_name = QLineEdit()
self._file_name.setEnabled(False)
self._file_name.setText(self._defaultPath)
self._file_name.setMinimumWidth(250)
file_name_layout = QHBoxLayout()
file_name_layout.addWidget(self._file_name)
file_name_layout.addWidget(file_name_button)
layout.addRow("Select directory to save files to:", file_name_layout)
self.setLayout(layout)
def copyRecursively(self, src, tgt):
src_info = QFileInfo(src)
if src_info.isDir():
tgt_dir = QDir(tgt)
if not tgt_dir.mkdir(src_info.fileName()):
return False
src_dir = QDir(src)
fnames = src_dir.entryList(QDir.Files | QDir.Dirs
| QDir.NoDotAndDotDot | QDir.Hidden
| QDir.System)
for fname in fnames:
new_src = os.path.join(src, fname)
new_tgt = os.path.join(tgt, src_info.fileName())
if not self.copyRecursively(new_src, new_tgt):
return False
elif src_info.isFile():
fname = src_info.fileName()
if not QFile.copy(src, os.path.join(tgt, fname)):
return False
return True
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setMinimumWidth(500)
self.setMinimumHeight(200)
self._dynamic = False
self.setWindowTitle("Export data")
self.activateWindow()
layout = QFormLayout()
current_case = getCurrentCaseName()
self._case_model = AllCasesModel()
self._case_combo = QComboBox()
self._case_combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self._case_combo.setMinimumContentsLength(20)
self._case_combo.setModel(self._case_model)
self._case_combo.setCurrentIndex(self._case_model.indexOf(current_case))
layout.addRow("Select case:", self._case_combo)
self._export_keyword_model = ExportKeywordModel()
self._kw_model = self._export_keyword_model.getKeyWords()
self._keywords = QComboBox()
self._keywords.addItems(self._kw_model)
layout.addRow("Select keyword:", self._keywords)
self._active_realizations_model = ActiveRealizationsModel()
self._active_realizations_field = StringBox(self._active_realizations_model, "config/simulation/active_realizations")
self._active_realizations_field.setValidator(RangeStringArgument())
self._active_realizations_field.getValidationSupport().validationChanged.connect(self.validateExportDialog)
layout.addRow("Active realizations:", self._active_realizations_field)
file_name_button = QToolButton()
file_name_button.setText("Browse")
file_name_button.clicked.connect(self.selectFileDirectory)
self._defaultPath = QDir.currentPath() + "/export"
self._file_name = QLineEdit()
self._file_name.setEnabled(False)
self._file_name.setText(self._defaultPath)
self._file_name.textChanged.connect(self.validateExportDialog)
self._file_name.setMinimumWidth(250)
file_name_layout = QHBoxLayout()
file_name_layout.addWidget(self._file_name)
file_name_layout.addWidget(file_name_button)
layout.addRow("Select directory to save files to:", file_name_layout)
self._gen_kw_file_types = ["Parameter list", "Template based"]
self._field_kw_file_types = ["Eclipse GRDECL", "RMS roff"]
self._gen_data_file_types = ["Gen data"]
self._file_type_model = self._field_kw_file_types
self._file_type_combo = QComboBox()
self._file_type_combo.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self._file_type_combo.addItems(self._file_type_model)
layout.addRow("Select file format:", self._file_type_combo)
self._report_step = QLineEdit()
layout.addRow("Report step:", self._report_step)
self._gen_data_report_step_model = []
self._gen_data_report_step = QComboBox()
layout.addRow("Report step:", self._gen_data_report_step)
self.setLayout(layout)
self._keywords.currentIndexChanged.connect(self.keywordSelected)
self.keywordSelected()
for suffix, name in (
('png', "Portable Network Graphics"),
('jpg', "Joint Photographic Experts Group"),
('bmp', "Bitmap Image file"),
('bpm', "Business Process Model"),
('tiff', "Tagged Image File Format"),
('ico', "Windows Icon"),
('wbmp', "Wireless Application Protocol Bitmap"),
('xbm', "X Bitmap"),
('xpm', "X Pixmap"),
):
qt_image_suffix.append(suffix)
qt_image_format.append(f"{name} (*.{suffix})")
qt_image_suffix = tuple(qt_image_suffix)
qt_image_format = tuple(qt_image_format)
del suffix, name
QDir.addSearchPath("icons", join(abspath(dirname(__file__)), "icons"))
class QABCMeta(type(QObject), ABCMeta): # type: ignore
"""Qt ABCMeta class.
Usage:
>>> from abc import abstractmethod
>>> class MyQObject(QObject, metaclass=QABCMeta):
>>> @abstractmethod
>>> def my_abstract_method(self) -> None:
>>> raise NotImplementedError
"""
pass
def set_locate(self, locate: str) -> None:
"""Set environment variables."""
if locate == self.env or not QDir(locate).exists():
return
self.env = locate
logger.debug(f"~Set workplace to: \"{self.env}\"")
