def menu_bar(self):
bar = self.menuBar()
file_menu = bar.addMenu('File')
options = bar.addMenu('Options')
toggle_refresh = QAction(
'Auto Refresh',
self,
checkable=True,
triggered=lambda: self.timer.start(100)
if toggle_refresh.isChecked() else self.timer.stop())
toggle_ugly = QAction('Text View',
self,
checkable=True,
triggered=lambda: self.switch_view())
save_to_file = QAction('Save to File',
self,
triggered=self.export_registers)
toggle_refresh.setChecked(True)
options.addAction(toggle_refresh)
options.addAction(toggle_ugly)
file_menu.addAction(save_to_file)
def on_menu_item_checked(self, action: QAction):
item_id = action.property(ID_PROP)
checked = action.isChecked()
if item_id == ID_GRID_LINES:
self.level_view.draw_grid = checked
elif item_id == ID_TRANSPARENCY:
self.level_view.transparency = checked
elif item_id == ID_JUMPS:
self.level_view.draw_jumps = checked
elif item_id == ID_MARIO:
self.level_view.draw_mario = checked
elif item_id == ID_RESIZE_TYPE:
self.level_view.draw_expansions = checked
elif item_id == ID_JUMP_OBJECTS:
self.level_view.draw_jumps_on_objects = checked
elif item_id == ID_ITEM_BLOCKS:
self.level_view.draw_items_in_blocks = checked
elif item_id == ID_INVISIBLE_ITEMS:
self.level_view.draw_invisible_items = checked
SETTINGS["draw_mario"] = self.level_view.draw_mario
SETTINGS["draw_jumps"] = self.level_view.draw_jumps
SETTINGS["draw_grid"] = self.level_view.draw_grid
SETTINGS["draw_expansion"] = self.level_view.draw_expansions
SETTINGS[
"draw_jump_on_objects"] = self.level_view.draw_jumps_on_objects
SETTINGS["draw_items_in_blocks"] = self.level_view.draw_items_in_blocks
SETTINGS["draw_invisible_items"] = self.level_view.draw_invisible_items
SETTINGS["block_transparency"] = self.level_view.transparency
save_settings()
def menu_bar(self):
bar = self.menuBar()
file_menu = bar.addMenu('File')
options = bar.addMenu('Options')
toggle_refresh = QAction(
'Auto Refresh',
self,
checkable=True,
triggered=lambda: self.timer.start(100)
if toggle_refresh.isChecked() else self.timer.stop())
save_to_file = QAction('Save to File', self, triggered=self.export_log)
options.addAction(toggle_refresh)
file_menu.addAction(save_to_file)
class SettingsMenu(QMenu):
def __init__(self, ui):
super(SettingsMenu, self).__init__(_('Einstellungen'), ui)
self.ui = ui
check_icon = IconRsc.get_icon('check_box_empty')
check_icon.addPixmap(IconRsc.get_pixmap('check_box'), QIcon.Normal,
QIcon.On)
self.open_action = QAction(
check_icon, _('PSD Datei nach dem Erstellen automatisch öffnen'),
self)
self.open_action.setCheckable(True)
self.open_action.setChecked(AppSettings.app['open_editor'])
self.open_action.toggled.connect(self.toggle_psd_open_action)
self.addAction(self.open_action)
self.addSeparator()
img_icon = IconRsc.get_icon('setting')
set_ps_path = QAction(img_icon, _('Erweiterte Einstellungen'), self)
set_ps_path.triggered.connect(self.open_settings_dialog)
self.addAction(set_ps_path)
def toggle_psd_open_action(self):
AppSettings.app['open_editor'] = self.open_action.isChecked()
def update_btn_desc(self):
editor = Path(AppSettings.app['editor_path'])
if editor.exists() and editor.is_file():
self.ui.lastFileBtn.setDescription(
_('Mit benutzerdefiniertem Editor öffnen'))
else:
self.ui.lastFileBtn.setDescription(
_('Mit Standardanwendung öffnen'))
# Update resolution buttons from app settings
self.ui.update_resolution(from_settings=True)
def open_settings_dialog(self):
psd_settings_window = PhotoshopSettings(self.ui)
psd_settings_window.accepted.connect(self.update_btn_desc)
psd_settings_window.rejected.connect(self.update_btn_desc)
psd_settings_window.open()
class QTextEditLogger(QTextEdit):
"""A text edit logger class.
This class extends the `QTextEdit` class
"""
timestamp_len = 19
_logo = 'metal_logo.png'
def __init__(self, img_path='/', dock_window: QDockWidget = None):
"""Widget to handle logging. Based on QTextEdit, an advanced WYSIWYG
viewer/editor supporting rich text formatting using HTML-style tags. It
is optimized to handle large documents and to respond quickly to user
input.
Get as:
gui.ui.log_text
Args:
img_path (str): Path to images. Defaults to '/'.
dock_window (QDockWidget): The dock window widget. Defaults to None.
"""
super().__init__()
self.img_path = img_path
self.dock_window = dock_window
# handles the loggers
# dict for what loggers we track and if we should show or not
self.tracked_loggers = Dict()
self.handlers = Dict()
self._actions = Dict() # menu actions. Must be an ordered Dict!
self._auto_scroll = True # autoscroll to end or not
self._show_timestamps = False
self._level_name = ''
# Props of the Widget
self.setTextInteractionFlags(Qt.TextSelectableByMouse |
Qt.TextSelectableByKeyboard)
self.text_format = QtGui.QTextCharFormat()
self.text_format.setFontFamily('Consolas')
self.logged_lines = collections.deque(
[], config.GUI_CONFIG.logger.num_lines)
self.setup_menu()
def toggle_autoscroll(self, checked: bool):
"""Toggle the autoscroll.
Args:
checked (bool): True to toggle on, False otherwise
"""
self._auto_scroll = bool(checked)
def toggle_timestamps(self, checked: bool):
"""Toggle the timestamp.
Args:
checked (bool): True to toggle on, False otherwise
"""
self._show_timestamps = bool(checked)
self.show_all_messages()
def setup_menu(self):
"""Setup the menu."""
# Behaviour for menu: the widget displays its QWidget::actions() as context menu.
# i.e., a local context menu
self.setContextMenuPolicy(Qt.ActionsContextMenu)
###################
# Click actions
actions = self._actions
actions.clear_log = QAction('&Clear log', self, triggered=self.clear)
actions.print_tips = QAction('&Show tips ',
self,
triggered=self.print_all_tips)
actions.separator = QAction(self)
actions.separator.setSeparator(True)
###################
# Toggle actions
self.action_scroll_auto = QAction('&Autoscroll',
self,
checkable=True,
checked=True)
self.action_scroll_auto.toggled.connect(self.toggle_autoscroll)
self.action_show_times = QAction('&Show timestamps',
self,
checkable=True,
checked=False)
self.action_show_times.toggled.connect(self.toggle_timestamps)
###################
# Filter level actions
def make_trg(lvl):
"""Make a trg.
Args:
lvl (logging.level): The level of logging, eg.., logging.ERROR
Returns:
str: Value of the name attribute
"""
name = f'set_level_{lvl}'
# self.set_level(lvl)
setattr(self, name, lambda: self.set_level(lvl))
func = getattr(self, name)
return func
actions.debug = QAction('Set filter level: Debug',
self,
triggered=make_trg(logging.DEBUG))
actions.info = QAction('Set filter level: Info',
self,
triggered=make_trg(logging.INFO))
actions.warning = QAction('Set filter level: Warning',
self,
triggered=make_trg(logging.WARNING))
actions.error = QAction('Set filter level: Error',
self,
triggered=make_trg(logging.ERROR))
actions.separator2 = QAction(self)
actions.separator2.setSeparator(True)
actions.loggers = QAction('Show/hide messages for logger:',
self,
enabled=False)
# Add actions to actin context menu
self.addActions(list(actions.values()))
def welcome_message(self):
"""Display the welcome message."""
img_txt = ''
# Logo
img_path = Path(self.img_path) / self._logo
if img_path.is_file():
img_txt = f'<img src="{img_path}" height=80>'
else:
print(
'WARNING: welcome_message could not locate img_path={img_path}')
# Main message
text = f'''<span class="INFO">{' '*self.timestamp_len}
<br>
<table border="0" width="100%" ID="tableLogo" style="margin: 0px;">
<tr>
<td align="center">
<h3 align="center" style="text-align: center;">
Welcome to Qiskit Metal!
</h3>
v{__version__}
</td>
<td> {img_txt} </td>
</tr>
</table>
</span>
<b>Tip: </b> {random.choice(config.GUI_CONFIG['tips'])}'''
self.log_message(text, format_as_html=2)
def print_all_tips(self):
"""Prints all available tips in the log window."""
for tip in config.GUI_CONFIG['tips']:
self.log_message(
f'''<br><span class="INFO">{' '*self.timestamp_len} \u2022 {tip} </span>'''
)
def set_level(self, level: int):
"""Set level on all handlers.
Args:
level (logging.level): The level of logging, eg.., logging.ERROR
"""
print(f'Setting level: {level}')
self.set_window_title_level(level)
for name, handler in self.handlers.items():
handler.setLevel(level)
def set_window_title_level(self, level: int):
"""Set the window title level.
Args:
level (int): the level
"""
self._level_name = logging.getLevelName(level).lower()
if self._level_name not in ['']:
self.dock_window.setWindowTitle(
f'Log (filter >= {self._level_name})')
else:
self.dock_window.setWindowTitle(
f'Log (right click log for options)')
return self._level_name
def add_logger(self, name: str, handler: logging.Handler):
"""Adds a logger to the widget.
- adds `true bool` to self.tracked_loggers for on/off to show
- adds `the handler` in self.handlers
- adds an action to the menu for the self.traceked_loggers
For example, a logger handler is added with
`gui.logger.addHandler(self._log_handler)`
where
`_log_handler is LogHandler_for_QTextLog`
Args:
name (string): Name of logger to be added
handler (logging.Handler): Handler
"""
if name in self.tracked_loggers:
return
self.tracked_loggers[name] = True
# can this be a problem if handler has multiple names?
self.handlers[name] = handler
#############################################
# Monkey patch add function
func_name = f'toggle_{clean_name(name)}'
def toggle_show_log(self2, val: bool):
"""Toggle the value of the.
Args:
self2 (QTextEdit): self
val (bool): True or False
Example:
<bound method QTextEditLogger.add_logger.<locals>.toggle_show_log
of <qiskit_metal._gui.widgets.log_widget.log_metal.QTextEditLogger object at 0x7fce3a500c18>>
"""
self2.tracked_loggers[name] = bool(val)
monkey_patch(self, toggle_show_log, func_name=func_name)
#############################################
# Add action
action = QAction(f' - {name}',
self,
checkable=True,
checked=True,
triggered=getattr(self, func_name))
self._actions[f'logger_{name}'] = action
self.addAction(action)
# style TODO: move
self.document().setDefaultStyleSheet(config.GUI_CONFIG.logger.style)
# is this the first logger we added
if len(self.tracked_loggers) == 1:
self.set_window_title_level(handler.level)
def get_all_checked(self):
"""Get all the checked items.
Returns:
list: List of checked items
"""
res = []
for name, isChecked in self.tracked_loggers.items():
if isChecked:
res += [name]
return res
def show_all_messages(self):
"""Clear and reprint all log lines, thus refreshing toggles for
timestamp, etc."""
self.clear()
for name, record in self.logged_lines:
if name in self.get_all_checked():
self.log_message(record, name != 'Errors')
def log_message_to(self, name, record):
"""Set where to log messages to.
Args:
name (str): The name
record (bool): True to send to records, False otherwise
"""
self.logged_lines.append((name, record))
if name in self.get_all_checked():
self.log_message(record, name != 'Errors')
def log_message(self, message, format_as_html=True):
"""Do the actual logging.
Args:
message (str): The message to log.
format_as_html (bool): True to format as HTML, False otherwise. Defaults to True.
"""
# set the write positon
cursor = self.textCursor()
cursor.movePosition(QtGui.QTextCursor.End)
cursor.insertBlock() # add a new block, which makes a new line
# add message
if format_as_html == True: # pylint: disable=singleton-comparison
if not self.action_show_times.isChecked():
# remove the timestamp -- assumes that this has been formatted
# with pre tag by LogHandler_for_QTextLog
res = message.split('<pre>', 1)
if len(res) == 2:
message = res[0] + '<pre>' + res[1][1 + self.timestamp_len:]
else:
pass # print(f'Warning incorrect: {message}')
cursor.insertHtml(message)
elif format_as_html == 2:
cursor.insertHtml(message)
else:
cursor.insertText(message, self.text_format)
# make sure that the message is visible and scrolled ot
if self.action_scroll_auto.isChecked():
self.moveCursor(QtGui.QTextCursor.End)
self.moveCursor(QtGui.QTextCursor.StartOfLine)
self.ensureCursorVisible()
def remove_handlers(self, logger):
"""Call on clsoe window to remove handlers from the logger."""
for name, handler in self.handlers.items():
if handler in logger.handlers:
logger.handlers.remove(handler)
class Window(QMainWindow):
def __init__(self):
super(Window, self).__init__()
self.project = None
self.view = None
self.lastProjectDirectory = None
self.lastProjectFile = None
self.recentProjectFiles = list()
self.lastImportDirectory = None
self.loadSettings()
self.setWindowTitle("Point Cloud Tagger")
self.createActions()
self.createMenus()
self.createToolBars()
self.createContainer()
self.createEditor()
self.createStatusBar()
def loadSettings(self):
try:
with io.open(Path(__file__).parent / 'app.json', 'r') as f:
data = json.load(f)
if 'lastProjectDirectory' in data:
self.lastProjectDirectory = data['lastProjectDirectory']
if 'recentProjectFiles' in data:
self.recentProjectFiles = data['recentProjectFiles']
if 'lastImportDirectory' in data:
self.lastImportDirectory = data['lastImportDirectory']
except:
pass
def saveSettings(self):
data = dict()
data['lastProjectDirectory'] = self.lastProjectDirectory
data['recentProjectFiles'] = self.recentProjectFiles
data['lastImportDirectory'] = self.lastImportDirectory
with io.open(Path(__file__).parent / 'app.json', 'w') as f:
json.dump(data, f, indent=' ')
def createActions(self):
# root = QFileInfo(__file__).absolutePath()
self.newAct = QAction(
# QIcon(root + '/icons/new.png'),
"&New",
self,
shortcut=QKeySequence.New,
statusTip="Start new project",
triggered=self.newProject)
self.openAct = QAction(
# QIcon(root + '/icons/open.png'),
"&Open",
self,
shortcut=QKeySequence.Open,
statusTip="Open project",
triggered=self.openProject)
self.saveAct = QAction(
# QIcon(root + '/icons/save.png'),
"&Save",
self,
shortcut=QKeySequence.Save,
statusTip="Save project",
triggered=self.saveProject,
enabled=False)
self.saveAsAct = QAction(
# QIcon(root + '/icons/saveas.png'),
"Save &As...",
self,
shortcut=QKeySequence.SaveAs,
statusTip="Save project under new name",
triggered=self.saveProjectAs,
enabled=False)
self.closeAct = QAction(
# QIcon(root + '/icons/close.png'),
"&Close",
self,
shortcut=QKeySequence.Close,
statusTip="Close project",
triggered=self.closeProject,
enabled=False)
self.importAct = QAction(
# QIcon(root + '/icons/import.png'),
"Import MVE Scene",
self,
statusTip="Import MVE scene",
triggered=self.importMVEScene,
enabled=False)
self.exportSelectionAct = QAction(
# QIcon(root + '/icons/import.png'),
"Export Selection",
self,
statusTip="Export selection to ply",
triggered=self.exportSelection,
enabled=False)
self.exportViewsAct = QAction(
# QIcon(root + '/icons/import.png'),
"Export Views",
self,
statusTip="Export views to png",
triggered=self.exportViews,
enabled=False)
self.exitAct = QAction(
# QIcon(root + '/icons/quit.png'),
"&Quit",
self,
shortcut=QKeySequence.Quit,
statusTip="Close the application",
triggered=self.close)
self.aboutAct = QAction("&About",
self,
statusTip="Show the application's About box",
triggered=self.about)
cameraGroup = QActionGroup(self)
self.orthoCameraAct = QAction(
# QIcon(root + '/icons/camera-ortho.png'),
"Orthographic",
cameraGroup,
shortcut="O",
statusTip="Orthographic camera",
triggered=self.toggleOrthoCamera,
checkable=True,
checked=False,
enabled=False)
self.perspectiveCameraAct = QAction(
# QIcon(root + '/icons/camera-perpective.png'),
"Perspective",
cameraGroup,
shortcut="P",
statusTip="Perspective camera",
triggered=self.togglePerspectiveCamera,
checkable=True,
checked=True,
enabled=False)
self.viewCameraAct = QAction(
# QIcon(root + '/icons/camera-view.png'),
"View",
cameraGroup,
shortcut="[",
statusTip="Views camera",
triggered=self.toggleViewCamera,
checkable=True,
checked=False,
enabled=False)
self.toggleAxisAct = QAction(
# QIcon(root + '/icons/axis.png'),
"Axis",
self,
statusTip="Show/hide axis",
triggered=self.toggleAxis,
checkable=True,
checked=True,
enabled=False)
self.togglePlaneAct = QAction(
# QIcon(root + '/icons/plane.png'),
"Plane",
self,
statusTip="Show/hide plane",
triggered=self.togglePlane,
checkable=True,
checked=True,
enabled=False)
self.toggleLocationAct = QAction(
# QIcon(root + '/icons/location.png'),
"Location",
self,
statusTip="Show/hide location",
triggered=self.toggleLocation,
checkable=True,
checked=True,
enabled=False)
self.toggleBBoxAct = QAction(
# QIcon(root + '/icons/bbox.png'),
"BBox",
self,
statusTip="Show/hide box",
triggered=self.toggleBBox,
checkable=True,
checked=True,
enabled=False)
self.togglePhotoAct = QAction(
# QIcon(root + '/icons/photo.png'),
"Picture",
self,
shortcut="]",
statusTip="Show/hide picture",
triggered=self.togglePicture,
checkable=True,
checked=True,
enabled=False)
self.preselectAct = QAction(
"Build/apply selection",
self,
statusTip="Build index and apply saved selection",
triggered=self.preselect,
enabled=False)
self.editorAct = QAction("Scene editor",
self,
statusTip="Open scene editor",
triggered=self.showEditor,
enabled=False)
def createMenus(self):
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(self.newAct)
fileMenu.addAction(self.openAct)
fileMenu.addAction(self.saveAct)
fileMenu.addAction(self.saveAsAct)
fileMenu.addAction(self.closeAct)
fileMenu.addSeparator()
fileMenu.addAction(self.importAct)
fileMenu.addSeparator()
fileMenu.addAction(self.exportSelectionAct)
fileMenu.addAction(self.exportViewsAct)
fileMenu.addSeparator()
self.recentMenu = fileMenu.addMenu("Recent...")
self.updateRecentMenu()
fileMenu.addSeparator()
fileMenu.addAction(self.exitAct)
viewMenu = self.menuBar().addMenu("&View")
viewMenu.addAction(self.orthoCameraAct)
viewMenu.addAction(self.perspectiveCameraAct)
viewMenu.addAction(self.viewCameraAct)
viewMenu.addSeparator()
viewMenu.addAction(self.toggleAxisAct)
viewMenu.addAction(self.togglePlaneAct)
viewMenu.addAction(self.toggleLocationAct)
viewMenu.addAction(self.toggleBBoxAct)
viewMenu.addAction(self.togglePhotoAct)
viewMenu.addSeparator()
self.shaderMenu = viewMenu.addMenu("Cloud shaders...")
self.shaderMenu.setEnabled(False)
self.updateShaderMenu()
toolsMenu = self.menuBar().addMenu("&Tools")
toolsMenu.addAction(self.preselectAct)
toolsMenu.addSeparator()
toolsMenu.addAction(self.editorAct)
self.menuBar().addSeparator()
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction(self.aboutAct)
def updateRecentMenu(self):
self.recentMenu.clear()
if len(self.recentProjectFiles) > 0:
for file in self.recentProjectFiles:
def openRecent(filename):
return lambda: self.openProject(filename)
if len(file) > 30:
name = "..." + file[-30:]
else:
name = file
self.recentMenu.addAction(name, openRecent(file))
else:
self.recentMenu.addSection("No project yet")
def updateShaderMenu(self):
self.shaderActions = dict()
self.shaderMenu.clear()
items = sorted(
set([
file.stem
for file in (Path(__file__).parent / 'shaders').iterdir()
if file.is_file()
]))
group = QActionGroup(self)
for item in items:
def setShader(name):
return lambda: self.setCloudShader(name)
checked = False
if self.project:
checked = self.project.cloudShaderName == item
action = QAction(item,
group,
triggered=setShader(item),
checkable=True,
checked=checked)
self.shaderActions[item] = action
self.shaderMenu.addAction(action)
def createToolBars(self):
# self.fileToolBar = self.addToolBar("File")
# self.fileToolBar.addAction(self.newAct)
# self.fileToolBar.addAction(self.openAct)
# self.fileToolBar.addAction(self.saveAct)
# viewToolBar = self.addToolBar("View")
# cameraMenu = QMenu("Camera", self)
# cameraMenu.addAction(self.orthoCameraAct)
# cameraMenu.addAction(self.perspectiveCameraAct)
# cameraMenu.addAction(self.viewCameraAct)
# cameraButton = QToolButton(text="Camera", popupMode=QToolButton.InstantPopup)
# cameraButton.setMenu(cameraMenu)
# viewToolBar.addWidget(cameraButton)
# viewToolBar.addAction(self.toggleAxisAct)
# viewToolBar.addAction(self.togglePlaneAct)
# viewToolBar.addAction(self.toggleLocationAct)
# viewToolBar.addAction(self.toggleBBoxAct)
# viewToolBar.addAction(self.togglePhotoAct)
pass
def createContainer(self):
self.container = QWidget(self)
self.container.setStyleSheet("QOpenGLWidget { background: black; }")
self.container.setLayout(QVBoxLayout())
self.setCentralWidget(self.container)
def createEditor(self):
self.editor = Editor(self)
self.editor.changed.connect(self.renderProject,
type=Qt.QueuedConnection)
def createStatusBar(self):
self.statusBar().showMessage("Initialized")
def closeEvent(self, event):
self.destroyProject()
event.accept()
def enableProjectActions(self, enabled):
actions = [
self.saveAct,
self.saveAsAct,
self.closeAct,
self.importAct,
self.exportSelectionAct,
self.exportViewsAct,
self.orthoCameraAct,
self.perspectiveCameraAct,
self.viewCameraAct,
self.toggleAxisAct,
self.togglePlaneAct,
self.toggleLocationAct,
self.toggleBBoxAct,
self.togglePhotoAct,
self.shaderMenu,
self.preselectAct,
self.editorAct,
]
for action in actions:
action.setEnabled(enabled)
def createProject(self):
self.destroyProject()
self.project = Project(0.7, 0.9, 0.1, 1000)
self.project.message.connect(self.showMessage,
type=Qt.QueuedConnection)
self.project.stateChanged.connect(self.updateState,
type=Qt.QueuedConnection)
self.view = View(self, self.project)
self.container.layout().addWidget(self.view)
self.enableProjectActions(True)
self.updateShaderMenu()
self.editor.setProject(self.project)
def destroyProject(self):
self.editor.setProject(None)
self.enableProjectActions(False)
if self.view:
self.container.layout().removeWidget(self.view)
self.view.close()
self.view = None
if self.project:
self.project.message.disconnect(self.showMessage)
self.project.stateChanged.disconnect(self.updateState)
self.project = None
@Slot(str)
def showMessage(self, message):
self.statusBar().showMessage(message)
@Slot()
def updateState(self):
if not self.project:
return
self.orthoCameraAct.setChecked(self.project.cameraMode == 'ortho')
self.perspectiveCameraAct.setChecked(
self.project.cameraMode == 'perspective')
self.viewCameraAct.setChecked(self.project.cameraMode == 'view')
self.toggleAxisAct.setChecked(self.project.showAxis)
self.togglePlaneAct.setChecked(self.project.showPlane)
self.toggleLocationAct.setChecked(self.project.showLocation)
self.toggleBBoxAct.setChecked(self.project.showBBox)
self.togglePhotoAct.setChecked(self.project.showPicture)
def newProject(self):
self.createProject()
self.project.create()
self.lastProjectFile = None
def openProject(self, filename=None):
if not filename:
(filename, ftype) = QFileDialog.getOpenFileName(
self,
"Choose project file",
dir=self.lastProjectDirectory,
filter="Projects (*.prj)",
options=QFileDialog.DontResolveSymlinks
| QFileDialog.HideNameFilterDetails)
if filename:
self.lastProjectDirectory = str(Path(filename).parent)
self.createProject()
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.load(filename, progress)
self.lastProjectFile = filename
if filename in self.recentProjectFiles:
self.recentProjectFiles.remove(filename)
self.recentProjectFiles.insert(0, filename)
self.updateRecentMenu()
self.updateShaderMenu()
self.editor.setProject(self.project)
self.saveSettings()
except BaseException as e:
progress.close()
raise e
def saveProject(self):
if not self.lastProjectFile:
self.saveProjectAs()
return
self.project.save(self.lastProjectFile)
def saveProjectAs(self):
(filename, ftype) = QFileDialog.getSaveFileName(
self,
"Choose project file",
dir=self.lastProjectDirectory,
filter="Projects (*.prj)",
options=QFileDialog.DontResolveSymlinks
| QFileDialog.HideNameFilterDetails)
if filename:
if not filename.endswith('.prj'):
filename += '.prj'
self.project.save(filename)
self.lastProjectFile = filename
if filename in self.recentProjectFiles:
self.recentProjectFiles.remove(filename)
self.recentProjectFiles.insert(0, filename)
self.updateRecentMenu()
self.saveSettings()
def closeProject(self):
self.destroyProject()
def importMVEScene(self):
(filename, ftype) = QFileDialog.getOpenFileName(
self,
"Choose MVE scene",
dir=self.lastImportDirectory,
filter="MVE Scene (synth_0.out)",
options=QFileDialog.DontResolveSymlinks)
if filename:
directory = str(Path(filename).parent)
self.lastImportDirectory = directory
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.importmve(directory, progress)
self.view.update()
self.saveSettings()
except BaseException as e:
progress.close()
raise e
def exportSelection(self):
(filename, ftype) = QFileDialog.getSaveFileName(
self,
"Choose ply file",
dir=self.lastProjectDirectory,
filter="Meshes (*.ply)",
options=QFileDialog.DontResolveSymlinks
| QFileDialog.HideNameFilterDetails)
if filename:
if not filename.endswith('.ply'):
filename += '.ply'
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.exportply(filename, progress)
except BaseException as e:
progress.close()
raise e
def exportViews(self):
filename, ok = QInputDialog.getText(self, "View Image Filename",
"Png filename")
if ok and len(filename) > 0:
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.exportviews(self.view.context(), filename,
progress)
except BaseException as e:
progress.close()
raise e
def preselect(self):
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.preselect(progress)
except BaseException as e:
progress.close()
raise e
def showEditor(self):
dock = QDockWidget("Scene Parameters", self)
dock.setAllowedAreas(Qt.RightDockWidgetArea)
dock.setFixedWidth(640)
dock.setWidget(self.editor)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
def toggleOrthoCamera(self):
if not self.orthoCameraAct.isChecked():
return
self.project.setCameraMode('ortho')
def togglePerspectiveCamera(self):
if not self.perspectiveCameraAct.isChecked():
return
self.project.setCameraMode('perspective')
def toggleViewCamera(self):
if not self.viewCameraAct.isChecked():
return
self.project.setCameraMode('view')
def toggleAxis(self):
self.project.toggleAxis()
def togglePlane(self):
self.project.togglePlane()
def toggleLocation(self):
self.project.toggleLocation()
def toggleBBox(self):
self.project.toggleBBox()
def togglePicture(self):
self.project.togglePicture()
def setCloudShader(self, name):
if not self.project:
return
self.editor.loadShader(name)
self.project.setCloudShader(name)
self.shaderActions[name].setChecked(True)
def renderProject(self):
if not self.project:
return
self.project.redraw.emit()
def about(self):
QMessageBox.about(
self, "About Application",
"The <b>3D Tagger</b> can load point-clouds from MVE scenes, tag points and export result."
)
class MainWindow(QMainWindow):
def __init__(self, tedaCommandLine):
super().__init__()
self.tedaCommandLine = tedaCommandLine
self.cmaps = ColorMaps()
self.combobox = QComboBox()
self.filename = None
self.isMousePressed = False
self.isCmdPressed = False
self.cursor_coords = CoordinatesModel()
self.scales_model = ScalesModel()
fig = Figure(figsize=(14, 10))
fig.tight_layout()
self.fits_image = FitsPlotter(figure=fig)
fig.subplots_adjust(left=0,
bottom=0.001,
right=1,
top=1,
wspace=None,
hspace=None)
self.fits_image = FitsPlotterFitsFile(figure=fig,
cmap_model=self.cmaps,
scale_model=self.scales_model)
self.central_widget = FigureCanvas(fig)
self.setCentralWidget(self.central_widget)
self.current_x_coord = 0
self.current_y_coord = 0
self.fullWidgetXcord = 0
self.fullWidgetYcord = 0
self.centralWidgetcordX = 0
self.centralWidgetcordY = 0
self.painterComponent = PainterComponent(self.fits_image)
# self.painterComponent.startMovingEvents(self.central_widget)
self.painterComponent.setCanvas(self.central_widget)
self.scanObject = ScanToolbar(self)
self.createActions()
self.createMenus()
self.createToolBars()
self.createStatusBar()
self.createDockWindows()
if not self.tedaCommandLine.ignoreSettings:
self.scaleWidget.readSlidersValues()
# self.defineButtonsActions()
self.setWindowTitle("TeDa")
self.painterComponent.observe(
lambda change: self.onAutoCenterChange(change), ['auto_center'])
self.readWindowSettings()
self.readAppState()
self.updateHeaderData()
self.dragging = draggingComponent.Dragging(
widget=self, scale_widget=self.scaleWidget)
self.activeLinearAdjustmentByMouseMovement()
# Observing here may be to late for values loaded from settings e.g. via readAppState
self.painterComponent.observe(
lambda change: self.onCenterCircleChange(change),
['ccenter_x', 'ccenter_y'])
self.painterComponent.observe(
lambda change: self.onCenterCircleRadiusChange(change),
['cradius'])
self.fits_image.observe(lambda change: self.onMouseMoveOnImage(change),
['mouse_xdata', 'mouse_ydata'])
# self.cmaps.observe(lambda change: self.on_colormap_change(change))
self.full_view_widget.painterComponent.observe(
lambda change: self.onRectangleInWidgetMove(change),
['viewX', 'viewY'])
self.painterComponent.observe(
lambda change: self.movingCentralWidget(change),
['movingViewX', 'movingViewY'])
self.fits_image.observe(lambda change: self.onMouseZoomOnImage(change),
['viewBounaries_versionno'])
# open last fits
try:
self.openLastFits()
except FileNotFoundError:
print('Błąd w odczycie lub brak ostatio wczytanego pliku')
def closeEvent(self, event: PySide2.QtGui.QCloseEvent):
self.writeAppState()
self.writeWindowSettings()
if not self.tedaCommandLine.ignoreSettings:
self.scaleWidget.writeSlidersValues()
super().closeEvent(event)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Delete:
self.deleteSelected()
if e.key() == Qt.Key_R:
action = self.dockRadialFit.toggleViewAction()
if not action.isChecked():
action.trigger()
if (self.cursor_coords.img_x != 0 and self.cursor_coords.img_x !=
None) and (self.cursor_coords.img_y != 0
and self.cursor_coords.img_y != None):
self.painterComponent.add(self.cursor_coords.img_x,
self.cursor_coords.img_y,
type="circleCenter")
self.painterComponent.paintAllShapes(
self.central_widget.figure.axes[0])
if e.key() == Qt.Key_Control:
self.isCmdPressed = True
def keyReleaseEvent(self, event: PySide2.QtGui.QKeyEvent):
if event.key() == Qt.Key_Control:
self.isCmdPressed = False
def canvasMousePressEvent(self, event):
self.isMousePressed = not self.isMousePressed
def mouseMoveEventOnCanvas(self, event):
if self.isCmdPressed:
if self.isMousePressed:
self.dragging.mouseMoveEvent(event)
def print_(self):
document = self.textEdit.document()
printer = QPrinter()
dlg = QPrintDialog(printer, self)
if dlg.exec_() != QDialog.Accepted:
return
document.print_(printer)
self.statusBar().showMessage("Ready", 2000)
def open_dialog(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Image", ".",
"Fits files (*.fits)")
if fileName:
self.open_fits(fileName)
def save(self):
filename, _ = QFileDialog.getSaveFileName(self, "Choose a file name",
'.', "HTML (*.html *.htm)")
if not filename:
return
file = QFile(filename)
if not file.open(QFile.WriteOnly | QFile.Text):
QMessageBox.warning(
self, "Dock Widgets",
"Cannot write file %s:\n%s." % (filename, file.errorString()))
return
out = QTextStream(file)
QApplication.setOverrideCursor(Qt.WaitCursor)
out << self.textEdit.toHtml()
QApplication.restoreOverrideCursor()
self.statusBar().showMessage("Saved '%s'" % filename, 2000)
def save_dialog(self):
figure = self.central_widget.figure
filetypes = figure.canvas.get_supported_filetypes_grouped()
filterstr = ';;'.join([
k + ' (' + ' '.join(['*.' + ext for ext in v]) + ')'
for k, v in filetypes.items()
])
dialog = QFileDialog.getSaveFileName(
self, "Save Image As...",
os.path.splitext(self.filename)[0], filterstr)
if dialog[0] != "":
try:
self.central_widget.figure.savefig(dialog[0])
except ValueError:
print("Unsupported format")
def open_fits(self, fileName):
"""Opens specified FITS file and loads it to user interface"""
self.fits_image.set_file(fileName)
self.filename = fileName
self.cursor_coords.set_wcs_from_fits(
self.fits_image.header
) # TODO: one up and extract and set wcs in fits_image before plot
self.fits_image.set_wcs(self.cursor_coords.wcs)
self.fits_image.plot()
self.radial_profile_widget.set_data(self.fits_image.data)
self.radial_profile_iraf_widget.set_data(self.fits_image.data)
self.updateHeaderData()
self.zoom_view_widget.updateFits(self.fits_image)
self.full_view_widget.updateFits(self.fits_image)
self.saveLastFits()
def saveLastFits(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("Files")
settings.setValue("lastFile", self.filename)
settings.endGroup()
def openLastFits(self):
if (self.tedaCommandLine.openFile is None):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("Files")
filename = settings.value("lastFile")
settings.endGroup()
else:
filename = self.tedaCommandLine.openFile
if filename:
self.open_fits(filename)
def readAppState(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("WCS")
self.wcsSexAct.setChecked(bool(settings.value("sexagesimal", True)))
self.wcsGridAct.setChecked(bool(settings.value("grid", False)))
settings.endGroup()
settings.beginGroup("paint")
self.painterComponent.auto_center = bool(
settings.value("auto_center", True))
settings.endGroup()
def writeAppState(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("WCS")
settings.setValue("sexagesimal", self.wcsSexAct.isChecked())
settings.setValue("grid", self.wcsGridAct.isChecked())
settings.endGroup()
settings.beginGroup("paint")
settings.setValue("auto_center", self.painterComponent.auto_center)
settings.endGroup()
def undo(self):
document = self.textEdit.document()
document.undo()
def insertCustomer(self, customer):
if not customer:
return
def addParagraph(self, paragraph):
if not paragraph:
return
def about(self):
QMessageBox.about(
self, "TeDa FITS Viewer", f"TeDa FITS Viewer {__version__} <br/>"
"Authors: <ul> "
"<li>Michał Brodniak</li>"
"<li>Konrad Górski</li>"
"<li>Mikołaj Kałuszyński</li>"
"<li>Edward Lis</li>"
"<li>Grzegorz Mroczkowski</li>"
"</ul>"
"Created by <a href='https://akond.com'>Akond Lab</a> for The "
"<a href='https://araucaria.camk.edu.pl'>Araucaria Project</a><br/>"
"Licence: MIT <br/>"
"3rd party work used: "
"<a href='https://material.io/resources/icons/'> Google Material Icons</a>, "
"<a href='https://www.astropy.org'> AstroPy</a>, "
"<a href='https://doc.qt.io/qtforpython/'> Qt5/PySide2</a>, "
"<a href='https://www.scipy.org'> SciPy</a>, and other..."
"<br/><br/>"
"Visit the <a href='https://github.com/majkelx/teda'>project's GitHub page</a> for help"
" and the issue tracker")
def on_console_show(self):
console.show(ax=self.fits_image.ax,
window=self,
data=self.fits_image.data,
header=self.fits_image.header,
wcs=self.cursor_coords.wcs)
def on_sex_toggle(self):
print('sex toggled to :', self.wcsSexAct.isChecked())
self.cursor_coords.wcs_sexagesimal = self.wcsSexAct.isChecked()
def on_grid_toggle(self):
self.fits_image.plot_grid = self.wcsGridAct.isChecked()
def createActions(self):
# ico1 = QPixmap('/Users/mka/projects/astro/teda/icons/png.png')
# self.openAct = QAction(ico1, "&Open", self, shortcut=QKeySequence.Open, statusTip="Open FITS file", triggered=self.open)
self.openAct = QAction(IconFactory.getIcon('note_add'),
"&Open",
self,
shortcut=QKeySequence.Open,
statusTip="Open FITS file",
triggered=self.open_dialog)
self.saveAct = QAction(IconFactory.getIcon('save'),
"&Save",
self,
shortcut=QKeySequence.Save,
statusTip="Save FITS view",
triggered=self.save_dialog)
self.quitAct = QAction("&Quit",
self,
shortcut="Ctrl+Q",
statusTip="Quit the application",
triggered=self.close)
self.aboutAct = QAction("&About",
self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt",
self,
statusTip="Show the Qt library's About box",
triggered=QApplication.instance().aboutQt)
self.qtConsoleAct = QAction('Python Console',
self,
statusTip="Open IPython console window",
triggered=self.on_console_show)
self.wcsSexAct = QAction(
'Sexagesimal',
self,
statusTip=
"Format WCS coordinates as sexagesimal (RA in hour angle) instead of decimal deg"
)
self.wcsSexAct.toggled.connect(self.on_sex_toggle)
self.wcsSexAct.setCheckable(True)
self.wcsGridAct = QAction(
'Show Grid',
self,
statusTip="Overlay WCS coordinates grid over image",
)
self.wcsGridAct.setCheckable(True)
self.wcsGridAct.toggled.connect(self.on_grid_toggle)
self.prevHDUAct = QAction(IconFactory.getIcon('skip_previous'),
'Prev HDU',
self,
statusTip="Previous HDU",
triggered=self.prevHDU)
self.nextHDUAct = QAction(IconFactory.getIcon('skip_next'),
'Next HDU',
self,
statusTip="Next HDU",
triggered=self.nextHDU)
self.zoom4Act = QAction(IconFactory.getIcon("x4"),
'Zoom ×4',
self,
statusTip="Zoom ×4",
triggered=self.setZoomButton4)
self.zoom2Act = QAction(IconFactory.getIcon("x2"),
'Zoom ×2',
self,
statusTip="Zoom ×2",
triggered=self.setZoomButton2)
self.zoomHomeAct = QAction(IconFactory.getIcon('home'),
'Home',
self,
statusTip="Reset zoom an position",
triggered=self.setZoomButtonHome)
self.zoom05Act = QAction(IconFactory.getIcon("1-2"),
'Zoom 1/2',
self,
statusTip="Zoom 1/2",
triggered=self.setZoomButton05)
self.zoom025Act = QAction(IconFactory.getIcon("1-4"),
'Zoom 1/4',
self,
statusTip="Zoom 1/4",
triggered=self.setZoomButton025)
self.panningAct = QAction(IconFactory.getIcon('panning'),
'Panning',
self,
statusTip="Panning",
triggered=self.changePanningStatus)
self.circleAct = QAction(IconFactory.getIcon('circle'),
'Add Region',
self,
statusTip="Add Region",
triggered=self.changeAddCircleStatus)
self.centerCircleAct = QAction(
IconFactory.getIcon('add_circle_outline'),
'Radial profile',
self,
statusTip="Radial profile with gaussoide fit [R]-key",
triggered=self.changeAddCenterCircleStatus)
self.autoCenterAct = QAction(
'Auto Center',
self,
statusTip="Automatically center cursor on star centroid",
triggered=self.changeAutoCenter)
self.deleteAct = QAction(IconFactory.getIcon('delete_forever'),
'Delete selected',
self,
statusTip="Delete selected [Del]-key",
triggered=self.deleteSelected)
self.slidersAct = QAction(
IconFactory.getIcon('slider'),
'Dynamic Scale Sliders',
self,
statusTip='Show/Hide Dynamic Scale',
triggered=self.dynamicScaleDockWidgetTriggerActions)
self.panningAct.setCheckable(True)
self.panningAct.setChecked(True)
self.circleAct.setCheckable(True)
self.autoCenterAct.setCheckable(True)
self.autoCenterAct.setChecked(self.painterComponent.auto_center)
self.centerCircleAct.setCheckable(True)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.scanObject.scanAct)
self.fileMenu.addAction(self.scanObject.stopAct)
self.fileMenu.addAction(self.scanObject.pauseAct)
self.fileMenu.addAction(self.scanObject.resumeAct)
self.fileMenu.addAction(self.scanObject.autopauseAct)
self.fileMenu.addAction(self.scanObject.disabledautopauseAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.quitAct)
self.editMenu = self.menuBar().addMenu("&Edit")
self.editMenu.addAction(self.panningAct)
self.editMenu.addAction(self.circleAct)
self.editMenu.addAction(self.centerCircleAct)
self.editMenu.addSeparator()
self.editMenu.addAction(self.autoCenterAct)
self.editMenu.addSeparator()
self.editMenu.addAction(self.deleteAct)
self.hduMenu = self.menuBar().addMenu("HDU")
self.hduMenu.addAction(self.prevHDUAct)
self.hduMenu.addAction(self.nextHDUAct)
self.hduMenu.addSeparator()
self.zoomMenu = self.menuBar().addMenu("Zoom")
self.zoomMenu.addAction(self.zoom4Act)
self.zoomMenu.addAction(self.zoom2Act)
self.zoomMenu.addAction(self.zoomHomeAct)
self.zoomMenu.addAction(self.zoom05Act)
self.zoomMenu.addAction(self.zoom025Act)
self.WcsMenu = self.menuBar().addMenu("W&CS")
self.WcsMenu.addAction(self.wcsSexAct)
self.WcsMenu.addSeparator()
self.WcsMenu.addAction(self.wcsGridAct)
self.viewMenu = self.menuBar().addMenu("&View")
self.viewMenu.addAction(self.qtConsoleAct)
self.viewMenu.addSeparator()
self.menuBar().addSeparator()
self.helpMenu = self.menuBar().addMenu("&Help")
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
def createToolBars(self):
self.fileToolBar = self.addToolBar("File Toolbar")
self.fileToolBar.addAction(self.openAct)
self.fileToolBar.addAction(self.saveAct)
self.hduToolBar = self.addToolBar("HDU Toolbar")
self.hduToolBar.addAction(self.prevHDUAct)
self.hduToolBar.addAction(self.nextHDUAct)
self.scanToolBar = self.addToolBar("Scan Toolbar")
self.scanToolBar.addAction(self.scanObject.scanAct)
self.scanToolBar.addAction(self.scanObject.stopAct)
self.scanToolBar.addAction(self.scanObject.pauseAct)
self.scanToolBar.addAction(self.scanObject.resumeAct)
self.scanToolBar.addAction(self.scanObject.autopauseAct)
self.scanToolBar.addAction(self.scanObject.disabledautopauseAct)
self.scanToolBar.hide()
# self.infoToolBar = self.addToolBar("Info Toolbar")
# self.mouse_x_label = QLabel('100.1')
# self.mouse_y_label = QLabel('100.145')
# self.infoToolBar.addWidget(QLabel('image x:'))
# self.infoToolBar.addWidget(self.mouse_x_label)
# self.infoToolBar.addWidget(QLabel('y:'))
# self.infoToolBar.addWidget(self.mouse_y_label)
# self.infoToolBar.hide()
self.zoomToolBar = self.addToolBar("Zoom Toolbar")
self.zoomToolBar.addAction(self.zoom4Act)
self.zoomToolBar.addAction(self.zoom2Act)
self.zoomToolBar.addAction(self.zoomHomeAct)
self.zoomToolBar.addAction(self.zoom05Act)
self.zoomToolBar.addAction(self.zoom025Act)
self.mouseActionToolBar = self.addToolBar("Mouse Task Toolbar")
self.mouseActionToolBar.addAction(self.panningAct)
self.mouseActionToolBar.addAction(self.circleAct)
self.mouseActionToolBar.addAction(self.centerCircleAct)
self.mouseActionToolBar.addAction(self.deleteAct)
self.sliderToolBar = self.addToolBar("Slider Toolbar")
self.slidersAct.setChecked(True)
self.sliderToolBar.addAction(self.slidersAct)
self.viewMenu.addAction(self.fileToolBar.toggleViewAction())
self.viewMenu.addAction(self.hduToolBar.toggleViewAction())
self.viewMenu.addAction(self.scanToolBar.toggleViewAction())
# self.viewMenu.addAction(self.infoToolBar.toggleViewAction())
self.viewMenu.addAction(self.zoomToolBar.toggleViewAction())
self.viewMenu.addAction(self.mouseActionToolBar.toggleViewAction())
self.viewMenu.addAction(self.sliderToolBar.toggleViewAction())
self.viewMenu.addSeparator()
def nextHDU(self):
self.fits_image.changeHDU(True, 1)
self.updateHeaderData()
def prevHDU(self):
self.fits_image.changeHDU(True, -1)
self.updateHeaderData()
def updateHeaderData(self):
self.headerWidget.setHeader()
self.prevHDUAct.setEnabled(self.fits_image._huds is not None
and self.fits_image.hdu != 0)
self.nextHDUAct.setEnabled(
self.fits_image._huds is not None
and self.fits_image.hdu != len(self.fits_image._huds) - 1)
def setZoomButton4(self):
self.setZoomButton(4, False)
def setZoomButton2(self):
self.setZoomButton(2, False)
def setZoomButtonHome(self):
self.setZoomButton(1, True)
def setZoomButton05(self):
self.setZoomButton(0.5, False)
def setZoomButton025(self):
self.setZoomButton(0.25, False)
def setZoomButton(self, zoom: float, reset: bool):
if self.fits_image.ax != None:
self.fits_image.setZoom(zoom, reset)
self.full_view_widget.updateMiniatureShape(self.fits_image.viewX,
self.fits_image.viewY,
self.fits_image.viewW,
self.fits_image.viewH)
def changePanningStatus(self):
if self.panningAct.isChecked():
self.toogleOffRegionButtons()
self.panningAct.toggle()
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.startMovingEvents(self.central_widget)
else:
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.stopMovingEvents(self.central_widget)
def changeAddCircleStatus(self):
if self.circleAct.isChecked():
self.toogleOffRegionButtons()
self.circleAct.toggle()
self.painterComponent.startPainting(self.central_widget, "circle")
else:
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.startMovingEvents(self.central_widget)
self.panningAct.toggle()
def changeAddCenterCircleStatus(self):
if self.centerCircleAct.isChecked():
self.toogleOffRegionButtons()
self.centerCircleAct.toggle()
self.painterComponent.startPainting(self.central_widget,
"circleCenter")
else:
self.painterComponent.stopPainting(self.central_widget)
self.painterComponent.startMovingEvents(self.central_widget)
self.panningAct.toggle()
def changeAutoCenter(self):
self.painterComponent.auto_center = self.autoCenterAct.isChecked()
def deleteSelected(self):
self.painterComponent.deleteSelectedShapes(
self.central_widget.figure.axes[0])
def toogleOffRegionButtons(self):
if self.panningAct.isChecked():
self.panningAct.toggle()
if self.circleAct.isChecked():
self.circleAct.toggle()
if self.centerCircleAct.isChecked():
self.centerCircleAct.toggle()
self.painterComponent.stopPainting(self.central_widget)
def createStatusBar(self):
self.statusBar().showMessage("Ready")
def createDockWindows(self):
# Scale
self.dynamic_scale_dock = QDockWidget("Dynamic Scale", self)
self.dynamic_scale_dock.setObjectName("SCALE")
self.dynamic_scale_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.scaleWidget = ScaleWidget(self,
scales_model=self.scales_model,
cmap_model=self.cmaps)
self.dynamic_scale_dock.setWidget(self.scaleWidget)
self.addDockWidget(Qt.RightDockWidgetArea, self.dynamic_scale_dock)
self.viewMenu.addAction(self.dynamic_scale_dock.toggleViewAction())
self.dynamic_scale_dock.setFloating(True)
self.dynamic_scale_dock.hide()
#radial profiles
dock = QDockWidget("Radial Profile Fit", self)
dock.setObjectName("RADIAL_PROFILE_IRAF")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.radial_profile_iraf_widget = IRAFRadialProfileWidget(
self.fits_image.data)
dock.setWidget(self.radial_profile_iraf_widget)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.dockRadialFit = dock
dock = QDockWidget("Radial Profile Curve", self)
dock.setObjectName("RADIAL_PROFILE")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.radial_profile_widget = RadialProfileWidget(self.fits_image.data)
dock.setWidget(self.radial_profile_widget)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
dock.hide()
#info panel
dock = QDockWidget("Info", self)
dock.setObjectName("INFO_PANEL")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.info_widget = InfoWidget(self)
dock.setWidget(self.info_widget)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
# FITS headers
dock = QDockWidget("FITS header", self)
dock.setObjectName("FTIS_DATA")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.headerWidget = HeaderTableWidget(self)
self.headerWidget.setColumnCount(2)
self.headerWidget.setHorizontalHeaderItem(0, QTableWidgetItem("KEY"))
self.headerWidget.setHorizontalHeaderItem(1, QTableWidgetItem("VALUE"))
self.headerWidget.horizontalHeader().setStretchLastSection(1)
self.headerWidget.setEditTriggers(
QtWidgets.QTableWidget.NoEditTriggers)
self.headerWidget.clearFocus()
dock.setWidget(self.headerWidget)
# full
dock = QDockWidget("Full view", self)
dock.setObjectName("FULL_VIEW")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.full_view_widget = FullViewWidget(self.fits_image)
self.full_view_widget.fits_image.set_scale_model(self.scales_model)
self.full_view_widget.fits_image.set_cmap_model(self.cmaps)
dock.setWidget(self.full_view_widget)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
# zoom
dock = QDockWidget("Zoom view", self)
dock.setObjectName("ZOOM_VIEW")
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea)
self.zoom_view_widget = ZoomViewWidget(self.fits_image)
self.zoom_view_widget.fits_image.set_scale_model(self.scales_model)
self.zoom_view_widget.fits_image.set_cmap_model(self.cmaps)
dock.setWidget(self.zoom_view_widget)
self.addDockWidget(Qt.TopDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
# fileSelector
dock = QDockWidget("Directory view", self)
dock.setObjectName("DIRECTORY_VIEW")
dock.setAllowedAreas(Qt.LeftDockWidgetArea)
self.file_widget = FileSystemWidget(self)
dock.setWidget(self.file_widget)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.viewMenu.addSeparator()
# def changeColor(self, color):
# self.cmaps.set_active_color_map(color)
# def on_colormap_change(self, change):
# self.fits_image.cmap = self.cmaps.get_active_color_map()
# self.fits_image.plot()
# self.updateFitsInWidgets()
def onAutoCenterChange(self, change):
self.autoCenterAct.setChecked(change.new)
def dynamicScaleDockWidgetTriggerActions(self):
if self.dynamic_scale_dock.isHidden():
self.dynamic_scale_dock.show()
else:
self.dynamic_scale_dock.hide()
def onCenterCircleChange(self, change):
self.radial_profile_widget.set_centroid(
self.painterComponent.ccenter_x, self.painterComponent.ccenter_y)
self.radial_profile_iraf_widget.set_centroid(
self.painterComponent.ccenter_x, self.painterComponent.ccenter_y)
def onCenterCircleRadiusChange(self, change):
self.radial_profile_widget.set_radius(self.painterComponent.cradius)
self.radial_profile_iraf_widget.set_radius(
self.painterComponent.cradius)
def onRectangleInWidgetMove(self, change):
changed = False
if change.new is not None:
changed = True
if change.name == 'viewX':
self.fullWidgetXcord = change.new
elif change.name == 'viewY':
self.fullWidgetYcord = change.new
if changed:
self.fits_image.moveToXYcords(self.fullWidgetXcord,
self.fullWidgetYcord)
def movingCentralWidget(self, change):
changed = False
if change.new is not None:
changed = True
if change.name == 'movingViewX':
self.centralWidgetcordX = change.new
elif change.name == 'movingViewY':
self.centralWidgetcordY = change.new
if changed:
self.full_view_widget.updateMiniatureShapeXYonly(
self.centralWidgetcordX, self.centralWidgetcordY)
def onMouseMoveOnImage(self, change):
display = ''
val = 0
if change.new is not None:
display = f'{change.new:f}'
val = change.new
if change.name == 'mouse_xdata':
# self.mouse_x_label.setText(display)
self.current_x_coord = val
self.cursor_coords.set_img_x(change.new)
elif change.name == 'mouse_ydata':
# self.mouse_y_label.setText(display)
self.current_y_coord = val
self.cursor_coords.set_img_y(change.new)
if display != '':
self.zoom_view_widget.setXYofZoom(self.fits_image,
self.current_x_coord,
self.current_y_coord,
self.fits_image.zoom)
if not self.hasFocus():
self.setFocus()
if self.scanObject.activeScan and self.scanObject.enableAutopause: #reser autopause
if not self.scanObject.obserwableValue.autopauseFlag:
self.scanObject.obserwableValue.autopauseFlag = True
def activeLinearAdjustmentByMouseMovement(self):
self.central_widget.mpl_connect('motion_notify_event',
self.mouseMoveEventOnCanvas)
self.central_widget.mpl_connect('button_press_event',
self.canvasMousePressEvent)
self.central_widget.mpl_connect('button_release_event',
self.canvasMousePressEvent)
def onMouseZoomOnImage(self, change):
changed = False
if change.new is not None:
changed = True
if changed:
self.full_view_widget.updateMiniatureShape(self.fits_image.viewX,
self.fits_image.viewY,
self.fits_image.viewW,
self.fits_image.viewH)
def readWindowSettings(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("MainWindow")
size, pos = settings.value("size"), settings.value("pos")
settings.endGroup()
if size is not None and pos is not None:
print('settings: resize to {} and move to {}', size, pos)
self.move(pos)
# self.resize(size)
print('Size reported ', self.size())
print('Size set ', size)
self.resize(size)
print('Size reported ', self.size())
else:
self.resize(800, 600)
geometry = settings.value("geometry")
if geometry is not None:
self.restoreGeometry(geometry)
self.restoreState(settings.value("windowState"))
self.headerWidget.readSettings(settings)
self.file_widget.readSettings(settings)
def writeWindowSettings(self):
if self.tedaCommandLine.ignoreSettings:
return
settings = QSettings()
settings.beginGroup("MainWindow")
settings.setValue("size", self.size())
settings.setValue("pos", self.pos())
settings.endGroup()
settings.setValue('geometry', self.saveGeometry())
settings.setValue('windowState', self.saveState())
self.headerWidget.writeSettings(settings)
self.file_widget.writeSettings(settings)
def initMenuBar(self):
self.menu = self.menuBar()
file_menu = self.menu.addMenu("&File")
file_menu.addAction(self.newGameAction)
file_menu.addAction(self.openAction)
file_menu.addSeparator()
file_menu.addAction(self.saveGameAction)
file_menu.addAction(self.saveAsAction)
file_menu.addSeparator()
file_menu.addAction(self.showLiberationPrefDialogAction)
file_menu.addSeparator()
#file_menu.addAction("Close Current Game", lambda: self.closeGame()) # Not working
file_menu.addAction("E&xit" , lambda: self.exit())
displayMenu = self.menu.addMenu("&Display")
tg_cp_visibility = QAction('&Control Point', displayMenu)
tg_cp_visibility.setCheckable(True)
tg_cp_visibility.setChecked(True)
tg_cp_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("cp", tg_cp_visibility.isChecked()))
tg_go_visibility = QAction('&Ground Objects', displayMenu)
tg_go_visibility.setCheckable(True)
tg_go_visibility.setChecked(True)
tg_go_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("go", tg_go_visibility.isChecked()))
tg_line_visibility = QAction('&Lines', displayMenu)
tg_line_visibility.setCheckable(True)
tg_line_visibility.setChecked(True)
tg_line_visibility.toggled.connect(
lambda: QLiberationMap.set_display_rule("lines", tg_line_visibility.isChecked()))
tg_event_visibility = QAction('&Events', displayMenu)
tg_event_visibility.setCheckable(True)
tg_event_visibility.setChecked(True)
tg_event_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("events", tg_event_visibility.isChecked()))
tg_sam_visibility = QAction('&SAM Range', displayMenu)
tg_sam_visibility.setCheckable(True)
tg_sam_visibility.setChecked(True)
tg_sam_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("sam", tg_sam_visibility.isChecked()))
tg_flight_path_visibility = QAction('&Flight Paths', displayMenu)
tg_flight_path_visibility.setCheckable(True)
tg_flight_path_visibility.setChecked(False)
tg_flight_path_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("flight_paths", tg_flight_path_visibility.isChecked()))
displayMenu.addAction(tg_go_visibility)
displayMenu.addAction(tg_cp_visibility)
displayMenu.addAction(tg_line_visibility)
displayMenu.addAction(tg_event_visibility)
displayMenu.addAction(tg_sam_visibility)
displayMenu.addAction(tg_flight_path_visibility)
help_menu = self.menu.addMenu("&Help")
help_menu.addAction("&Discord Server", lambda: webbrowser.open_new_tab("https://" + "discord.gg" + "/" + "bKrt" + "rkJ"))
help_menu.addAction("&Github Repository", lambda: webbrowser.open_new_tab("https://github.com/khopa/dcs_liberation"))
help_menu.addAction("&Releases", lambda: webbrowser.open_new_tab("https://github.com/Khopa/dcs_liberation/releases"))
help_menu.addAction("&Online Manual", lambda: webbrowser.open_new_tab(URLS["Manual"]))
help_menu.addAction("&ED Forum Thread", lambda: webbrowser.open_new_tab(URLS["ForumThread"]))
help_menu.addAction("Report an &issue", lambda: webbrowser.open_new_tab(URLS["Issues"]))
help_menu.addSeparator()
help_menu.addAction(self.showAboutDialogAction)
class MainWindow(QMainWindow):
def __init__(self, url):
super(MainWindow, self).__init__()
self.progress = 0
fd = QFile(":/jquery.min.js")
if fd.open(QIODevice.ReadOnly | QFile.Text):
self.jQuery = QTextStream(fd).readAll()
fd.close()
else:
self.jQuery = ''
QNetworkProxyFactory.setUseSystemConfiguration(True)
self.view = QWebView(self)
self.view.load(url)
self.view.loadFinished.connect(self.adjustLocation)
self.view.titleChanged.connect(self.adjustTitle)
self.view.loadProgress.connect(self.setProgress)
self.view.loadFinished.connect(self.finishLoading)
self.locationEdit = QLineEdit(self)
self.locationEdit.setSizePolicy(QSizePolicy.Expanding,
self.locationEdit.sizePolicy().verticalPolicy())
self.locationEdit.returnPressed.connect(self.changeLocation)
toolBar = self.addToolBar("Navigation")
toolBar.addAction(self.view.pageAction(QWebPage.Back))
toolBar.addAction(self.view.pageAction(QWebPage.Forward))
toolBar.addAction(self.view.pageAction(QWebPage.Reload))
toolBar.addAction(self.view.pageAction(QWebPage.Stop))
toolBar.addWidget(self.locationEdit)
viewMenu = self.menuBar().addMenu("&View")
viewSourceAction = QAction("Page Source", self)
viewSourceAction.triggered.connect(self.viewSource)
viewMenu.addAction(viewSourceAction)
effectMenu = self.menuBar().addMenu("&Effect")
effectMenu.addAction("Highlight all links", self.highlightAllLinks)
self.rotateAction = QAction(
self.style().standardIcon(QStyle.SP_FileDialogDetailedView),
"Turn images upside down", self, checkable=True)
self.rotateAction.toggled.connect(self.rotateImages)
effectMenu.addAction(self.rotateAction)
toolsMenu = self.menuBar().addMenu("&Tools")
toolsMenu.addAction("Remove GIF images", self.removeGifImages)
toolsMenu.addAction("Remove all inline frames",
self.removeInlineFrames)
toolsMenu.addAction("Remove all object elements",
self.removeObjectElements)
toolsMenu.addAction("Remove all embedded elements",
self.removeEmbeddedElements)
self.setCentralWidget(self.view)
def viewSource(self):
accessManager = self.view.page().networkAccessManager()
request = QNetworkRequest(self.view.url())
reply = accessManager.get(request)
reply.finished.connect(self.slotSourceDownloaded)
def slotSourceDownloaded(self):
reply = self.sender()
self.textEdit = QTextEdit()
self.textEdit.setAttribute(Qt.WA_DeleteOnClose)
self.textEdit.show()
self.textEdit.setPlainText(QTextStream(reply).readAll())
self.textEdit.resize(600, 400)
reply.deleteLater()
def adjustLocation(self):
self.locationEdit.setText(self.view.url().toString())
def changeLocation(self):
url = QUrl.fromUserInput(self.locationEdit.text())
self.view.load(url)
self.view.setFocus()
def adjustTitle(self):
if 0 < self.progress < 100:
self.setWindowTitle("%s (%s%%)" % (self.view.title(), self.progress))
else:
self.setWindowTitle(self.view.title())
def setProgress(self, p):
self.progress = p
self.adjustTitle()
def finishLoading(self):
self.progress = 100
self.adjustTitle()
self.view.page().mainFrame().evaluateJavaScript(self.jQuery)
self.rotateImages(self.rotateAction.isChecked())
def highlightAllLinks(self):
code = """$('a').each(
function () {
$(this).css('background-color', 'yellow')
}
)"""
self.view.page().mainFrame().evaluateJavaScript(code)
def rotateImages(self, invert):
if invert:
code = """
$('img').each(
function () {
$(this).css('-webkit-transition', '-webkit-transform 2s');
$(this).css('-webkit-transform', 'rotate(180deg)')
}
)"""
else:
code = """
$('img').each(
function () {
$(this).css('-webkit-transition', '-webkit-transform 2s');
$(this).css('-webkit-transform', 'rotate(0deg)')
}
)"""
self.view.page().mainFrame().evaluateJavaScript(code)
def removeGifImages(self):
code = "$('[src*=gif]').remove()"
self.view.page().mainFrame().evaluateJavaScript(code)
def removeInlineFrames(self):
code = "$('iframe').remove()"
self.view.page().mainFrame().evaluateJavaScript(code)
def removeObjectElements(self):
code = "$('object').remove()"
self.view.page().mainFrame().evaluateJavaScript(code)
def removeEmbeddedElements(self):
code = "$('embed').remove()"
self.view.page().mainFrame().evaluateJavaScript(code)
class FileSystemWidget(QWidget):
def __init__(self, parent, *args, **kwargs):
super().__init__(*args, **kwargs)
self.currentRootPath = '/'
self.currentPath = QDir.currentPath()
self.mainWindow = parent
self.chooseDirAction = QAction(IconFactory.getIcon('folder'),
'Root directory',
self,
statusTip="Change root directory",
triggered=self.chooseRootDir)
self.showOFAction = QAction(IconFactory.getIcon('filter_alt'),
'Show only FITS files',
self,
statusTip="Show only FITS/all files",
triggered=self.showOFFiles)
self.showOFAction.setCheckable(True)
self.showOFAction.toggled.connect(self.showOFFiles)
self.chooseDirBtn = QToolButton()
self.chooseDirBtn.setDefaultAction(self.chooseDirAction)
self.showOFBtn = QToolButton()
self.showOFBtn.setDefaultAction(self.showOFAction)
iconlayout = QHBoxLayout()
iconlayout.setAlignment(Qt.AlignLeft)
iconlayout.addWidget(self.chooseDirBtn)
iconlayout.addWidget(self.showOFBtn)
self.viewsSplitter = QSplitter(Qt.Horizontal)
self.viewsSplitter.splitterMoved.connect(self.splitterMoved)
self.dirsModel = QFileSystemModel(self)
self.dirsModel.setOption(QFileSystemModel.DontWatchForChanges, True)
self.dirsModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.dirsModel.setNameFilterDisables(False)
self.dirs = QTreeView()
self.dirs.setModel(self.dirsModel)
self.dirs.hideColumn(1)
self.dirs.hideColumn(2)
self.dirs.hideColumn(3)
self.dirs.clicked.connect(self.onDirsClick)
self.dirs.doubleClicked.connect(self.onDirsDoubleClick)
self.filesModel = QFileSystemModel(self)
self.filesModel.setOption(QFileSystemModel.DontWatchForChanges, True)
self.filesModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.filesModel.setNameFilterDisables(False)
self.files = QListView()
self.files.setModel(self.filesModel)
self.files.doubleClicked.connect(self.onFilesDoubleClick)
self.viewsSplitter.addWidget(self.dirs)
self.viewsSplitter.addWidget(self.files)
viewslayout = QHBoxLayout()
viewslayout.addWidget(self.viewsSplitter)
layout = QVBoxLayout()
layout.addLayout(iconlayout)
layout.addLayout(viewslayout)
self.setLayout(layout)
self.dirsModel.setRootPath(self.currentRootPath)
self.dirs.setRootIndex(self.dirsModel.index(self.currentRootPath))
index = self.dirsModel.index(self.currentPath)
self.dirs.setCurrentIndex(index)
self.dirs.setExpanded(index, True)
self.filesModel.setRootPath(self.currentPath)
self.files.setRootIndex(self.filesModel.index(self.currentPath))
def splitterMoved(self, pos, index):
if pos == 0:
self.filesModel.setFilter(QDir.NoDot | QDir.AllEntries
| QDir.DirsFirst | QDir.Type)
elif pos == self.viewsSplitter.width(
) - self.viewsSplitter.handleWidth():
self.dirsModel.setFilter(QDir.NoDotAndDotDot | QDir.AllEntries)
else:
self.dirsModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.filesModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
def onDirsClick(self, item):
index = self.dirs.selectedIndexes()[0]
info = self.dirsModel.fileInfo(index)
if info.isDir():
self.currentPath = info.filePath()
self.files.setRootIndex(
self.filesModel.setRootPath(info.filePath()))
def onDirsDoubleClick(self, item):
index = self.dirs.selectedIndexes()[0]
info = self.dirsModel.fileInfo(index)
if info.isDir():
self.currentPath = info.filePath()
self.files.setRootIndex(
self.filesModel.setRootPath(info.filePath()))
else:
self.mainWindow.open_fits(info.filePath())
def onFilesDoubleClick(self, item):
index = self.files.selectedIndexes()[0]
info = self.filesModel.fileInfo(index)
if info.isDir():
self.setPath(info.filePath())
else:
try:
self.mainWindow.open_fits(info.filePath())
except FileNotFoundError:
self.setPath(self.currentPath) # refesh maybe?
def setPath(self, path):
self.currentPath = path
index = self.dirsModel.index(self.currentPath)
self.dirs.setCurrentIndex(index)
self.dirs.setExpanded(index, True)
self.files.setRootIndex(self.filesModel.setRootPath(self.currentPath))
def chooseRootDir(self):
dir = QFileDialog.getExistingDirectory(self, 'Select directory')
if dir:
self.setRootPath(dir)
def setRootPath(self, dir):
self.currentRootPath = dir
self.dirsModel.setRootPath(self.currentRootPath)
self.dirs.setRootIndex(self.dirsModel.index(self.currentRootPath))
self.setPath(self.currentRootPath)
def showOFFiles(self):
if self.showOFAction.isChecked():
self.dirsModel.setNameFilters(["*.FITS", "*.fits"])
self.filesModel.setNameFilters(["*.FITS", "*.fits"])
else:
self.dirsModel.setNameFilters(["*"])
self.filesModel.setNameFilters(["*"])
def writeSettings(self, settings):
settings.beginGroup("fileWidget")
settings.setValue('splitterGeometry',
self.viewsSplitter.saveGeometry())
settings.setValue('splitterState', self.viewsSplitter.saveState())
settings.setValue('rootPath', self.currentRootPath)
settings.setValue('path', self.currentPath)
settings.endGroup()
def readSettings(self, settings):
settings.beginGroup("fileWidget")
self.viewsSplitter.restoreGeometry(settings.value("splitterGeometry"))
self.viewsSplitter.restoreState(settings.value("splitterState"))
rootPath = settings.value("rootPath")
path = settings.value("path")
settings.endGroup()
if rootPath is None:
rootPath = '/'
self.setRootPath(rootPath)
if path is None:
path = QDir.currentPath()
self.setPath(path)
self.splitterMoved(self.viewsSplitter.handle(1).pos().x(), 0)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowIcon(QIcon(":/icons/apps/16/tabulator.svg"))
self._recentDocuments = []
self._actionRecentDocuments = []
self._keyboardShortcutsDialog = None
self._preferences = Preferences()
self._preferences.loadSettings()
self._createActions()
self._createMenus()
self._createToolBars()
self._loadSettings()
self._updateActions()
self._updateActionFullScreen()
self._updateMenuOpenRecent()
# Central widget
self._documentArea = QMdiArea()
self._documentArea.setViewMode(QMdiArea.TabbedView)
self._documentArea.setTabsMovable(True)
self._documentArea.setTabsClosable(True)
self.setCentralWidget(self._documentArea)
self._documentArea.subWindowActivated.connect(self._onDocumentWindowActivated)
def closeEvent(self, event):
if True:
# Store application properties and preferences
self._saveSettings()
self._preferences.saveSettings()
event.accept()
else:
event.ignore()
def _loadSettings(self):
settings = QSettings()
# Recent documents
size = settings.beginReadArray("RecentDocuments")
for idx in range(size-1, -1, -1):
settings.setArrayIndex(idx)
canonicalName = QFileInfo(settings.value("Document")).canonicalFilePath()
self._updateRecentDocuments(canonicalName)
settings.endArray()
# Application properties: Geometry
geometry = settings.value("Application/Geometry", QByteArray()) if self._preferences.restoreApplicationGeometry() else QByteArray()
if not geometry.isEmpty():
self.restoreGeometry(geometry)
else:
availableGeometry = self.screen().availableGeometry()
self.resize(availableGeometry.width() * 2/3, availableGeometry.height() * 2/3)
self.move((availableGeometry.width() - self.width()) / 2, (availableGeometry.height() - self.height()) / 2)
# Application properties: State
state = settings.value("Application/State", QByteArray()) if self._preferences.restoreApplicationState() else QByteArray()
if not state.isEmpty():
self.restoreState(state)
else:
self._toolbarApplication.setVisible(True)
self._toolbarDocument.setVisible(True)
self._toolbarEdit.setVisible(True)
self._toolbarTools.setVisible(True)
self._toolbarView.setVisible(False)
self._toolbarHelp.setVisible(False)
def _saveSettings(self):
settings = QSettings()
# Recent documents
if not self._preferences.restoreRecentDocuments():
self._recentDocuments.clear()
settings.remove("RecentDocuments")
settings.beginWriteArray("RecentDocuments")
for idx in range(len(self._recentDocuments)):
settings.setArrayIndex(idx)
settings.setValue("Document", self._recentDocuments[idx])
settings.endArray()
# Application properties: Geometry
geometry = self.saveGeometry() if self._preferences.restoreApplicationGeometry() else QByteArray()
settings.setValue("Application/Geometry", geometry)
# Application properties: State
state = self.saveState() if self._preferences.restoreApplicationState() else QByteArray()
settings.setValue("Application/State", state)
def _createActions(self):
#
# Actions: Application
self._actionAbout = QAction(self.tr("About {0}").format(QApplication.applicationName()), self)
self._actionAbout.setObjectName("actionAbout")
self._actionAbout.setIcon(QIcon(":/icons/apps/16/tabulator.svg"))
self._actionAbout.setIconText(self.tr("About"))
self._actionAbout.setToolTip(self.tr("Brief description of the application"))
self._actionAbout.triggered.connect(self._onActionAboutTriggered)
self._actionColophon = QAction(self.tr("Colophon"), self)
self._actionColophon.setObjectName("actionColophon")
self._actionColophon.setToolTip(self.tr("Lengthy description of the application"))
self._actionColophon.triggered.connect(self._onActionColophonTriggered)
self._actionPreferences = QAction(self.tr("Preferences…"), self)
self._actionPreferences.setObjectName("actionPreferences")
self._actionPreferences.setIcon(QIcon.fromTheme("configure", QIcon(":/icons/actions/16/application-configure.svg")))
self._actionPreferences.setToolTip(self.tr("Customize the appearance and behavior of the application"))
self._actionPreferences.triggered.connect(self._onActionPreferencesTriggered)
self._actionQuit = QAction(self.tr("Quit"), self)
self._actionQuit.setObjectName("actionQuit")
self._actionQuit.setIcon(QIcon.fromTheme("application-exit", QIcon(":/icons/actions/16/application-exit.svg")))
self._actionQuit.setShortcut(QKeySequence.Quit)
self._actionQuit.setToolTip(self.tr("Quit the application"))
self._actionQuit.triggered.connect(self.close)
#
# Actions: Document
self._actionNew = QAction(self.tr("New"), self)
self._actionNew.setObjectName("actionNew")
self._actionNew.setIcon(QIcon.fromTheme("document-new", QIcon(":/icons/actions/16/document-new.svg")))
self._actionNew.setShortcut(QKeySequence.New)
self._actionNew.setToolTip(self.tr("Create new document"))
self._actionNew.triggered.connect(self._onActionNewTriggered)
self._actionOpen = QAction(self.tr("Open…"), self)
self._actionOpen.setObjectName("actionOpen")
self._actionOpen.setIcon(QIcon.fromTheme("document-open", QIcon(":/icons/actions/16/document-open.svg")))
self._actionOpen.setShortcut(QKeySequence.Open)
self._actionOpen.setToolTip(self.tr("Open an existing document"))
self._actionOpen.triggered.connect(self._onActionOpenTriggered)
self._actionOpenRecentClear = QAction(self.tr("Clear List"), self)
self._actionOpenRecentClear.setObjectName("actionOpenRecentClear")
self._actionOpenRecentClear.setToolTip(self.tr("Clear document list"))
self._actionOpenRecentClear.triggered.connect(self._onActionOpenRecentClearTriggered)
self._actionSave = QAction(self.tr("Save"), self)
self._actionSave.setObjectName("actionSave")
self._actionSave.setIcon(QIcon.fromTheme("document-save", QIcon(":/icons/actions/16/document-save.svg")))
self._actionSave.setShortcut(QKeySequence.Save)
self._actionSave.setToolTip(self.tr("Save document"))
self._actionSave.triggered.connect(self._onActionSaveTriggered)
self._actionSaveAs = QAction(self.tr("Save As…"), self)
self._actionSaveAs.setObjectName("actionSaveAs")
self._actionSaveAs.setIcon(QIcon.fromTheme("document-save-as", QIcon(":/icons/actions/16/document-save-as.svg")))
self._actionSaveAs.setShortcut(QKeySequence.SaveAs)
self._actionSaveAs.setToolTip(self.tr("Save document under a new name"))
self._actionSaveAs.triggered.connect(self._onActionSaveAsTriggered)
self._actionSaveAsDelimiterColon = QAction(self.tr("Colon"), self)
self._actionSaveAsDelimiterColon.setObjectName("actionSaveAsDelimiterColon")
self._actionSaveAsDelimiterColon.setCheckable(True)
self._actionSaveAsDelimiterColon.setToolTip(self.tr("Save document with colon as delimiter under a new name"))
self._actionSaveAsDelimiterColon.setData("colon")
self._actionSaveAsDelimiterColon.triggered.connect(lambda: self._onActionSaveAsDelimiterTriggered("colon") )
self._actionSaveAsDelimiterComma = QAction(self.tr("Comma"), self)
self._actionSaveAsDelimiterComma.setObjectName("actionSaveAsDelimiterComma")
self._actionSaveAsDelimiterComma.setCheckable(True)
self._actionSaveAsDelimiterComma.setToolTip(self.tr("Save document with comma as delimiter under a new name"))
self._actionSaveAsDelimiterComma.setData("comma")
self._actionSaveAsDelimiterComma.triggered.connect(lambda: self._onActionSaveAsDelimiterTriggered("comma") )
self._actionSaveAsDelimiterSemicolon = QAction(self.tr("Semicolon"), self)
self._actionSaveAsDelimiterSemicolon.setObjectName("actionSaveAsDelimiterSemicolon")
self._actionSaveAsDelimiterSemicolon.setCheckable(True)
self._actionSaveAsDelimiterSemicolon.setToolTip(self.tr("Save document with semicolon as delimiter under a new name"))
self._actionSaveAsDelimiterSemicolon.setData("semicolon")
self._actionSaveAsDelimiterSemicolon.triggered.connect(lambda: self._onActionSaveAsDelimiterTriggered("semicolon") )
self._actionSaveAsDelimiterTab = QAction(self.tr("Tab"), self)
self._actionSaveAsDelimiterTab.setObjectName("actionSaveAsDelimiterTab")
self._actionSaveAsDelimiterTab.setCheckable(True)
self._actionSaveAsDelimiterTab.setToolTip(self.tr("Save document with tab as delimiter under a new name"))
self._actionSaveAsDelimiterTab.setData("tab")
self._actionSaveAsDelimiterTab.triggered.connect(lambda: self._onActionSaveAsDelimiterTriggered("tab") )
self._actionSaveAsDelimiter = QActionGroup(self)
self._actionSaveAsDelimiter.setObjectName("actionSaveAsDelimiter")
self._actionSaveAsDelimiter.addAction(self._actionSaveAsDelimiterColon)
self._actionSaveAsDelimiter.addAction(self._actionSaveAsDelimiterComma)
self._actionSaveAsDelimiter.addAction(self._actionSaveAsDelimiterSemicolon)
self._actionSaveAsDelimiter.addAction(self._actionSaveAsDelimiterTab)
self._actionSaveCopyAs = QAction(self.tr("Save Copy As…"), self)
self._actionSaveCopyAs.setObjectName("actionSaveCopyAs")
self._actionSaveCopyAs.setIcon(QIcon.fromTheme("document-save-as", QIcon(":/icons/actions/16/document-save-as.svg")))
self._actionSaveCopyAs.setToolTip(self.tr("Save copy of document under a new name"))
self._actionSaveCopyAs.triggered.connect(self._onActionSaveCopyAsTriggered)
self._actionSaveAll = QAction(self.tr("Save All"), self)
self._actionSaveAll.setObjectName("actionSaveAll")
self._actionSaveAll.setIcon(QIcon.fromTheme("document-save-all", QIcon(":/icons/actions/16/document-save-all.svg")))
self._actionSaveAll.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_L))
self._actionSaveAll.setToolTip(self.tr("Save all documents"))
self._actionSaveAll.triggered.connect(self._onActionSaveAllTriggered)
self._actionClose = QAction(self.tr("Close"), self)
self._actionClose.setObjectName("actionClose")
self._actionClose.setIcon(QIcon.fromTheme("document-close", QIcon(":/icons/actions/16/document-close.svg")))
self._actionClose.setShortcut(QKeySequence.Close)
self._actionClose.setToolTip(self.tr("Close document"))
self._actionClose.triggered.connect(self._onActionCloseTriggered)
self._actionCloseOther = QAction(self.tr("Close Other"), self)
self._actionCloseOther.setObjectName("actionCloseOther")
self._actionCloseOther.setToolTip(self.tr("Close all other documents"))
self._actionCloseOther.triggered.connect(self._onActionCloseOtherTriggered)
self._actionCloseAll = QAction(self.tr("Close All"), self)
self._actionCloseAll.setObjectName("actionCloseAll")
self._actionCloseAll.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_W))
self._actionCloseAll.setToolTip(self.tr("Close all documents"))
self._actionCloseAll.triggered.connect(self._onActionCloseAllTriggered)
#
# Actions: View
self._actionFullScreen = QAction(self)
self._actionFullScreen.setObjectName("actionFullScreen")
self._actionFullScreen.setIconText(self.tr("Full Screen"))
self._actionFullScreen.setCheckable(True)
self._actionFullScreen.setShortcuts([QKeySequence(Qt.Key_F11), QKeySequence.FullScreen])
self._actionFullScreen.triggered.connect(self._onActionFullScreenTriggered)
self._actionTitlebarFullPath = QAction(self.tr("Show Path in Titlebar"), self)
self._actionTitlebarFullPath.setObjectName("actionTitlebarFullPath")
self._actionTitlebarFullPath.setCheckable(True)
self._actionTitlebarFullPath.setChecked(True)
self._actionTitlebarFullPath.setToolTip(self.tr("Display the full path of the document in the titlebar"))
self._actionTitlebarFullPath.triggered.connect(self._onActionTitlebarFullPathTriggered)
self._actionToolbarApplication = QAction(self.tr("Show Application Toolbar"), self)
self._actionToolbarApplication.setObjectName("actionToolbarApplication")
self._actionToolbarApplication.setCheckable(True)
self._actionToolbarApplication.setToolTip(self.tr("Display the Application toolbar"))
self._actionToolbarApplication.toggled.connect(lambda checked: self._toolbarApplication.setVisible(checked))
self._actionToolbarDocument = QAction(self.tr("Show Document Toolbar"), self)
self._actionToolbarDocument.setObjectName("actionToolbarDocument")
self._actionToolbarDocument.setCheckable(True)
self._actionToolbarDocument.setToolTip(self.tr("Display the Document toolbar"))
self._actionToolbarDocument.toggled.connect(lambda checked: self._toolbarDocument.setVisible(checked))
self._actionToolbarEdit = QAction(self.tr("Show Edit Toolbar"), self)
self._actionToolbarEdit.setObjectName("actionToolbarEdit")
self._actionToolbarEdit.setCheckable(True)
self._actionToolbarEdit.setToolTip(self.tr("Display the Edit toolbar"))
self._actionToolbarEdit.toggled.connect(lambda checked: self._toolbarEdit.setVisible(checked))
self._actionToolbarTools = QAction(self.tr("Show Tools Toolbar"), self)
self._actionToolbarTools.setObjectName("actionToolbarTools")
self._actionToolbarTools.setCheckable(True)
self._actionToolbarTools.setToolTip(self.tr("Display the Tools toolbar"))
self._actionToolbarTools.toggled.connect(lambda checked: self._toolbarTools.setVisible(checked))
self._actionToolbarView = QAction(self.tr("Show View Toolbar"), self)
self._actionToolbarView.setObjectName("actionToolbarView")
self._actionToolbarView.setCheckable(True)
self._actionToolbarView.setToolTip(self.tr("Display the View toolbar"))
self._actionToolbarView.toggled.connect(lambda checked: self._toolbarView.setVisible(checked))
self._actionToolbarHelp = QAction(self.tr("Show Help Toolbar"), self)
self._actionToolbarHelp.setObjectName("actionToolbarHelp")
self._actionToolbarHelp.setCheckable(True)
self._actionToolbarHelp.setToolTip(self.tr("Display the Help toolbar"))
self._actionToolbarHelp.toggled.connect(lambda checked: self._toolbarHelp.setVisible(checked))
#
# Actions: Help
self._actionKeyboardShortcuts = QAction(self.tr("Keyboard Shortcuts"), self)
self._actionKeyboardShortcuts.setObjectName("actionKeyboardShortcuts")
self._actionKeyboardShortcuts.setIcon(QIcon.fromTheme("help-keyboard-shortcuts", QIcon(":/icons/actions/16/help-keyboard-shortcuts.svg")))
self._actionKeyboardShortcuts.setIconText(self.tr("Shortcuts"))
self._actionKeyboardShortcuts.setToolTip(self.tr("List of all keyboard shortcuts"))
self._actionKeyboardShortcuts.triggered.connect(self._onActionKeyboardShortcutsTriggered)
def _createMenus(self):
# Menu: Application
menuApplication = self.menuBar().addMenu(self.tr("Application"))
menuApplication.setObjectName("menuApplication")
menuApplication.addAction(self._actionAbout)
menuApplication.addAction(self._actionColophon)
menuApplication.addSeparator()
menuApplication.addAction(self._actionPreferences)
menuApplication.addSeparator()
menuApplication.addAction(self._actionQuit)
#
# Menu: Document
self._menuOpenRecent = QMenu(self.tr("Open Recent"), self)
self._menuOpenRecent.setObjectName("menuOpenRecent")
self._menuOpenRecent.setIcon(QIcon.fromTheme("document-open-recent", QIcon(":/icons/actions/16/document-open-recent.svg")))
self._menuOpenRecent.setToolTip(self.tr("Open a document which was recently opened"))
self._menuSaveAsDelimiter = QMenu(self.tr("Save As with Delimiter…"), self)
self._menuSaveAsDelimiter.setObjectName("menuSaveAsDelimiter")
self._menuSaveAsDelimiter.setIcon(QIcon.fromTheme("document-save-as", QIcon(":/icons/actions/16/document-save-as.svg")))
self._menuSaveAsDelimiter.setToolTip(self.tr("Save document with specific delimiter under a new name"))
self._menuSaveAsDelimiter.addActions(self._actionSaveAsDelimiter.actions())
menuDocument = self.menuBar().addMenu(self.tr("Document"))
menuDocument.setObjectName("menuDocument")
menuDocument.addAction(self._actionNew)
menuDocument.addSeparator()
menuDocument.addAction(self._actionOpen)
menuDocument.addMenu(self._menuOpenRecent)
menuDocument.addSeparator()
menuDocument.addAction(self._actionSave)
menuDocument.addAction(self._actionSaveAs)
menuDocument.addMenu(self._menuSaveAsDelimiter)
menuDocument.addAction(self._actionSaveCopyAs)
menuDocument.addAction(self._actionSaveAll)
menuDocument.addSeparator()
menuDocument.addAction(self._actionClose)
menuDocument.addAction(self._actionCloseOther)
menuDocument.addAction(self._actionCloseAll)
# Menu: Edit
menuEdit = self.menuBar().addMenu(self.tr("Edit"))
menuEdit.setObjectName("menuEdit")
# Menu: Tools
menuTools = self.menuBar().addMenu(self.tr("Tools"))
menuTools.setObjectName("menuTools")
# Menu: View
menuView = self.menuBar().addMenu(self.tr("View"))
menuView.setObjectName("menuView")
menuView.addAction(self._actionFullScreen)
menuView.addSeparator()
menuView.addAction(self._actionTitlebarFullPath)
menuView.addSeparator()
menuView.addAction(self._actionToolbarApplication)
menuView.addAction(self._actionToolbarDocument)
menuView.addAction(self._actionToolbarEdit)
menuView.addAction(self._actionToolbarTools)
menuView.addAction(self._actionToolbarView)
menuView.addAction(self._actionToolbarHelp)
# Menu: Help
menuHelp = self.menuBar().addMenu(self.tr("Help"))
menuHelp.setObjectName("menuHelp")
menuHelp.addAction(self._actionKeyboardShortcuts)
def _createToolBars(self):
# Toolbar: Application
self._toolbarApplication = self.addToolBar(self.tr("Application Toolbar"))
self._toolbarApplication.setObjectName("toolbarApplication")
self._toolbarApplication.addAction(self._actionAbout)
self._toolbarApplication.addAction(self._actionPreferences)
self._toolbarApplication.addSeparator()
self._toolbarApplication.addAction(self._actionQuit)
self._toolbarApplication.visibilityChanged.connect(lambda visible: self._actionToolbarApplication.setChecked(visible))
# Toolbar: Document
self._toolbarDocument = self.addToolBar(self.tr("Document Toolbar"))
self._toolbarDocument.setObjectName("toolbarDocument")
self._toolbarDocument.addAction(self._actionNew)
self._toolbarDocument.addAction(self._actionOpen)
self._toolbarDocument.addSeparator()
self._toolbarDocument.addAction(self._actionSave)
self._toolbarDocument.addAction(self._actionSaveAs)
self._toolbarDocument.addSeparator()
self._toolbarDocument.addAction(self._actionClose)
self._toolbarDocument.visibilityChanged.connect(lambda visible: self._actionToolbarDocument.setChecked(visible))
# Toolbar: Edit
self._toolbarEdit = self.addToolBar(self.tr("Edit Toolbar"))
self._toolbarEdit.setObjectName("toolbarEdit")
self._toolbarEdit.visibilityChanged.connect(lambda visible: self._actionToolbarEdit.setChecked(visible))
# Toolbar: Tools
self._toolbarTools = self.addToolBar(self.tr("Tools Toolbar"))
self._toolbarTools.setObjectName("toolbarTools")
self._toolbarTools.visibilityChanged.connect(lambda visible: self._actionToolbarTools.setChecked(visible))
# Toolbar: View
self._toolbarView = self.addToolBar(self.tr("View Toolbar"))
self._toolbarView.setObjectName("toolbarView")
self._toolbarView.addAction(self._actionFullScreen)
self._toolbarView.visibilityChanged.connect(lambda visible: self._actionToolbarView.setChecked(visible))
# Toolbar: Help
self._toolbarHelp = self.addToolBar(self.tr("Help Toolbar"))
self._toolbarHelp.setObjectName("toolbarHelp")
self._toolbarHelp.addAction(self._actionKeyboardShortcuts)
self._toolbarHelp.visibilityChanged.connect(lambda visible: self._actionToolbarHelp.setChecked(visible))
def _updateActions(self, subWindowCount=0):
hasDocument = subWindowCount >= 1
hasDocuments = subWindowCount >= 2
# Actions: Document
self._actionSave.setEnabled(hasDocument)
self._actionSaveAs.setEnabled(hasDocument)
self._menuSaveAsDelimiter.setEnabled(hasDocument)
self._actionSaveCopyAs.setEnabled(hasDocument)
self._actionSaveAll.setEnabled(hasDocument)
self._actionClose.setEnabled(hasDocument)
self._actionCloseOther.setEnabled(hasDocuments)
self._actionCloseAll.setEnabled(hasDocument)
def _updateActionFullScreen(self):
if not self.isFullScreen():
self._actionFullScreen.setText(self.tr("Full Screen Mode"))
self._actionFullScreen.setIcon(QIcon.fromTheme("view-fullscreen", QIcon(":/icons/actions/16/view-fullscreen.svg")))
self._actionFullScreen.setChecked(False)
self._actionFullScreen.setToolTip(self.tr("Display the window in full screen"))
else:
self._actionFullScreen.setText(self.tr("Exit Full Screen Mode"))
self._actionFullScreen.setIcon(QIcon.fromTheme("view-restore", QIcon(":/icons/actions/16/view-restore.svg")))
self._actionFullScreen.setChecked(True)
self._actionFullScreen.setToolTip(self.tr("Exit the full screen mode"))
def _updateActionRecentDocuments(self):
# Add items to the list, if necessary
for idx in range(len(self._actionRecentDocuments)+1, self._preferences.maximumRecentDocuments()+1):
actionRecentDocument = QAction(self)
actionRecentDocument.setObjectName(f"actionRecentDocument_{idx}")
actionRecentDocument.triggered.connect(lambda data=actionRecentDocument.data(): self._onActionOpenRecentDocumentTriggered(data))
self._actionRecentDocuments.append(actionRecentDocument)
# Remove items from the list, if necessary
while len(self._actionRecentDocuments) > self._preferences.maximumRecentDocuments():
self._actionRecentDocuments.pop()
# Update items
for idx in range(len(self._actionRecentDocuments)):
text = None
data = None
show = False
if idx < len(self._recentDocuments):
text = self.tr("{0} [{1}]").format(QFileInfo(self._recentDocuments[idx]).fileName(), self._recentDocuments[idx])
data = self._recentDocuments[idx]
show = True
self._actionRecentDocuments[idx].setText(text)
self._actionRecentDocuments[idx].setData(data)
self._actionRecentDocuments[idx].setVisible(show)
def _updateMenuOpenRecent(self):
self._menuOpenRecent.clear()
if self._preferences.maximumRecentDocuments() > 0:
# Document list wanted; show the menu
self._menuOpenRecent.menuAction().setVisible(True)
if len(self._recentDocuments) > 0:
# Document list has items; enable the menu
self._menuOpenRecent.setEnabled(True)
self._menuOpenRecent.addActions(self._actionRecentDocuments)
self._menuOpenRecent.addSeparator()
self._menuOpenRecent.addAction(self._actionOpenRecentClear)
else:
# Document list is empty; disable the menu
self._menuOpenRecent.setEnabled(False)
else:
# No document list wanted; hide the menu
self._menuOpenRecent.menuAction().setVisible(False)
def _updateTitleBar(self):
title = None
document = self._activeDocument()
if document:
title = document.canonicalName() if self._actionTitlebarFullPath.isChecked() and document.canonicalName() else document.documentTitle()
self.setWindowTitle(title)
def _onActionAboutTriggered(self):
dialog = AboutDialog(self)
dialog.exec_()
def _onActionColophonTriggered(self):
dialog = ColophonDialog(self)
dialog.exec_()
def _onActionPreferencesTriggered(self):
dialog = PreferencesDialog(self)
dialog.setPreferences(self._preferences)
dialog.exec_()
self._preferences = dialog.preferences()
self._updateRecentDocuments(None)
self._updateMenuOpenRecent()
def _onActionNewTriggered(self):
self._loadDocument("")
def _onActionOpenTriggered(self):
fileNames = QFileDialog.getOpenFileNames(self, self.tr("Open Document"),
QStandardPaths.writableLocation(QStandardPaths.HomeLocation),
self.tr("CSV Files (*.csv);;All Files (*.*)"))[0]
for fileName in fileNames:
self._openDocument(fileName)
def _onActionOpenRecentDocumentTriggered(self, canonicalName):
pass
# self.openDocument(canonicalName)
def _onActionOpenRecentClearTriggered(self):
self._recentDocuments.clear()
self._updateRecentDocuments(None)
self._updateMenuOpenRecent()
def _onActionSaveTriggered(self):
pass
def _onActionSaveAsTriggered(self):
pass
def _onActionSaveAsDelimiterTriggered(self, delimiter):
pass
def _onActionSaveCopyAsTriggered(self):
pass
def _onActionSaveAllTriggered(self):
pass
def _onActionCloseTriggered(self):
self._documentArea.closeActiveSubWindow()
def _onActionCloseOtherTriggered(self):
for subWindow in self._documentArea.subWindowList():
if subWindow != self._documentArea.activeSubWindow():
subWindow.close()
def _onActionCloseAllTriggered(self):
self._documentArea.closeAllSubWindows()
def _onActionFullScreenTriggered(self):
if not self.isFullScreen():
self.setWindowState(self.windowState() | Qt.WindowFullScreen)
else:
self.setWindowState(self.windowState() & ~Qt.WindowFullScreen)
self._updateActionFullScreen()
def _onActionTitlebarFullPathTriggered(self):
self._updateTitleBar()
def _onActionKeyboardShortcutsTriggered(self):
if not self._keyboardShortcutsDialog:
self._keyboardShortcutsDialog = KeyboardShortcutsDialog(self)
self._keyboardShortcutsDialog.show()
self._keyboardShortcutsDialog.raise_()
self._keyboardShortcutsDialog.activateWindow()
def _onDocumentWindowActivated(self, subWindow):
# Update the application window
self._updateActions(len(self._documentArea.subWindowList()))
self._updateTitleBar()
if not subWindow:
return
def _onDocumentAboutToClose(self, canonicalName):
# Workaround to show subwindows always maximized
for subWindow in self._documentArea.subWindowList():
if not subWindow.isMaximized():
subWindow.showMaximized()
# Update menu items without the emitter
self._updateActions(len(self._documentArea.subWindowList()) - 1)
def _createDocument(self):
document = Document()
document.setPreferences(self._preferences)
document.aboutToClose.connect(self._onDocumentAboutToClose)
subWindow = self._documentArea.addSubWindow(document)
subWindow.setWindowIcon(QIcon())
subWindow.showMaximized()
return document
def _createDocumentIndex(self, canonicalName):
fileName = QFileInfo(canonicalName).fileName()
canonicalIndex = 0
for subWindow in self._documentArea.subWindowList():
if QFileInfo(subWindow.widget().canonicalName()).fileName() == fileName:
if subWindow.widget().canonicalIndex() > canonicalIndex:
canonicalIndex = subWindow.widget().canonicalIndex()
return canonicalIndex + 1
def _findDocumentWindow(self, canonicalName):
for subWindow in self._documentArea.subWindowList():
if subWindow.widget().canonicalName() == canonicalName:
return subWindow
return None
def _activeDocument(self):
subWindow = self._documentArea.activeSubWindow()
return subWindow.widget() if subWindow else None
def _openDocument(self, fileName):
canonicalName = QFileInfo(fileName).canonicalFilePath()
subWindow = self._findDocumentWindow(canonicalName)
if subWindow:
# Given document is already loaded; activate the subwindow
self._documentArea.setActiveSubWindow(subWindow)
# Update list of recent documents
self._updateRecentDocuments(canonicalName)
self._updateMenuOpenRecent()
return True
return self._loadDocument(canonicalName);
def _loadDocument(self, canonicalName):
document = self._createDocument()
succeeded = document.load(canonicalName)
if succeeded:
document.setCanonicalIndex(self._createDocumentIndex(canonicalName))
document.updateDocumentTitle()
document.show()
# Update list of recent documents
self._updateRecentDocuments(canonicalName)
self._updateMenuOpenRecent()
# Update the application window
self._updateActions(len(self._documentArea.subWindowList()))
self._updateTitleBar()
else:
document.close()
return succeeded
def _updateRecentDocuments(self, canonicalName):
if canonicalName:
while canonicalName in self._recentDocuments:
self._recentDocuments.remove(canonicalName)
self._recentDocuments.insert(0, canonicalName)
# Remove items from the list, if necessary
while len(self._recentDocuments) > self._preferences.maximumRecentDocuments():
self._recentDocuments.pop()
self._updateActionRecentDocuments()
def init_ui(self):
self.setWindowTitle('Trace Event Window')
self.setGeometry(100, 100, 800, 600)
bar = self.menuBar()
file_ = bar.addMenu('File')
export_log = QAction('Save to File',
self,
triggered=lambda: self.save_log())
options = bar.addMenu('Options')
auto_refresh = QAction(
'Auto Refresh',
self,
checkable=True,
triggered=lambda: self.timer.start(100)
if auto_refresh.isChecked() else self.timer.stop())
auto_refresh.setChecked(True)
options.addAction(auto_refresh)
file_.addAction(export_log)
vgrid = QVBoxLayout()
grid = QHBoxLayout()
self.tree = QTreeWidget()
self.tree.setHeaderLabels(['Name'])
self.top = []
self.lst = []
for n, event in enumerate(self.trace_events):
word = event.split('_')[0]
if word not in self.top:
self.top.append(word)
item = QTreeWidgetItem(self.tree)
self.lst.append(item)
item.setText(0, word)
subitem = QTreeWidgetItem(item)
subitem.setText(0, ' ' + event.split(' : ')[0])
# subitem.setCheckState(0, Qt.Unchecked)
cbox = QCheckBox()
cbox.stateChanged.connect(lambda state, text=subitem.text(0): self.
handle_checked(state, text))
self.tree.setItemWidget(subitem, 0, cbox)
# self.tree.setColumnWidth(0, 25)
self.tracelist = QLabel()
self.disp_output()
self.traceview = QScrollArea()
self.traceview.setWidget(self.tracelist)
self.traceview.setWidgetResizable(True)
search = QHBoxLayout()
self.search_bar = QLineEdit(self)
self.completer = QCompleter(self.top, self)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.search_bar.setCompleter(self.completer)
search_button = QPushButton('Search')
search_button.clicked.connect(lambda: self.tree.setCurrentItem(
self.lst[self.top.index(self.search_bar.text())]))
expand = QPushButton('▼')
expand.setFixedSize(QSize(25, 25))
expand.clicked.connect(lambda: self.tree.expandAll())
collapse = QPushButton('▲')
collapse.setFixedSize(QSize(25, 25))
collapse.clicked.connect(lambda: self.tree.collapseAll())
self.search_bar.returnPressed.connect(lambda: search_button.click())
search.addWidget(self.search_bar)
search.addWidget(search_button)
search.addWidget(expand)
search.addWidget(collapse)
self.digest = QLabel()
vgrid.addLayout(search)
vgrid.addWidget(self.tree)
vgridwid = QWidget()
vgridwid.setLayout(vgrid)
split = QSplitter(Qt.Horizontal)
split.addWidget(vgridwid)
split.addWidget(self.traceview)
split.setStretchFactor(1, 1)
# grid.addLayout(vgrid)
grid.addWidget(split)
# grid.addWidget(self.tracelist)
self.disp_output()
center = QWidget()
center.setLayout(grid)
self.setCentralWidget(center)
self.show()
def _on_theme_changed(self, action: QAction, new_theme: str):
if action.isChecked():
locator.get_static("SettingsService").set_theme(new_theme)
self.theme_info_dialog.exec_()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.settings_tree = SettingsTree()
self.setCentralWidget(self.settings_tree)
self.location_dialog = None
self.create_actions()
self.create_menus()
self.auto_refresh_action.setChecked(True)
self.fallbacks_action.setChecked(True)
self.setWindowTitle("Settings Editor")
self.resize(500, 600)
def open_settings(self):
if self.location_dialog is None:
self.location_dialog = LocationDialog(self)
if self.location_dialog.exec_():
settings = QSettings(self.location_dialog.format(),
self.location_dialog.scope(),
self.location_dialog.organization(),
self.location_dialog.application())
self.set_settings_object(settings)
self.fallbacks_action.setEnabled(True)
def open_inifile(self):
file_name, _ = QFileDialog.getOpenFileName(self, "Open INI File",
'', "INI Files (*.ini *.conf)")
if file_name:
self.load_ini_file(file_name)
def load_ini_file(self, file_name):
settings = QSettings(file_name, QSettings.IniFormat)
if settings.status() != QSettings.NoError:
return
self.set_settings_object(settings)
self.fallbacks_action.setEnabled(False)
def open_property_list(self):
file_name, _ = QFileDialog.getOpenFileName(self,
"Open Property List", '', "Property List Files (*.plist)")
if file_name:
settings = QSettings(file_name, QSettings.NativeFormat)
self.set_settings_object(settings)
self.fallbacks_action.setEnabled(False)
def open_registry_path(self):
path, ok = QInputDialog.getText(self, "Open Registry Path",
"Enter the path in the Windows registry:",
QLineEdit.Normal, 'HKEY_CURRENT_USER\\')
if ok and path != '':
settings = QSettings(path, QSettings.NativeFormat)
self.set_settings_object(settings)
self.fallbacks_action.setEnabled(False)
def about(self):
QMessageBox.about(self, "About Settings Editor",
"The <b>Settings Editor</b> example shows how to access "
"application settings using Qt.")
def create_actions(self):
self.open_settings_action = QAction("&Open Application Settings...",
self, shortcut="Ctrl+O", triggered=self.open_settings)
self.open_ini_file_action = QAction("Open I&NI File...", self,
shortcut="Ctrl+N", triggered=self.open_inifile)
self.open_property_list_action = QAction("Open macOS &Property List...",
self, shortcut="Ctrl+P", triggered=self.open_property_list)
if sys.platform != 'darwin':
self.open_property_list_action.setEnabled(False)
self.open_registry_path_action = QAction(
"Open Windows &Registry Path...", self, shortcut="Ctrl+G",
triggered=self.open_registry_path)
if sys.platform != 'win32':
self.open_registry_path_action.setEnabled(False)
self.refresh_action = QAction("&Refresh", self, shortcut="Ctrl+R",
enabled=False, triggered=self.settings_tree.refresh)
self.exit_action = QAction("E&xit", self, shortcut="Ctrl+Q",
triggered=self.close)
self.auto_refresh_action = QAction("&Auto-Refresh", self,
shortcut="Ctrl+A", checkable=True, enabled=False)
self.auto_refresh_action.triggered[bool].connect(self.settings_tree.set_auto_refresh)
self.auto_refresh_action.triggered[bool].connect(self.refresh_action.setDisabled)
self.fallbacks_action = QAction("&Fallbacks", self,
shortcut="Ctrl+F", checkable=True, enabled=False)
self.fallbacks_action.triggered[bool].connect(self.settings_tree.set_fallbacks_enabled)
self.about_action = QAction("&About", self, triggered=self.about)
self.about_Qt_action = QAction("About &Qt", self,
triggered=qApp.aboutQt)
def create_menus(self):
self.file_menu = self.menuBar().addMenu("&File")
self.file_menu.addAction(self.open_settings_action)
self.file_menu.addAction(self.open_ini_file_action)
self.file_menu.addAction(self.open_property_list_action)
self.file_menu.addAction(self.open_registry_path_action)
self.file_menu.addSeparator()
self.file_menu.addAction(self.refresh_action)
self.file_menu.addSeparator()
self.file_menu.addAction(self.exit_action)
self.options_menu = self.menuBar().addMenu("&Options")
self.options_menu.addAction(self.auto_refresh_action)
self.options_menu.addAction(self.fallbacks_action)
self.menuBar().addSeparator()
self.help_menu = self.menuBar().addMenu("&Help")
self.help_menu.addAction(self.about_action)
self.help_menu.addAction(self.about_Qt_action)
def set_settings_object(self, settings):
settings.setFallbacksEnabled(self.fallbacks_action.isChecked())
self.settings_tree.set_settings_object(settings)
self.refresh_action.setEnabled(True)
self.auto_refresh_action.setEnabled(True)
nice_name = QDir.fromNativeSeparators(settings.fileName())
nice_name = nice_name.split('/')[-1]
if not settings.isWritable():
nice_name += " (read only)"
self.setWindowTitle("{} - Settings Editor".format(nice_name))
class mainWindow(QObject):
signalRun = Signal(SpiderThread)
signalRunApi = Signal(apiTester)
def __init__(self):
QObject.__init__(self) # must init parent QObject,if you want to use signal
self.widget = QWidget()
self.ipLabel = QLabel(self.widget)
self.thread = QThread()
self.worker = Worker()
self.worker.moveToThread(self.thread)
self.man = SpiderThread()
self.api = apiTester()
# 1 2:loop 3: time
self.testStatus = [False,1,0,"ip","mac"]
# advance config
self.findCoreStop = True
self.cleanCacheSet = False
self.useApiTest = False
self.showTestProgress = True
self.saveTestLog = False
self.saveLogPath = ""
self.chromePath = ""
self.showChrome = False
self.coreDumpPath = ""
# ui form
self.passwordLabel = QLabel(self.widget)
self.ipLineEdit = QLineEdit(self.widget)
self.passwordLineEdit = QLineEdit(self.widget)
self.startBtn = QPushButton(self.widget)
self.stopBtn = QPushButton(self.widget)
self.messageBox = QTextEdit(self.widget)
self.messageBox.setReadOnly(True)
self.userLabel = QLabel(self.widget)
self.userLineEdit = QLineEdit(self.widget)
self.intervalLabel = QLabel(self.widget)
self.intervalSpinBox = QSpinBox(self.widget)
self.loopLabel = QLabel(self.widget)
self.loopSpinBox = QSpinBox(self.widget)
self.intervalSpinBox.setRange(0,9999)
self.loopSpinBox.setRange(1,9999)
self.radioReboot = QRadioButton(self.widget)
self.radioProvision = QRadioButton(self.widget)
self.radioFactory = QRadioButton(self.widget)
# self.apiCheckBox = QCheckBox(self.widget)
self.menu = QMenu()
self.gxpAction = QAction("Classic UI")
self.grp2602Action = QAction("Ant Design UI")
self.gxpAction.setCheckable(True)
self.grp2602Action.setCheckable(True)
self.menu.addAction(self.gxpAction)
self.menu.addAction(self.grp2602Action)
self.webLabel = QLabel(self.widget)
self.webBtn = QPushButton(self.widget)
self.webBtn.setMenu(self.menu)
self.clearBtn = QPushButton(self.widget)
self.messageList = deque()
self.timer = QTimer()
self.advanceBtn = QPushButton(self.widget)
self.infoLabel = QLabel(self.widget)
# provision widget
self.provWidget = QWidget(self.widget)
self.ver1Label = QLabel(self.provWidget)
self.ver2Label = QLabel(self.provWidget)
self.ver3Label = QLabel(self.provWidget)
self.ver1LineEdit = QLineEdit(self.provWidget)
self.ver2LineEdit = QLineEdit(self.provWidget)
self.ver3LineEdit = QLineEdit(self.provWidget)
self.dir1Label = QLabel(self.provWidget)
self.dir2Label = QLabel(self.provWidget)
self.dir3Label = QLabel(self.provWidget)
self.dir1LineEdit = QLineEdit(self.provWidget)
self.dir2LineEdit = QLineEdit(self.provWidget)
self.dir3LineEdit = QLineEdit(self.provWidget)
self.radioHttp = QRadioButton(self.provWidget)
self.radioHttps = QRadioButton(self.provWidget)
self.radioTftp = QRadioButton(self.provWidget)
self.radioFtp = QRadioButton(self.provWidget)
self.radioFtps = QRadioButton(self.provWidget)
self.radioWindow = QRadioButton(self.provWidget)
# advance widget
self.advanceWidget = QWidget()
self.checkCoreBox = QCheckBox(self.advanceWidget)
self.cleanCache = QCheckBox(self.advanceWidget)
self.checkSaveLogBox = QCheckBox(self.advanceWidget)
self.selectDirBtn = QPushButton(self.advanceWidget)
self.saveDirLabel = QLabel(self.advanceWidget)
self.saveDirLabel.setStyleSheet("background:white")
self.checkProgressBox = QCheckBox(self.advanceWidget)
self.advanceOkBtn = QPushButton(self.advanceWidget)
self.selectChromeBtn = QPushButton(self.advanceWidget)
self.chromePathLabel = QLabel(self.advanceWidget)
self.chromePathLabel.setStyleSheet("background:white")
self.checkShowChromeBox = QCheckBox(self.advanceWidget)
self.chromeLabel = QLabel(self.advanceWidget)
self.pcapLabel = QLabel(self.advanceWidget)
self.apiCheckBox = QCheckBox(self.advanceWidget)
self.corePathLabel = QLabel(self.advanceWidget)
self.corePathLabel.setStyleSheet("background:white")
self.corePathBtn = QPushButton(self.advanceWidget)
self.interfaceMenu = QComboBox(self.advanceWidget)
self.interfaceMenu.addItem('Default')
self.aiOptionBox= QCheckBox(self.advanceWidget)
a = IFACES
print(a)
for i in a.keys():
print(a[i].description)
self.interfaceMenu.addItem(a[i].description)
# connect singal and slot
self.startBtn.clicked.connect(self.clickedStarBtn)
self.radioProvision.clicked.connect(self.clickedProvision)
self.radioReboot.clicked.connect(self.clickedOthers)
self.radioFactory.clicked.connect(self.clickedOthers)
self.stopBtn.clicked.connect(self.clickedStopBtn)
self.grp2602Action.triggered.connect(self.clickedGrp2602)
self.gxpAction.triggered.connect(self.clickedGxpType)
self.timer.timeout.connect(self.updateMessage)
self.apiCheckBox.stateChanged.connect(self.apiTestBoxCheck)
self.clearBtn.clicked.connect(self.clickedClearBtn)
self.advanceBtn.clicked.connect(self.clickedAdvanceBtn)
self.advanceOkBtn.clicked.connect(self.clickedAdvanceOkBtn)
self.checkSaveLogBox.stateChanged.connect(self.saveLogBoxCheck)
self.selectChromeBtn.clicked.connect(self.clickedSelectChromeBtn)
self.selectDirBtn.clicked.connect(self.clickedSelectDirBtn)
self.corePathBtn.clicked.connect(self.clickedCorePathBtn)
self.worker.signalJobEnd.connect(self.slotTestStoped)
self.worker.apiTestFinished.connect(self.slotTestStoped)
self.signalRun.connect(self.worker.dowork)
self.signalRunApi.connect(self.worker.doworkApi)
# self.man.signalUpdateMessage.connect(self.pushMessage)
def setupUI(self):
# set text content /value
self.widget.setWindowTitle("自动重启升降级测试工具")
self.ipLabel.setText("初始IP:")
self.passwordLabel.setText("密码:")
self.startBtn.setText("开始测试")
self.stopBtn.setText("停止测试")
self.userLabel.setText("用户名:")
self.intervalLabel.setText("间隔时间:")
self.loopLabel.setText("测试次数:")
self.intervalSpinBox.setValue(130)
self.radioFactory.setText("恢复出厂")
self.radioProvision.setText("升降级")
self.radioReboot.setText("重启")
self.ver1Label.setText("版本 1:")
self.ver2Label.setText("版本 2:")
self.ver3Label.setText("版本 3:")
self.dir1Label.setText("路径 1:")
self.dir2Label.setText("路径 2:")
self.dir3Label.setText("路径 3:")
self.radioHttp.setText("Http")
self.radioHttps.setText("Https")
self.radioTftp.setText("Tftp")
self.radioFtp.setText("Ftp")
self.radioFtps.setText("Ftps")
self.apiCheckBox.setText("使用API测试，配置CoreDump下载路径")
self.webLabel.setText("网页类型:")
self.webBtn.setText("请选择UI类型")
self.clearBtn.setText("清空输入")
self.advanceWidget.setWindowTitle("高级设置")
self.advanceBtn.setText("高级设置")
self.checkCoreBox.setText("发现Core Dump时停止测试")
self.cleanCache.setText("清除页面cache")
self.checkSaveLogBox.setText("保存测试日志")
self.selectDirBtn.setText("浏览")
self.checkProgressBox.setText("显示底部状态条")
self.advanceOkBtn.setText("OK")
self.checkShowChromeBox.setText("测试时显示Chrome浏览器")
self.selectChromeBtn.setText("浏览")
self.chromeLabel.setText("Chrome浏览器路径")
self.infoLabel.setText("未开始测试")
self.pcapLabel.setText("Net Interface")
self.corePathBtn.setText("浏览")
self.radioWindow.setText("网页拖拽文件")
# self.aiOptionBox.setText("AI")
#init value
self.saveDirLabel.hide()
self.selectDirBtn.hide()
self.gxpAction.setChecked(True)
self.radioReboot.click()
self.radioHttp.click()
self.stopBtn.setEnabled(False)
self.passwordLineEdit.setEchoMode(QLineEdit.PasswordEchoOnEdit)
# set position-------------------------------
xPos = 20
yPos = 30
colum2 = xPos +200
# line 1
self.ipLabel.move(xPos,yPos)
self.intervalLabel.move(colum2,yPos)
self.intervalSpinBox.move(colum2+60,yPos-2)
self.ipLineEdit.move(xPos+50,yPos-2)
# line 2
line2 = yPos +40
self.passwordLabel.move(xPos,line2)
self.passwordLineEdit.move(xPos+50,line2-2)
self.loopLabel.move(colum2,line2)
self.loopSpinBox.move(colum2+60,line2-2)
# line3
line3 = yPos +80
self.userLabel.move(xPos,line3)
self.userLineEdit.move(xPos+50,line3-2)
self.radioReboot.move(colum2,line3)
self.radioFactory.move(colum2+60,line3)
self.radioProvision.move(colum2,line3+30)
self.webLabel.move(xPos,line3+40)
self.webBtn.move(xPos+60,line3+35)
# provWidget
self.provWidget.resize(400,130)
self.provWidget.move(xPos,line3+70)
spaceY = 30
x = 0
y = 0
cl = 200
self.ver1Label.move(x,y)
self.ver1LineEdit.move(x+50,y)
self.ver2Label.move(x,y+spaceY)
self.ver2LineEdit.move(x+50,y+spaceY)
self.ver3Label.move(x,y+spaceY*2)
self.ver3LineEdit.move(x+50,y+spaceY*2)
self.dir1Label.move(cl,y)
self.dir1LineEdit.move(cl+50,y)
self.dir2Label.move(cl,y+spaceY)
self.dir2LineEdit.move(cl+50,y+spaceY)
self.dir3Label.move(cl,y+spaceY*2)
self.dir3LineEdit.move(cl+50,y+spaceY*2)
self.radioHttp.move(x,y+spaceY*3)
self.radioHttps.move(x+50,y+spaceY*3)
self.radioTftp.move(x+110,y+spaceY*3)
self.radioFtp.move(x+160,y+spaceY*3)
self.radioFtps.move(x+210,y+spaceY*3)
self.radioWindow.move(x+265,y+spaceY*3)
# advance widget
self.advanceWidget.resize(300,400)
x = 20
y = 20
space = 30
self.checkCoreBox.move(x,y)
self.cleanCache.move(x,y+space)
self.checkProgressBox.move(x,y+space*2)
self.checkShowChromeBox.move(x,y+space*3)
self.apiCheckBox.move(x,y+space*4)
self.corePathBtn.move(x-2,y+space*5-8)
self.corePathLabel.move(x+35,y+space*5-8)
y += 40
self.chromeLabel.move(x,y+space*4+10)
self.selectChromeBtn.move(x-2,y+space*5)
self.chromePathLabel.move(x+35,y+space*5+2)
self.checkSaveLogBox.move(x,y+space*6+10)
self.selectDirBtn.move(x-2,y+space*7)
self.saveDirLabel.move(x+35,y+space*7+2)
self.advanceOkBtn.move(x+170,y+space*10+10)
self.interfaceMenu.move(x-5,y+space*8+10)
self.pcapLabel.move(x,y+space*8-2)
# self.aiOptionBox.move(x, y+space*9+8)
# set size
self.messageBox.resize(373,155)
# self.widget.resize(410,400)
self.loopSpinBox.resize(60,25)
self.intervalSpinBox.resize(60,25)
self.webBtn.resize(100,25)
self.saveDirLabel.resize(185,22)
self.selectDirBtn.resize(32,24)
self.selectChromeBtn.resize(32,24)
self.chromePathLabel.resize(185,22)
self.infoLabel.resize(400, 25)
self.corePathBtn.resize(32,24)
self.corePathLabel.resize(185,22)
#
self.provWidget.hide()
self.changePosition(True)
self.widget.show()
self.loadCache()
# ----------------end of setupUI ---------------------
def changePosition(self,hide):
xPos = 20
if hide:
buttonLine = 200
self.widget.resize(420,415)
else:
buttonLine = 310
self.widget.resize(420,524)
self.startBtn.move(xPos,buttonLine)
self.stopBtn.move(xPos+90,buttonLine)
self.clearBtn.move(xPos+180,buttonLine)
self.advanceBtn.move(xPos+270,buttonLine)
self.messageBox.move(xPos,buttonLine+30)
boxH = self.messageBox.height()
self.infoLabel.move(xPos,buttonLine+boxH+35)
def setItemEnable(self,enable):
self.provWidget.setEnabled(enable)
self.ipLineEdit.setEnabled(enable)
self.passwordLineEdit.setEnabled(enable)
self.userLineEdit.setEnabled(enable)
self.intervalSpinBox.setEnabled(enable)
self.loopSpinBox.setEnabled(enable)
self.radioFactory.setEnabled(enable)
self.radioReboot.setEnabled(enable)
self.radioProvision.setEnabled(enable)
self.advanceBtn.setEnabled(enable)
self.startBtn.setEnabled(enable)
self.clearBtn.setEnabled(enable)
if self.useApiTest:
self.webBtn.setEnabled(False)
else:
self.webBtn.setEnabled(enable)
self.stopBtn.setEnabled(not enable)
def outputError(self,str):
appstr = "<span style=\"color:red\">"
appstr += str + "</span>"
self.messageBox.append(appstr)
def outputWarning(self,str):
appstr = "<span style=\"color:orange\">"
appstr += str + "</span>"
self.messageBox.append(appstr)
def loadCache(self):
file = QFile("cache")
if not file.open(QIODevice.ReadOnly | QIODevice.Text):
return
inStream = QTextStream(file)
# ip
self.ipLineEdit.setText(inStream.readLine())
# passwordLabel
self.passwordLineEdit.setText(inStream.readLine())
# user
self.userLineEdit.setText(inStream.readLine())
# ver1
self.ver1LineEdit.setText(inStream.readLine())
self.dir1LineEdit.setText(inStream.readLine())
# ver2
self.ver2LineEdit.setText(inStream.readLine())
self.dir2LineEdit.setText(inStream.readLine())
# ver3
self.ver3LineEdit.setText(inStream.readLine())
self.dir3LineEdit.setText(inStream.readLine())
self.intervalSpinBox.setValue(int(inStream.readLine()))
self.loopSpinBox.setValue(int(inStream.readLine()))
# web type button
webType = inStream.readLine()
if webType == "gxpAction":
self.grp2602Action.setChecked(False)
self.gxpAction.setChecked(True)
self.webBtn.setText(self.gxpAction.text())
else:
self.grp2602Action.setChecked(True)
self.gxpAction.setChecked(False)
self.webBtn.setText(self.grp2602Action.text())
testType = inStream.readLine()
if testType == "reboot":
self.radioReboot.setChecked(True)
elif testType == "provision":
self.radioProvision.setChecked(True)
self.changePosition(False)
self.provWidget.show()
else:
self.radioFactory.setChecked(True)
serverType = inStream.readLine()
if serverType == "Http":
self.radioHttp.setChecked(True)
elif serverType == "Https":
self.radioHttps.setChecked(True)
elif serverType == "Tftp":
self.radioTftp.setChecked(True)
elif serverType == "Ftp":
self.radioFtp.setChecked(True)
elif serverType == "Ftps":
self.radioFtps.setChecked(True)
else:
self.radioWindow.setChecked(True)
if inStream.readLine() == "True":
self.findCoreStop = True
else:
self.findCoreStop = False
if inStream.readLine() == "True":
self.cleanCacheSet = True
else:
self.cleanCacheSet = False
if inStream.readLine() == "True":
self.useApiTest = True
self.webBtn.setEnabled(False)
else:
self.useApiTest = False
self.corePathBtn.hide()
self.corePathLabel.hide()
if inStream.readLine() == "True":
self.showTestProgress = True
else:
self.showTestProgress = False
self.infoLabel.hide()
if inStream.readLine() == "True":
self.showChrome = True
else:
self.showChrome = False
self.chromePath = inStream.readLine()
if inStream.readLine() == "True":
self.saveTestLog = True
else:
self.saveTestLog = False
self.saveLogPath = inStream.readLine()
self.coreDumpPath = inStream.readLine()
file.close()
def saveCache(self):
file = QFile("cache")
if not file.open(QIODevice.WriteOnly):
return
content = self.ipLineEdit.text() + "\n"
content += self.passwordLineEdit.text() + "\n"
content += self.userLineEdit.text() + "\n"
content += self.ver1LineEdit.text() + "\n"
content += self.dir1LineEdit.text() + "\n"
content += self.ver2LineEdit.text() + "\n"
content += self.dir2LineEdit.text() + "\n"
content += self.ver3LineEdit.text() + "\n"
content += self.dir3LineEdit.text() + "\n"
content += str(self.intervalSpinBox.value()) + "\n"
content += str(self.loopSpinBox.value()) + "\n"
if self.gxpAction.isChecked():
content += "gxpAction\n"
else:
content += "grp2602Action\n"
if self.radioReboot.isChecked():
content += "reboot\n"
elif self.radioProvision.isChecked():
content += "provision\n"
else:
content += "factory\n"
if self.radioHttp.isChecked():
content += "Http\n"
elif self.radioHttps.isChecked():
content += "Https\n"
elif self.radioTftp.isChecked():
content += "Tftp\n"
elif self.radioFtp.isChecked():
content += "Ftp\n"
elif self.radioFtps.isChecked():
content += "Ftps\n"
else :
content += "Window\n"
content += str(self.findCoreStop) + "\n"
content += str(self.cleanCacheSet) + "\n"
content += str(self.useApiTest) + "\n"
content += str(self.showTestProgress) + "\n"
content += str(self.showChrome) + "\n"
content += self.chromePath +"\n"
content += str(self.saveTestLog) +"\n"
content += self.saveLogPath +"\n"
content += self.coreDumpPath +"\n"
byteArr = bytes(content,"utf-8")
file.write(QByteArray(byteArr))
file.close()
def checkBeforeRun(self):
containError = False
#---------check Ip address--------------
if self.ipLineEdit.text() == "":
containError = True
self.outputError("IP地址不能为空!")
else:
pattern = re.compile("^((1[0-9][0-9]\.)|(2[0-4][0-9]\.)|(25[0-5]\.)|([1-9][0-9]\.)|([0-9]\.)){3}((1[0-9][0-9])|(2[0-4][0-9])|(25[0-5])|([1-9][0-9])|([0-9]))$")
if not pattern.search(self.ipLineEdit.text()):
containError = True
self.outputError("IP地址格式错误,检查是否含有多余空格！(仅支持IPV4)")
#------------------------
if self.passwordLineEdit.text() == "":
containError = True
self.outputError("密码不能为空!")
if self.userLineEdit.text() == "":
containError = True
self.outputError("用户名不能为空!")
if self.intervalSpinBox.value() <= 40:
self.outputWarning("间隔时间过短,可能对测试造成影响")
if not self.radioProvision.isChecked() and not self.radioReboot.isChecked() and \
not self.radioFactory.isChecked():
containError = True
self.outputError("必须选择测试方式(重启，升降级，恢复出厂)")
# check provision ----------
if self.radioProvision.isChecked():
if self.ver1LineEdit.text() == "" or self.ver2LineEdit.text() == "" or \
self.dir1LineEdit.text() == "" or self.dir2LineEdit.text() == "":
containError = True
self.outputError("升降级测试至少填上前两个版本及其路径")
bin_name = ""
if os.path.exists(os.path.abspath("config.ini") ):
f = open(os.path.abspath("config.ini") , "r")
line = f.readline()
while line:
option = line.split("=")
if option[0] == "firmbinname":
if option[1].strip('"') != "":
filenamebin = option[1].strip()
bin_name = filenamebin.strip('"')
pass
line = f.readline()
f.close()
filename = os.path.join(self.dir1LineEdit.text(), bin_name)
if not os.path.exists(filename) and self.radioWindow.isChecked():
containError = True
self.outputError("firmware1 文件不存在！" + filename)
filename = os.path.join(self.dir2LineEdit.text(), bin_name)
if not os.path.exists(filename) and self.radioWindow.isChecked():
containError = True
self.outputError("firmware2 文件不存在！" + filename)
filename = os.path.join(self.dir3LineEdit.text(), bin_name)
if self.ver3LineEdit.text() != "" and self.dir3LineEdit.text() == "":
containError = True
self.outputError("填写了版本3，但对应路径为空！")
if self.dir3LineEdit.text() != "" and self.ver3LineEdit.text() == "":
containError = True
self.outputError("填写了路径3，但对应版本为空！")
elif self.dir3LineEdit.text() != "" and self.radioWindow.isChecked() and not os.path.exists(filename):
containError = True
self.outputError("firmware3 文件不存在！" + filename)
if not self.radioFtp.isChecked() and not self.radioFtps.isChecked() and \
not self.radioHttp.isChecked() and not self.radioHttps.isChecked() and \
not self.radioTftp.isChecked() and not self.radioWindow.isChecked():
containError = True
self.outputError("升降级测试必须选择服务器类型(Tftp,Ftp,Ftps,Http,Https)")
return containError
def startTest(self):
ip = self.ipLineEdit.text()
passwd = self.passwordLineEdit.text()
username = self.userLineEdit.text()
ptime = self.intervalSpinBox.value()
loop = self.loopSpinBox.value()
modelType = self.webBtn.text()
if self.gxpAction.isChecked():
device_type = "GXP21XX"
elif self.grp2602Action.isChecked():
device_type = "GRP260X"
if self.radioReboot.isChecked():
task_type = "reboot"
elif self.radioProvision.isChecked():
task_type = "provision"
text_ver1 = self.ver1LineEdit.text()
text_ver2 = self.ver2LineEdit.text()
text_ver3 = self.ver3LineEdit.text()
text_dir1 = self.dir1LineEdit.text()
text_dir2 = self.dir2LineEdit.text()
text_dir3 = self.dir3LineEdit.text()
prov_dict = {"ver1": text_ver1.strip(), "dir1": text_dir1.strip(), "ver2": text_ver2.strip(),
"dir2": text_dir2.strip(), "ver3": text_ver3.strip(), "dir3": text_dir3.strip()}
if self.radioHttp.isChecked():
self.man.update_prov_setting("HTTP", prov_dict)
elif self.radioHttps.isChecked():
self.man.update_prov_setting("HTTPS", prov_dict)
elif self.radioTftp.isChecked():
self.man.update_prov_setting("TFTP", prov_dict)
elif self.radioFtp.isChecked():
self.man.update_prov_setting("FTP", prov_dict)
elif self.radioFtps.isChecked():
self.man.update_prov_setting("FTPS", prov_dict)
elif self.radioWindow.isChecked():
self.man.update_prov_setting("browser", prov_dict)
else:
task_type = "reset"
coredump_stop = True
headless_flag = False
clean_cache = False
if self.checkCoreBox.isChecked() == False:
self.messageBox.append("Find core dump will not stop")
coredump_stop = False
if self.cleanCache.isChecked() == True:
clean_cache = True
if self.checkShowChromeBox.isChecked() == True or self.radioWindow.isChecked() == True:
headless_flag = False
else:
headless_flag = True
# ai_mode = False
# if self.aiOptionBox.isChecked() == True:
# ai_mode = True
browser_path = ""
if self.chromePathLabel.text() != "":
browser_path = self.chromePathLabel.text()
self.testStatus = [True,1,0,"ip",""]
print(self.interfaceMenu.currentText())
self.man.setStatus(self.testStatus)
self.man.setMessageList(self.messageList)
self.man.update_setting(ip.strip(), username.strip(), passwd.strip(), device_type, \
task_type, loop, ptime, coredump_stop, headless_flag, browser_path, \
clean_cache, self.interfaceMenu.currentText(), False)
def startApiTest(self):
ip = self.ipLineEdit.text()
passwd = self.passwordLineEdit.text()
username = self.userLineEdit.text()
ptime = self.intervalSpinBox.value()
loop = self.loopSpinBox.value()
testType = "Reboot"
if self.radioProvision.isChecked():
testType = "Provision"
self.api.setValue(ip,username,passwd,ptime,loop,testType)
v1 = self.ver1LineEdit.text()
v2 = self.ver2LineEdit.text()
v3 = self.ver3LineEdit.text()
d1 = self.dir1LineEdit.text()
d2 = self.dir2LineEdit.text()
d3 = self.dir3LineEdit.text()
self.api.setVersion(v1,v2,v3,d1,d2,d3)
self.api.setTestStatus(self.testStatus,self.messageList,self.coreDumpPath)
if self.radioHttp.isChecked():
self.api.setServerType("http")
elif self.radioHttps.isChecked():
self.api.setServerType("https")
elif self.radioTftp.isChecked():
self.api.setServerType("tftp")
elif self.radioFtp.isChecked():
self.api.setServerType("ftp")
else: #self.radioFtps.isChecked()
self.api.setServerType("ftps")
self.api.setFoundCoreStop(self.findCoreStop)
# slot ---------------------------------
def apiTestBoxCheck(self,state):
if state == 2:
self.corePathBtn.show()
self.corePathLabel.show()
else:
self.corePathBtn.hide()
self.corePathLabel.hide()
def clickedCorePathBtn(self):
dir = QFileDialog.getExistingDirectory(self.advanceWidget,"选择Core Dump存放路径","/home")
if dir != "":
self.corePathLabel.setText(dir)
self.coreDumpPath = dir
def clickedSelectDirBtn(self):
dir = QFileDialog.getExistingDirectory(self.advanceWidget,"选择日志存放路径","/home")
if dir != "":
self.saveDirLabel.setText(dir)
self.saveLogPath = dir
def clickedSelectChromeBtn(self):
fileName = QFileDialog.getOpenFileName(self.advanceWidget,"选择谷歌浏览器","/home","Chrome (*.exe)")
if fileName != "":
self.chromePathLabel.setText(fileName[0])
self.chromePath = fileName[0]
def saveLogBoxCheck(self,state):
if state == 2: # checked
self.selectDirBtn.show()
self.saveDirLabel.show()
else:
self.selectDirBtn.hide()
self.saveDirLabel.hide()
def clickedAdvanceOkBtn(self):
self.findCoreStop = self.checkCoreBox.isChecked()
self.cleanCacheSet = self.cleanCache.isChecked()
self.useApiTest = self.apiCheckBox.isChecked()
self.showTestProgress = self.checkProgressBox.isChecked()
self.saveTestLog = self.checkSaveLogBox.isChecked()
self.saveLogPath = self.saveDirLabel.text()
self.showChrome = self.checkShowChromeBox.isChecked()
self.chromePath = self.chromePathLabel.text()
self.coreDumpPath = self.corePathLabel.text()
if self.useApiTest:
self.webBtn.setEnabled(False)
self.corePathBtn.show()
self.corePathLabel.show()
else:
self.webBtn.setEnabled(True)
self.corePathBtn.hide()
self.corePathLabel.hide()
if self.showTestProgress:
self.infoLabel.show()
else:
self.infoLabel.hide()
self.saveCache()
self.advanceWidget.hide()
def clickedAdvanceBtn(self):
self.advanceWidget.hide()
self.checkCoreBox.setChecked(self.findCoreStop)
self.cleanCache.setChecked(self.cleanCacheSet)
self.apiCheckBox.setChecked(self.useApiTest)
self.checkProgressBox.setChecked(self.showTestProgress)
self.checkSaveLogBox.setChecked(self.saveTestLog)
self.saveDirLabel.setText(self.saveLogPath)
self.checkShowChromeBox.setChecked(self.showChrome)
self.chromePathLabel.setText(self.chromePath)
self.corePathLabel.setText(self.coreDumpPath)
self.advanceWidget.show()
def slotTestStoped(self):
self.testStatus[0] = False
self.setItemEnable(True)
self.timer.stop()
self.updateMessage()
self.thread.quit()
# save Test log
if self.saveTestLog:
fileName = time.strftime("%Y_%m_%d.%H_%M_%S.",time.localtime())
if self.radioReboot.isChecked():
fileName += "reboot"
elif self.radioProvision:
fileName += "provision"
else:
fileName += "factoryReset"
fileName += ".htm"
if self.saveLogPath == "":
self.outputWarning("日志地址没有设置，无法保存")
else:
fileName = self.saveLogPath + "\\" + fileName
print(fileName)
file = QFile(fileName)
if not file.open(QIODevice.WriteOnly):
self.outputError("打开文件错误,保存日志失败")
return
byteArr = bytes(self.messageBox.toHtml(),"utf-8")
file.write(QByteArray(byteArr))
file.close()
def clickedClearBtn(self):
self.ipLineEdit.setText("")
self.passwordLineEdit.setText("")
self.userLineEdit.setText("")
self.ver1LineEdit.setText("")
self.dir1LineEdit.setText("")
self.ver2LineEdit.setText("")
self.dir2LineEdit.setText("")
self.ver3LineEdit.setText("")
self.dir3LineEdit.setText("")
def clickedStarBtn(self):
if self.checkBeforeRun():
return
self.messageBox.clear()
self.saveCache()
self.messageBox.append("Init Setting...")
self.setItemEnable(False)
self.timer.start(500)
self.thread.start()
# deside use what to test
if self.useApiTest:
if self.radioFactory.isChecked():
self.outputWarning("Api not support Factory Reset, will test as Gxp type web driver")
self.clickedGxpType()
self.startTest()
self.signalRun.emit(self.man)
else:
self.startApiTest()
self.signalRunApi.emit(self.api)
else:
self.startTest()
self.signalRun.emit(self.man)
def clickedStopBtn(self):
self.stopBtn.setEnabled(False)
self.testStatus[0] = False
self.man.quit()
self.outputWarning("正在停止...")
def clickedProvision(self):
self.provWidget.show()
self.changePosition(False)
def clickedOthers(self):
self.provWidget.hide()
self.changePosition(True)
def clickedGxpType(self):
self.gxpAction.setChecked(True)
self.grp2602Action.setChecked(False)
self.webBtn.setText(self.gxpAction.text())
def clickedGrp2602(self):
self.gxpAction.setChecked(False)
self.grp2602Action.setChecked(True)
self.webBtn.setText(self.grp2602Action.text())
def updateMessage(self):
while len(self.messageList) >0:
info = self.messageList.popleft()
self.messageBox.append(info)
if self.testStatus[0] == False:
self.infoLabel.setText("未开始测试")
else:
info = "第" + str(self.testStatus[1]) + "次测试 "
if self.testStatus[2] > 0:
info += "等待：{} 秒".format( self.testStatus[2] )
else:
info += "运行中"
info += " " + self.testStatus[3]
info += " " + self.testStatus[4]
self.infoLabel.setText(info)
class MVCPlaybackControlGUI(PlaybackControlConsole):
"""
GUI implementation of MVCPlaybackControlBase
"""
nameFiltersChanged = Signal("QStringList")
def __init__(self, config):
assertMainThread()
super().__init__(config)
# state
self.preventSeek = False
self.beginTime = None
self.timeRatio = 1.0
# gui
srv = Services.getService("MainWindow")
config.configLoaded.connect(self.restoreState)
config.configAboutToSave.connect(self.saveState)
self.config = config
playbackMenu = srv.menuBar().addMenu("&Playback")
style = QApplication.style()
self.actStart = QAction(QIcon.fromTheme("media-playback-start", style.standardIcon(QStyle.SP_MediaPlay)),
"Start Playback", self)
self.actPause = QAction(QIcon.fromTheme("media-playback-pause", style.standardIcon(QStyle.SP_MediaPause)),
"Pause Playback", self)
self.actPause.setEnabled(False)
self.actStepFwd = QAction(QIcon.fromTheme("media-seek-forward",
style.standardIcon(QStyle.SP_MediaSeekForward)),
"Step Forward", self)
self.actStepBwd = QAction(QIcon.fromTheme("media-seek-backward",
style.standardIcon(QStyle.SP_MediaSeekBackward)),
"Step Backward", self)
self.actSeekEnd = QAction(QIcon.fromTheme("media-skip-forward",
style.standardIcon(QStyle.SP_MediaSkipForward)),
"Seek End", self)
self.actSeekBegin = QAction(QIcon.fromTheme("media-skip-backward",
style.standardIcon(QStyle.SP_MediaSkipBackward)),
"Seek Begin", self)
self.actSetTimeFactor = {r : QAction("x 1/%d" % (1/r), self) if r < 1 else QAction("x %d" % r, self)
for r in (1/8, 1/4, 1/2, 1, 2, 4, 8)}
# pylint: disable=unnecessary-lambda
# let's stay on the safe side and do not use emit as a slot...
self.actStart.triggered.connect(lambda: self._startPlayback.emit())
self.actPause.triggered.connect(lambda: self._pausePlayback.emit())
self.actStepFwd.triggered.connect(lambda: self._stepForward.emit(self.selectedStream()))
self.actStepBwd.triggered.connect(lambda: self._stepBackward.emit(self.selectedStream()))
self.actSeekEnd.triggered.connect(lambda: self._seekEnd.emit())
self.actSeekBegin.triggered.connect(lambda: self._seekBeginning.emit())
# pylint: enable=unnecessary-lambda
def setTimeFactor(newFactor):
logger.debug("new time factor %f", newFactor)
self._setTimeFactor.emit(newFactor)
for r in self.actSetTimeFactor:
logger.debug("adding action for time factor %f", r)
self.actSetTimeFactor[r].triggered.connect(functools.partial(setTimeFactor, r))
self.dockWidget = srv.newDockWidget("PlaybackControl", None, Qt.LeftDockWidgetArea)
self.dockWidgetContents = QWidget(self.dockWidget)
self.dockWidget.setWidget(self.dockWidgetContents)
toolLayout = QBoxLayout(QBoxLayout.TopToBottom, self.dockWidgetContents)
toolLayout.setContentsMargins(0, 0, 0, 0)
toolBar = QToolBar()
toolLayout.addWidget(toolBar)
toolBar.addAction(self.actSeekBegin)
toolBar.addAction(self.actStepBwd)
toolBar.addAction(self.actStart)
toolBar.addAction(self.actPause)
toolBar.addAction(self.actStepFwd)
toolBar.addAction(self.actSeekEnd)
playbackMenu.addAction(self.actSeekBegin)
playbackMenu.addAction(self.actStepBwd)
playbackMenu.addAction(self.actStart)
playbackMenu.addAction(self.actPause)
playbackMenu.addAction(self.actStepFwd)
playbackMenu.addAction(self.actSeekEnd)
playbackMenu.addSeparator()
for r in self.actSetTimeFactor:
playbackMenu.addAction(self.actSetTimeFactor[r])
self.timeRatioLabel = QLabel("x 1")
self.timeRatioLabel.addActions(list(self.actSetTimeFactor.values()))
self.timeRatioLabel.setContextMenuPolicy(Qt.ActionsContextMenu)
toolBar.addSeparator()
toolBar.addWidget(self.timeRatioLabel)
contentsLayout = QGridLayout()
toolLayout.addLayout(contentsLayout, 10)
# now we add a position view
self.positionSlider = QSlider(Qt.Horizontal, self.dockWidgetContents)
self.beginLabel = QLabel(parent=self.dockWidgetContents)
self.beginLabel.setAlignment(Qt.AlignLeft|Qt.AlignCenter)
self.currentLabel = QLabel(parent=self.dockWidgetContents)
self.currentLabel.setAlignment(Qt.AlignHCenter|Qt.AlignCenter)
self.endLabel = QLabel(parent=self.dockWidgetContents)
self.endLabel.setAlignment(Qt.AlignRight|Qt.AlignCenter)
contentsLayout.addWidget(self.beginLabel, 0, 0, alignment=Qt.AlignLeft)
contentsLayout.addWidget(self.currentLabel, 0, 1, alignment=Qt.AlignHCenter)
contentsLayout.addWidget(self.endLabel, 0, 2, alignment=Qt.AlignRight)
contentsLayout.addWidget(self.positionSlider, 1, 0, 1, 3)
self.positionSlider.setTracking(False)
self.positionSlider.valueChanged.connect(self.onSliderValueChanged, Qt.DirectConnection)
self.positionSlider.sliderMoved.connect(self.displayPosition)
# file browser
self.browser = BrowserWidget(self.dockWidget)
self.nameFiltersChanged.connect(self._onNameFiltersChanged, Qt.QueuedConnection)
contentsLayout.addWidget(self.browser, 3, 0, 1, 3)
contentsLayout.setRowStretch(3, 100)
self.browser.activated.connect(self.browserActivated)
self.actShowAllFiles = QAction("Show all files")
self.actShowAllFiles.setCheckable(True)
self.actShowAllFiles.setChecked(False)
self.actShowAllFiles.toggled.connect(self._onShowAllFiles)
playbackMenu.addSeparator()
playbackMenu.addAction(self.actShowAllFiles)
self.actGroupStream = QActionGroup(self)
self.actGroupStream.setExclusionPolicy(QActionGroup.ExclusionPolicy.ExclusiveOptional)
playbackMenu.addSeparator()
self.actGroupStreamMenu = playbackMenu.addMenu("Step Stream")
self._selectedStream = None
self.recentSeqs = [QAction() for i in range(10)]
playbackMenu.addSeparator()
recentMenu = playbackMenu.addMenu("Recent")
for a in self.recentSeqs:
a.setVisible(False)
a.triggered.connect(self.openRecent)
recentMenu.addAction(a)
self._supportedFeaturesChanged(set(), set())
def __del__(self):
logger.internal("deleting playback control")
def _onNameFiltersChanged(self, nameFilt):
self.browser.setFilter(nameFilt)
def _onShowAllFiles(self, enabled):
self.fileSystemModel.setNameFilterDisables(enabled)
def _supportedFeaturesChanged(self, featureset, nameFilters):
"""
overwritten from MVCPlaybackControlBase. This function is called
from multiple threads, but not at the same time.
:param featureset: the current featureset
:return:
"""
assertMainThread()
self.featureset = featureset
self.actStepFwd.setEnabled("stepForward" in featureset)
self.actStepBwd.setEnabled("stepBackward" in featureset)
self.actSeekBegin.setEnabled("seekBeginning" in featureset)
self.actSeekEnd.setEnabled("seekEnd" in featureset)
self.positionSlider.setEnabled("seekTime" in featureset)
self.browser.setEnabled("setSequence" in featureset)
self.timeRatioLabel.setEnabled("setTimeFactor" in featureset)
for f in self.actSetTimeFactor:
self.actSetTimeFactor[f].setEnabled("setTimeFactor" in featureset)
self.timeRatioLabel.setEnabled("setTimeFactor" in featureset)
self.timeRatioLabel.setEnabled("setTimeFactor" in featureset)
self.timeRatioLabel.setEnabled("setTimeFactor" in featureset)
self.timeRatioLabel.setEnabled("setTimeFactor" in featureset)
if "startPlayback" not in featureset:
self.actStart.setEnabled(False)
if "pausePlayback" not in featureset:
self.actPause.setEnabled(False)
logger.debug("current feature set: %s", featureset)
logger.debug("Setting name filters of browser: %s", list(nameFilters))
self.nameFiltersChanged.emit(list(nameFilters))
super()._supportedFeaturesChanged(featureset, nameFilters)
def scrollToCurrent(self):
"""
Scrolls to the current item in the browser
:return:
"""
assertMainThread()
c = self.browser.current()
if c is not None:
self.browser.scrollTo(c)
def _sequenceOpened(self, filename, begin, end, streams):
"""
Notifies about an opened sequence.
:param filename: the filename which has been opened
:param begin: timestamp of sequence's first sample
:param end: timestamp of sequence's last sample
:param streams: list of streams in the sequence
:return: None
"""
assertMainThread()
self.beginTime = begin
self.preventSeek = True
self.positionSlider.setRange(0, end.toMSecsSinceEpoch() - begin.toMSecsSinceEpoch())
self.preventSeek = False
self.beginLabel.setText(begin.toString("hh:mm:ss.zzz"))
self.endLabel.setText(end.toString("hh:mm:ss.zzz"))
self._currentTimestampChanged(begin)
try:
self.browser.blockSignals(True)
self.browser.setActive(filename)
self.browser.scrollTo(filename)
finally:
self.browser.blockSignals(False)
self._selectedStream = None
for a in self.actGroupStream.actions():
logger.debug("Remove stream group action: %s", a.data())
self.actGroupStream.removeAction(a)
for stream in streams:
act = QAction(stream, self.actGroupStream)
act.triggered.connect(lambda cstream=stream: self.setSelectedStream(cstream))
act.setCheckable(True)
act.setChecked(False)
logger.debug("Add stream group action: %s", act.data())
self.actGroupStreamMenu.addAction(act)
QTimer.singleShot(250, self.scrollToCurrent)
super()._sequenceOpened(filename, begin, end, streams)
def _currentTimestampChanged(self, currentTime):
"""
Notifies about a changed timestamp
:param currentTime: the new current timestamp
:return: None
"""
assertMainThread()
if self.beginTime is None:
self.currentLabel.setText("")
else:
sliderVal = currentTime.toMSecsSinceEpoch() - self.beginTime.toMSecsSinceEpoch()
self.preventSeek = True
self.positionSlider.setValue(sliderVal)
self.preventSeek = False
self.positionSlider.blockSignals(False)
self.currentLabel.setEnabled(True)
self.currentLabel.setText(currentTime.toString("hh:mm:ss.zzz"))
super()._currentTimestampChanged(currentTime)
def onSliderValueChanged(self, value):
"""
Slot called whenever the slider value is changed.
:param value: the new slider value
:return:
"""
assertMainThread()
if self.beginTime is None or self.preventSeek:
return
if self.actStart.isEnabled():
ts = QDateTime.fromMSecsSinceEpoch(self.beginTime.toMSecsSinceEpoch() + value, self.beginTime.timeSpec())
self._seekTime.emit(ts)
else:
logger.warning("Can't seek while playing.")
def displayPosition(self, value):
"""
Slot called when the slider is moved. Displays the position without actually seeking to it.
:param value: the new slider value.
:return:
"""
assertMainThread()
if self.beginTime is None:
return
if self.positionSlider.isSliderDown():
ts = QDateTime.fromMSecsSinceEpoch(self.beginTime.toMSecsSinceEpoch() + value, self.beginTime.timeSpec())
self.currentLabel.setEnabled(False)
self.currentLabel.setText(ts.toString("hh:mm:ss.zzz"))
def _playbackStarted(self):
"""
Notifies about starting playback
:return: None
"""
assertMainThread()
self.actStart.setEnabled(False)
if "pausePlayback" in self.featureset:
self.actPause.setEnabled(True)
super()._playbackStarted()
def _playbackPaused(self):
"""
Notifies about pause playback
:return: None
"""
assertMainThread()
logger.debug("playbackPaused received")
if "startPlayback" in self.featureset:
self.actStart.setEnabled(True)
self.actPause.setEnabled(False)
super()._playbackPaused()
def openRecent(self):
"""
Called when the user clicks on a recent sequence.
:return:
"""
assertMainThread()
action = self.sender()
self.browser.setActive(action.data())
def browserActivated(self, filename):
"""
Called when the user activated a file.
:param filename: the new filename
:return:
"""
assertMainThread()
if filename is not None and Path(filename).is_file():
foundIdx = None
for i, a in enumerate(self.recentSeqs):
if a.data() == filename:
foundIdx = i
if foundIdx is None:
foundIdx = len(self.recentSeqs)-1
for i in range(foundIdx, 0, -1):
self.recentSeqs[i].setText(self.recentSeqs[i-1].text())
self.recentSeqs[i].setData(self.recentSeqs[i-1].data())
logger.debug("%d data: %s", i, self.recentSeqs[i-1].data())
self.recentSeqs[i].setVisible(self.recentSeqs[i-1].data() is not None)
self.recentSeqs[0].setText(self.compressFileName(filename))
self.recentSeqs[0].setData(filename)
self.recentSeqs[0].setVisible(True)
self._setSequence.emit(filename)
def _timeRatioChanged(self, newRatio):
"""
Notifies about a changed playback time ratio,
:param newRatio the new playback ratio as a float
:return: None
"""
assertMainThread()
self.timeRatio = newRatio
logger.debug("new timeRatio: %f", newRatio)
for r in [1/8, 1/4, 1/2, 1, 2, 4, 8]:
if abs(newRatio / r - 1) < 0.01:
self.timeRatioLabel.setText(("x 1/%d"%(1/r)) if r < 1 else ("x %d"%r))
return
self.timeRatioLabel.setText("%.2f" % newRatio)
super()._timeRatioChanged(newRatio)
def selectedStream(self):
"""
Returns the user-selected stream (for forward/backward stepping)
:return:
"""
return self._selectedStream
def setSelectedStream(self, stream):
"""
Sets the user-selected stream (for forward/backward stepping)
:param stream the stream name.
:return:
"""
self._selectedStream = stream
def saveState(self):
"""
Saves the state of the playback control
:return:
"""
assertMainThread()
propertyCollection = self.config.guiState()
showAllFiles = self.actShowAllFiles.isChecked()
folder = self.browser.folder()
logger.debug("Storing current folder: %s", folder)
try:
propertyCollection.setProperty("PlaybackControl_showAllFiles", int(showAllFiles))
propertyCollection.setProperty("PlaybackControl_folder", folder)
recentFiles = [a.data() for a in self.recentSeqs if a.data() is not None]
propertyCollection.setProperty("PlaybackControl_recent", "|".join(recentFiles))
except PropertyCollectionPropertyNotFound:
pass
def restoreState(self):
"""
Restores the state of the playback control from the given property collection
:param propertyCollection: a PropertyCollection instance
:return:
"""
assertMainThread()
propertyCollection = self.config.guiState()
propertyCollection.defineProperty("PlaybackControl_showAllFiles", 0, "show all files setting")
showAllFiles = propertyCollection.getProperty("PlaybackControl_showAllFiles")
self.actShowAllFiles.setChecked(bool(showAllFiles))
propertyCollection.defineProperty("PlaybackControl_folder", "", "current folder name")
folder = propertyCollection.getProperty("PlaybackControl_folder")
if Path(folder).is_dir():
logger.debug("Setting current file: %s", folder)
self.browser.setFolder(folder)
propertyCollection.defineProperty("PlaybackControl_recent", "", "recent opened sequences")
recentFiles = propertyCollection.getProperty("PlaybackControl_recent")
idx = 0
for f in recentFiles.split("|"):
if f != "" and Path(f).is_file():
self.recentSeqs[idx].setData(f)
self.recentSeqs[idx].setText(self.compressFileName(f))
self.recentSeqs[idx].setVisible(True)
idx += 1
if idx >= len(self.recentSeqs):
break
for a in self.recentSeqs[idx:]:
a.setData(None)
a.setText("")
a.setVisible(False)
@staticmethod
def compressFileName(filename):
"""
Compresses long path names with an ellipsis (...)
:param filename: the original path name as a Path or string instance
:return: the compressed path name as a string instance
"""
p = Path(filename)
parts = tuple(p.parts)
if len(parts) >= 6:
p = Path(*parts[:2]) / "..." / Path(*parts[-2:])
return str(p)
class MainWindow(QMainWindow):
def __init__(self, application, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.printer_thread = WorkerThread()
self.printer_thread.message.connect(self.standardOutputWritten)
self.printer_thread.start()
self.app = application
self.app.setStyle("Fusion")
self.__set_interface()
self.__set_layouts()
self.__set_stylesheet()
self.__set_connections()
self.__set_params()
def closeEvent(self, event):
self.printer_thread.stop()
def __set_interface(self):
self.button_width = 0.35
self.button_height = 0.05
self.setWindowTitle("GSI-RADS")
self.__getScreenDimensions()
self.setGeometry(self.left, self.top, self.width, self.height)
self.setMaximumWidth(self.width)
#self.setMaximumHeight(self.height)
self.setMinimumWidth(self.width)
self.setMinimumHeight(self.height)
self.move(self.width / 2, self.height / 2)
self.menu_bar = QMenuBar(self)
self.menu_bar.setNativeMenuBar(
False
) # https://stackoverflow.com/questions/25261760/menubar-not-showing-for-simple-qmainwindow-code-qt-creator-mac-os
self.file_menu = self.menu_bar.addMenu('File')
self.import_dicom_action = QAction(
QIcon(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'images/database-icon.png')), 'Import DICOM',
self)
self.import_dicom_action.setShortcut('Ctrl+D')
self.file_menu.addAction(self.import_dicom_action)
self.quit_action = QAction('Quit', self)
self.quit_action.setShortcut("Ctrl+Q")
self.file_menu.addAction(self.quit_action)
self.settings_menu = self.menu_bar.addMenu('Settings')
self.settings_seg_menu = self.settings_menu.addMenu("Segmentation...")
self.settings_seg_preproc_menu = self.settings_seg_menu.addMenu(
"Preprocessing...")
self.settings_seg_preproc_menu_p1_action = QAction(
"Brain-masking off (P1)", checkable=True)
self.settings_seg_preproc_menu_p2_action = QAction(
"Brain-masking on (P2)", checkable=True)
self.settings_seg_preproc_menu_p2_action.setChecked(True)
self.settings_seg_preproc_menu.addAction(
self.settings_seg_preproc_menu_p1_action)
self.settings_seg_preproc_menu.addAction(
self.settings_seg_preproc_menu_p2_action)
self.help_menu = self.menu_bar.addMenu('Help')
self.readme_action = QAction(
QIcon(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'images/readme-icon.jpeg')), 'Tutorial', self)
self.readme_action.setShortcut("Ctrl+R")
self.help_menu.addAction(self.readme_action)
self.about_action = QAction(
QIcon(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'images/about-icon.png')), 'About', self)
self.about_action.setShortcut("Ctrl+A")
self.help_menu.addAction(self.about_action)
self.help_action = QAction(
QIcon.fromTheme("help-faq"), "Help", self
) # Default icons can be found here: https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html#guidelines
self.help_action.setShortcut("Ctrl+J")
self.help_menu.addAction(self.help_action)
self.input_image_lineedit = QLineEdit()
self.input_image_lineedit.setFixedWidth(self.width *
(0.93 - self.button_width / 2))
self.input_image_lineedit.setFixedHeight(self.height *
self.button_height)
self.input_image_lineedit.setReadOnly(True)
self.input_image_pushbutton = QPushButton('Input MRI')
self.input_image_pushbutton.setFixedWidth(self.height *
self.button_width)
self.input_image_pushbutton.setFixedHeight(self.height *
self.button_height)
self.input_segmentation_lineedit = QLineEdit()
self.input_segmentation_lineedit.setReadOnly(True)
self.input_segmentation_lineedit.setFixedWidth(
self.width * (0.93 - self.button_width / 2))
self.input_segmentation_lineedit.setFixedHeight(self.height *
self.button_height)
self.input_segmentation_pushbutton = QPushButton('Input segmentation')
self.input_segmentation_pushbutton.setFixedWidth(self.height *
self.button_width)
self.input_segmentation_pushbutton.setFixedHeight(self.height *
self.button_height)
self.output_folder_lineedit = QLineEdit()
self.output_folder_lineedit.setReadOnly(True)
self.output_folder_lineedit.setFixedWidth(
self.width * (0.93 - self.button_width / 2))
self.output_folder_lineedit.setFixedHeight(self.height *
self.button_height)
self.output_folder_pushbutton = QPushButton('Output destination')
self.output_folder_pushbutton.setFixedWidth(self.height *
self.button_width)
self.output_folder_pushbutton.setFixedHeight(self.height *
self.button_height)
self.run_button = QPushButton('Run diagnosis')
self.run_button.setFixedWidth(self.height * self.button_width)
self.run_button.setFixedHeight(self.height * self.button_height)
self.main_display_tabwidget = QTabWidget()
self.tutorial_textedit = QPlainTextEdit()
self.tutorial_textedit.setReadOnly(True)
self.tutorial_textedit.setFixedWidth(self.width * 0.97)
self.tutorial_textedit.setPlainText(
"HOW TO USE THE SOFTWARE: \n"
" 1) Click 'Input MRI...' to select from your file explorer the MRI scan to process (unique file).\n"
" 1*) Alternatively, Click File > Import DICOM... if you wish to process an MRI scan as a DICOM sequence.\n"
" 2) Click 'Output destination' to choose a directory where to save the results \n"
" 3) (OPTIONAL) Click 'Input segmentation' to choose a tumor segmentation mask file, if nothing is provided the internal model with generate the segmentation automatically \n"
" 4) Click 'Run diagnosis' to perform the analysis. The human-readable version will be displayed in the interface.\n"
" \n"
"NOTE: \n"
"The output folder is populated automatically with the following: \n"
" * The diagnosis results in human-readable text (report.txt) and Excel-ready format (report.csv).\n"
" * The automatic segmentation masks of the brain and the tumor in the original patient space (input_brain_mask.nii.gz and input_tumor_mask.nii.gz).\n"
" * The input volume and tumor segmentation mask in MNI space in the sub-directory named \'registration\'.\n"
)
self.main_display_tabwidget.addTab(self.tutorial_textedit, 'Tutorial')
self.prompt_lineedit = QPlainTextEdit()
self.prompt_lineedit.setReadOnly(True)
self.prompt_lineedit.setFixedWidth(self.width * 0.97)
self.main_display_tabwidget.addTab(self.prompt_lineedit, 'Logging')
self.results_textedit = QPlainTextEdit()
self.results_textedit.setReadOnly(True)
self.results_textedit.setFixedWidth(self.width * 0.97)
self.main_display_tabwidget.addTab(self.results_textedit, 'Results')
self.sintef_logo_label = QLabel()
self.sintef_logo_label.setPixmap(
QPixmap(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'images/sintef-logo.png')))
self.sintef_logo_label.setFixedWidth(0.95 * (self.width / 3))
self.sintef_logo_label.setFixedHeight(
1 * (self.height * self.button_height))
self.sintef_logo_label.setScaledContents(True)
self.stolavs_logo_label = QLabel()
self.stolavs_logo_label.setPixmap(
QPixmap(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'images/stolavs-logo.png')))
self.stolavs_logo_label.setFixedWidth(0.95 * (self.width / 3))
self.stolavs_logo_label.setFixedHeight(
1 * (self.height * self.button_height))
self.stolavs_logo_label.setScaledContents(True)
self.amsterdam_logo_label = QLabel()
self.amsterdam_logo_label.setPixmap(
QPixmap(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'images/amsterdam-logo.png')))
self.amsterdam_logo_label.setFixedWidth(0.95 * (self.width / 3))
self.amsterdam_logo_label.setFixedHeight(
1 * (self.height * self.button_height))
self.amsterdam_logo_label.setScaledContents(True)
def __set_layouts(self):
self.input_volume_hbox = QHBoxLayout()
self.input_volume_hbox.addStretch(1)
self.input_volume_hbox.addWidget(self.input_image_lineedit)
self.input_volume_hbox.addWidget(self.input_image_pushbutton)
self.input_volume_hbox.addStretch(1)
self.input_seg_hbox = QHBoxLayout()
self.input_seg_hbox.addStretch(1)
self.input_seg_hbox.addWidget(self.input_segmentation_lineedit)
self.input_seg_hbox.addWidget(self.input_segmentation_pushbutton)
self.input_seg_hbox.addStretch(1)
self.output_dir_hbox = QHBoxLayout()
self.output_dir_hbox.addStretch(1)
self.output_dir_hbox.addWidget(self.output_folder_lineedit)
self.output_dir_hbox.addWidget(self.output_folder_pushbutton)
self.output_dir_hbox.addStretch(1)
self.run_action_hbox = QHBoxLayout()
self.run_action_hbox.addStretch(1)
self.run_action_hbox.addWidget(self.run_button)
self.run_action_hbox.addStretch(1)
self.dump_area_hbox = QHBoxLayout()
self.dump_area_hbox.addStretch(1)
self.dump_area_hbox.addWidget(self.main_display_tabwidget)
self.dump_area_hbox.addStretch(1)
self.logos_hbox = QHBoxLayout()
self.logos_hbox.addStretch(1)
self.logos_hbox.addWidget(self.sintef_logo_label)
self.logos_hbox.addWidget(self.stolavs_logo_label)
self.logos_hbox.addWidget(self.amsterdam_logo_label)
self.logos_hbox.addStretch(1)
self.main_vbox = QVBoxLayout()
self.main_vbox.addWidget(self.menu_bar)
#self.main_vbox.addStretch(1)
self.main_vbox.addLayout(self.input_volume_hbox)
self.main_vbox.addLayout(self.output_dir_hbox)
self.main_vbox.addLayout(self.input_seg_hbox)
self.main_vbox.addLayout(self.run_action_hbox)
#self.main_vbox.addStretch(1)
self.main_vbox.addLayout(self.dump_area_hbox)
self.main_vbox.addLayout(self.logos_hbox)
#self.main_vbox.addStretch(1)
self.central_label = QLabel()
self.central_label.setLayout(self.main_vbox)
self.setCentralWidget(self.central_label)
def __set_stylesheet(self):
self.central_label.setStyleSheet(
'QLabel{background-color: qlineargradient(spread:pad, x1:0.5, y1:1, x2:0.5, y2:0, stop:0 rgba(207, 209, 207, 255), stop:1 rgba(230, 229, 230, 255));}'
)
self.menu_bar.setStyleSheet(get_stylesheet('QMenuBar'))
self.input_image_lineedit.setStyleSheet(get_stylesheet('QLineEdit'))
self.input_image_pushbutton.setStyleSheet(
get_stylesheet('QPushButton'))
self.input_segmentation_lineedit.setStyleSheet(
get_stylesheet('QLineEdit'))
self.input_segmentation_pushbutton.setStyleSheet(
get_stylesheet('QPushButton'))
self.output_folder_lineedit.setStyleSheet(get_stylesheet('QLineEdit'))
self.output_folder_pushbutton.setStyleSheet(
get_stylesheet('QPushButton'))
self.results_textedit.setStyleSheet(get_stylesheet('QTextEdit'))
self.prompt_lineedit.setStyleSheet(get_stylesheet('QTextEdit'))
self.run_button.setStyleSheet(get_stylesheet('QPushButton'))
def __set_connections(self):
self.run_button.clicked.connect(self.diagnose_main_wrapper)
self.input_image_pushbutton.clicked.connect(
self.run_select_input_image)
self.input_segmentation_pushbutton.clicked.connect(
self.run_select_input_segmentation)
self.output_folder_pushbutton.clicked.connect(
self.run_select_output_folder)
self.readme_action.triggered.connect(self.readme_action_triggered)
self.about_action.triggered.connect(self.about_action_triggered)
self.quit_action.triggered.connect(self.quit_action_triggered)
self.import_dicom_action.triggered.connect(
self.import_dicom_action_triggered)
self.help_action.triggered.connect(self.help_action_triggered)
self.settings_seg_preproc_menu_p1_action.triggered.connect(
self.settings_seg_preproc_menu_p1_action_triggered)
self.settings_seg_preproc_menu_p2_action.triggered.connect(
self.settings_seg_preproc_menu_p2_action_triggered)
def __set_params(self):
self.input_image_filepath = ''
self.input_annotation_filepath = ''
self.output_folderpath = ''
def __getScreenDimensions(self):
screen = self.app.primaryScreen()
size = screen.size()
self.left = size.width() / 2
self.top = size.height() / 2
self.width = 0.4 * size.width()
self.height = 0.4 * size.height()
def readme_action_triggered(self):
popup = QMessageBox()
popup.setWindowTitle('Tutorial')
popup.setText(
"HOW TO USE THE SOFTWARE: \n"
" 1) Click 'Input MRI...' to select from your file explorer the MRI scan to process (unique file).\n"
" 1*) Alternatively, Click File > Import DICOM... if you wish to process an MRI scan as a DICOM sequence.\n"
" 2) Click 'Output destination' to choose a directory where to save the results \n"
" 3) (OPTIONAL) Click 'Input segmentation' to choose a tumor segmentation mask file, if nothing is provided the internal model with generate the segmentation automatically \n"
" 4) Click 'Run diagnosis' to perform the analysis. The human-readable version will be displayed in the interface.\n"
" \n"
"NOTE: \n"
"The output folder is populated automatically with the following: \n"
" * The diagnosis results in human-readable text (report.txt) and Excel-ready format (report.csv).\n"
" * The automatic segmentation masks of the brain and the tumor in the original patient space (input_brain_mask.nii.gz and input_tumor_mask.nii.gz).\n"
" * The input volume and tumor segmentation mask in MNI space in the sub-directory named \'registration\'.\n"
)
popup.exec_()
def about_action_triggered(self):
popup = QMessageBox()
popup.setWindowTitle('About')
popup.setText(
'Software developed as part of a collaboration between: \n'
' * Departement of Health Research, SINTEF\n'
' * St. Olavs hospital, Trondheim University Hospital\n'
' * Amsterdam University Medical Center\n\n'
'Contact: David Bouget, Andre Pedersen\n\n'
'For questions about the software, please visit:\n'
'https://github.com/SINTEFMedtek/GSI-RADS\n'
'For questions about the methodological aspect, please refer to the original publication:\n'
'https://www.mdpi.com/2072-6694/13/12/2854/review_report')
popup.exec_()
def quit_action_triggered(self):
self.printer_thread.stop()
sys.exit()
def diagnose_main_wrapper(self):
self.run_diagnosis_thread = threading.Thread(target=self.run_diagnosis)
self.run_diagnosis_thread.daemon = True # using daemon thread the thread is killed gracefully if program is abruptly closed
self.run_diagnosis_thread.start()
def run_diagnosis(self):
if not os.path.exists(self.input_image_filepath) or not os.path.exists(
self.output_folderpath):
self.standardOutputWritten(
'Process could not be started - The 1st and 2nd above-fields must be filled in.\n'
)
return
self.run_button.setEnabled(False)
self.prompt_lineedit.clear()
self.main_display_tabwidget.setCurrentIndex(1)
QApplication.processEvents(
) # to immidiently update GUI after button is clicked
self.seg_preprocessing_scheme = 'P1' if self.settings_seg_preproc_menu_p1_action.isChecked(
) else 'P2'
try:
start_time = time.time()
print('Initialize - Begin (Step 0/6)')
from diagnosis.main import diagnose_main
print('Initialize - End (Step 0/6)')
print('Step runtime: {} seconds.'.format(
np.round(time.time() - start_time, 3)) + "\n")
diagnose_main(
input_volume_filename=self.input_image_filepath,
input_segmentation_filename=self.input_annotation_filepath,
output_folder=self.output_folderpath,
preprocessing_scheme=self.seg_preprocessing_scheme)
except Exception as e:
print('{}'.format(traceback.format_exc()))
self.run_button.setEnabled(True)
self.standardOutputWritten(
'Process could not be completed - Issue arose.\n')
QApplication.processEvents()
return
self.run_button.setEnabled(True)
results_filepath = os.path.join(
ResourcesConfiguration.getInstance().output_folder, 'report.txt')
self.results_textedit.setPlainText(open(results_filepath, 'r').read())
self.main_display_tabwidget.setCurrentIndex(2)
def run_select_input_image(self):
input_image_filedialog = QFileDialog()
self.input_image_filepath = input_image_filedialog.getOpenFileName(
self, 'Select input T1 MRI', '~',
"Image files (*.nii *.nii.gz *.nrrd *.mha *.mhd)")[0]
self.input_image_lineedit.setText(self.input_image_filepath)
def run_select_input_segmentation(self):
filedialog = QFileDialog()
self.input_annotation_filepath = filedialog.getOpenFileName(
self, 'Select input segmentation file', '~',
"Image files (*.nii *.nii.gz)")[0]
self.input_segmentation_lineedit.setText(
self.input_annotation_filepath)
def import_dicom_action_triggered(self):
filedialog = QFileDialog()
filedialog.setFileMode(QFileDialog.DirectoryOnly)
self.input_image_filepath = filedialog.getExistingDirectory(
self, 'Select DICOM folder', '~')
self.input_image_lineedit.setText(self.input_image_filepath)
def run_select_output_folder(self):
filedialog = QFileDialog()
filedialog.setFileMode(QFileDialog.DirectoryOnly)
self.output_folderpath = filedialog.getExistingDirectory(
self, 'Select output folder', '~')
self.output_folder_lineedit.setText(self.output_folderpath)
def standardOutputWritten(self, text):
self.prompt_lineedit.moveCursor(QTextCursor.End)
self.prompt_lineedit.insertPlainText(text)
QApplication.processEvents()
def help_action_triggered(self):
# opens browser with specified url, directs user to Issues section of GitHub repo
QDesktopServices.openUrl(
QUrl("https://github.com/SINTEFMedtek/GSI-RADS/issues"))
def settings_seg_preproc_menu_p1_action_triggered(self, status):
if status:
self.settings_seg_preproc_menu_p2_action.setChecked(False)
else:
self.settings_seg_preproc_menu_p2_action.setChecked(True)
def settings_seg_preproc_menu_p2_action_triggered(self, status):
if status:
self.settings_seg_preproc_menu_p1_action.setChecked(False)
else:
self.settings_seg_preproc_menu_p1_action.setChecked(True)
def initMenuBar(self):
self.menu = self.menuBar()
file_menu = self.menu.addMenu("File")
file_menu.addAction(self.newGameAction)
#file_menu.addAction(QIcon(CONST.ICONS["Open"]), "Open") # TODO : implement
file_menu.addAction(self.saveGameAction)
file_menu.addSeparator()
file_menu.addAction(self.showLiberationPrefDialogAction)
file_menu.addSeparator()
#file_menu.addAction("Save As") # TODO : implement
#file_menu.addAction("Close Current Game", lambda: self.closeGame()) # Not working
file_menu.addAction("Exit" , lambda: self.exit())
help_menu = self.menu.addMenu("Help")
help_menu.addAction("Online Manual", lambda: webbrowser.open_new_tab(URLS["Manual"]))
help_menu.addAction("Discord", lambda: webbrowser.open_new_tab("https://" + "discord.gg" + "/" + "bKrt" + "rkJ"))
#help_menu.addAction("Troubleshooting Guide", lambda: webbrowser.open_new_tab(URLS["Troubleshooting"]))
#help_menu.addAction("Modding Guide", lambda: webbrowser.open_new_tab(URLS["Modding"]))
#help_menu.addSeparator() ----> Note from Khopa : I disable these links since it's not up to date for this branch
#help_menu.addAction("Contribute", lambda: webbrowser.open_new_tab(URLS["Repository"]))
help_menu.addAction("Forum Thread", lambda: webbrowser.open_new_tab(URLS["ForumThread"]))
help_menu.addAction("Report an issue", lambda: webbrowser.open_new_tab(URLS["Issues"]))
help_menu.addSeparator()
help_menu.addAction(self.showAboutDialogAction)
displayMenu = self.menu.addMenu("Display")
tg_cp_visibility = QAction('Control Point', displayMenu)
tg_cp_visibility.setCheckable(True)
tg_cp_visibility.setChecked(True)
tg_cp_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("cp", tg_cp_visibility.isChecked()))
tg_go_visibility = QAction('Ground Objects', displayMenu)
tg_go_visibility.setCheckable(True)
tg_go_visibility.setChecked(True)
tg_go_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("go", tg_go_visibility.isChecked()))
tg_line_visibility = QAction('Lines', displayMenu)
tg_line_visibility.setCheckable(True)
tg_line_visibility.setChecked(True)
tg_line_visibility.toggled.connect(
lambda: QLiberationMap.set_display_rule("lines", tg_line_visibility.isChecked()))
tg_event_visibility = QAction('Events', displayMenu)
tg_event_visibility.setCheckable(True)
tg_event_visibility.setChecked(True)
tg_event_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("events", tg_event_visibility.isChecked()))
tg_sam_visibility = QAction('SAM Range', displayMenu)
tg_sam_visibility.setCheckable(True)
tg_sam_visibility.setChecked(True)
tg_sam_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("sam", tg_sam_visibility.isChecked()))
tg_flight_path_visibility = QAction('Flight Paths', displayMenu)
tg_flight_path_visibility.setCheckable(True)
tg_flight_path_visibility.setChecked(False)
tg_flight_path_visibility.toggled.connect(lambda: QLiberationMap.set_display_rule("flight_paths", tg_flight_path_visibility.isChecked()))
displayMenu.addAction(tg_go_visibility)
displayMenu.addAction(tg_cp_visibility)
displayMenu.addAction(tg_line_visibility)
displayMenu.addAction(tg_event_visibility)
displayMenu.addAction(tg_sam_visibility)
displayMenu.addAction(tg_flight_path_visibility)
