class MainWindow(QMainWindow):
max_recent = 5
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
QApplication.setApplicationName('Sherloq')
QApplication.setOrganizationName('Guido Bartoli')
QApplication.setOrganizationDomain('www.guidobartoli.com')
QApplication.setApplicationVersion(ToolTree().version)
QApplication.setWindowIcon(QIcon('icons/sherloq_white.png'))
self.setWindowTitle('{} {}'.format(QApplication.applicationName(),
QApplication.applicationVersion()))
self.mdi_area = QMdiArea()
self.setCentralWidget(self.mdi_area)
self.filename = None
self.image = None
modify_font(self.statusBar(), bold=True)
tree_dock = QDockWidget(self.tr('TOOLS'), self)
tree_dock.setObjectName('tree_dock')
tree_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.addDockWidget(Qt.LeftDockWidgetArea, tree_dock)
self.tree_widget = ToolTree()
self.tree_widget.setObjectName('tree_widget')
self.tree_widget.itemDoubleClicked.connect(self.open_tool)
tree_dock.setWidget(self.tree_widget)
tools_action = tree_dock.toggleViewAction()
tools_action.setText(self.tr('Show tools'))
tools_action.setToolTip(self.tr('Toggle toolset visibility'))
tools_action.setShortcut(QKeySequence(Qt.Key_Tab))
tools_action.setObjectName('tools_action')
tools_action.setIcon(QIcon('icons/tools.svg'))
help_action = QAction(self.tr('Show help'), self)
help_action.setToolTip(self.tr('Toggle online help'))
help_action.setShortcut(QKeySequence.HelpContents)
help_action.setObjectName('help_action')
help_action.setIcon(QIcon('icons/help.svg'))
help_action.setCheckable(True)
help_action.setEnabled(False)
load_action = QAction(self.tr('&Load image...'), self)
load_action.setToolTip(self.tr('Load an image to analyze'))
load_action.setShortcut(QKeySequence.Open)
load_action.triggered.connect(self.load_file)
load_action.setObjectName('load_action')
load_action.setIcon(QIcon('icons/load.svg'))
quit_action = QAction(self.tr('&Quit'), self)
quit_action.setToolTip(self.tr('Exit from Sherloq'))
quit_action.setShortcut(QKeySequence.Quit)
quit_action.triggered.connect(self.close)
quit_action.setObjectName('quit_action')
quit_action.setIcon(QIcon('icons/quit.svg'))
tabbed_action = QAction(self.tr('&Tabbed'), self)
tabbed_action.setToolTip(self.tr('Toggle tabbed view for window area'))
tabbed_action.setShortcut(QKeySequence(Qt.Key_F10))
tabbed_action.setCheckable(True)
tabbed_action.triggered.connect(self.toggle_view)
tabbed_action.setObjectName('tabbed_action')
tabbed_action.setIcon(QIcon('icons/tabbed.svg'))
prev_action = QAction(self.tr('&Previous'), self)
prev_action.setToolTip(self.tr('Select the previous tool window'))
prev_action.setShortcut(QKeySequence.PreviousChild)
prev_action.triggered.connect(self.mdi_area.activatePreviousSubWindow)
prev_action.setObjectName('prev_action')
prev_action.setIcon(QIcon('icons/previous.svg'))
next_action = QAction(self.tr('&Next'), self)
next_action.setToolTip(self.tr('Select the next tool window'))
next_action.setShortcut(QKeySequence.NextChild)
next_action.triggered.connect(self.mdi_area.activateNextSubWindow)
next_action.setObjectName('next_action')
next_action.setIcon(QIcon('icons/next.svg'))
tile_action = QAction(self.tr('&Tile'), self)
tile_action.setToolTip(
self.tr('Arrange windows into non-overlapping views'))
tile_action.setShortcut(QKeySequence(Qt.Key_F11))
tile_action.triggered.connect(self.mdi_area.tileSubWindows)
tile_action.setObjectName('tile_action')
tile_action.setIcon(QIcon('icons/tile.svg'))
cascade_action = QAction(self.tr('&Cascade'), self)
cascade_action.setToolTip(
self.tr('Arrange windows into overlapping views'))
cascade_action.setShortcut(QKeySequence(Qt.Key_F12))
cascade_action.triggered.connect(self.mdi_area.cascadeSubWindows)
cascade_action.setObjectName('cascade_action')
cascade_action.setIcon(QIcon('icons/cascade.svg'))
close_action = QAction(self.tr('Close &All'), self)
close_action.setToolTip(self.tr('Close all open tool windows'))
close_action.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_W))
close_action.triggered.connect(self.mdi_area.closeAllSubWindows)
close_action.setObjectName('close_action')
close_action.setIcon(QIcon('icons/close.svg'))
self.full_action = QAction(self.tr('Full screen'), self)
self.full_action.setToolTip(self.tr('Switch to full screen mode'))
self.full_action.setShortcut(QKeySequence.FullScreen)
self.full_action.triggered.connect(self.change_view)
self.full_action.setObjectName('full_action')
self.full_action.setIcon(QIcon('icons/full.svg'))
self.normal_action = QAction(self.tr('Normal view'), self)
self.normal_action.setToolTip(self.tr('Back to normal view mode'))
self.normal_action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_F12))
self.normal_action.triggered.connect(self.change_view)
self.normal_action.setObjectName('normal_action')
self.normal_action.setIcon(QIcon('icons/normal.svg'))
about_action = QAction(self.tr('&About...'), self)
about_action.setToolTip(self.tr('Information about this program'))
about_action.triggered.connect(self.show_about)
about_action.setObjectName('about_action')
about_action.setIcon(QIcon('icons/sherloq_alpha.png'))
about_qt_action = QAction(self.tr('About &Qt'), self)
about_qt_action.setToolTip(
self.tr('Information about the Qt Framework'))
about_qt_action.triggered.connect(QApplication.aboutQt)
about_qt_action.setIcon(QIcon('icons/Qt.svg'))
file_menu = self.menuBar().addMenu(self.tr('&File'))
file_menu.addAction(load_action)
file_menu.addSeparator()
self.recent_actions = [None] * self.max_recent
for i in range(len(self.recent_actions)):
self.recent_actions[i] = QAction(self)
self.recent_actions[i].setVisible(False)
self.recent_actions[i].triggered.connect(self.open_recent)
file_menu.addAction(self.recent_actions[i])
file_menu.addSeparator()
file_menu.addAction(quit_action)
view_menu = self.menuBar().addMenu(self.tr('&View'))
view_menu.addAction(tools_action)
view_menu.addAction(help_action)
view_menu.addSeparator()
view_menu.addAction(self.full_action)
view_menu.addAction(self.normal_action)
window_menu = self.menuBar().addMenu(self.tr('&Window'))
window_menu.addAction(prev_action)
window_menu.addAction(next_action)
window_menu.addSeparator()
window_menu.addAction(tile_action)
window_menu.addAction(cascade_action)
window_menu.addAction(tabbed_action)
window_menu.addSeparator()
window_menu.addAction(close_action)
help_menu = self.menuBar().addMenu(self.tr('&Help'))
help_menu.addAction(help_action)
help_menu.addSeparator()
help_menu.addAction(about_action)
help_menu.addAction(about_qt_action)
main_toolbar = self.addToolBar(self.tr('&Toolbar'))
main_toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
main_toolbar.addAction(load_action)
main_toolbar.addSeparator()
main_toolbar.addAction(tools_action)
main_toolbar.addAction(help_action)
main_toolbar.addSeparator()
main_toolbar.addAction(prev_action)
main_toolbar.addAction(next_action)
main_toolbar.addSeparator()
main_toolbar.addAction(tile_action)
main_toolbar.addAction(cascade_action)
main_toolbar.addAction(tabbed_action)
main_toolbar.addAction(close_action)
# main_toolbar.addSeparator()
# main_toolbar.addAction(self.normal_action)
# main_toolbar.addAction(self.full_action)
main_toolbar.setAllowedAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea)
main_toolbar.setObjectName('main_toolbar')
settings = QSettings()
settings.beginGroup('main_window')
self.restoreGeometry(settings.value('geometry'))
self.restoreState(settings.value('state'))
self.recent_files = settings.value('recent_files')
if self.recent_files is None:
self.recent_files = []
elif not isinstance(self.recent_files, list):
self.recent_files = [self.recent_files]
self.update_recent()
settings.endGroup()
prev_action.setEnabled(False)
next_action.setEnabled(False)
tile_action.setEnabled(False)
cascade_action.setEnabled(False)
close_action.setEnabled(False)
tabbed_action.setEnabled(False)
self.tree_widget.setEnabled(False)
self.showNormal()
self.normal_action.setEnabled(False)
self.show_message(self.tr('Ready'))
def change_view(self):
if self.isFullScreen():
self.showNormal()
self.showMaximized()
self.full_action.setEnabled(True)
self.normal_action.setEnabled(False)
else:
self.showFullScreen()
self.full_action.setEnabled(False)
self.normal_action.setEnabled(True)
def closeEvent(self, event):
settings = QSettings()
settings.beginGroup('main_window')
settings.setValue('geometry', self.saveGeometry())
settings.setValue('state', self.saveState())
settings.setValue('recent_files', self.recent_files)
settings.endGroup()
super(MainWindow, self).closeEvent(event)
def update_recent(self):
if not self.recent_files:
return
self.recent_files = [f for f in self.recent_files if os.path.isfile(f)]
for i in range(len(self.recent_actions)):
if i < len(self.recent_files):
text = '&{} {}'.format(i + 1,
os.path.basename(self.recent_files[i]))
self.recent_actions[i].setText(text)
self.recent_actions[i].setData(self.recent_files[i])
self.recent_actions[i].setVisible(True)
else:
self.recent_actions[i].setVisible(False)
def open_recent(self):
action = self.sender()
if action:
filename, basename, image = load_image(self, action.data())
self.initialize(filename, basename, image)
def initialize(self, filename, basename, image):
self.filename = filename
self.image = image
self.findChild(ToolTree, 'tree_widget').setEnabled(True)
self.findChild(QAction, 'prev_action').setEnabled(True)
self.findChild(QAction, 'next_action').setEnabled(True)
self.findChild(QAction, 'tile_action').setEnabled(True)
self.findChild(QAction, 'cascade_action').setEnabled(True)
self.findChild(QAction, 'close_action').setEnabled(True)
self.findChild(QAction, 'tabbed_action').setEnabled(True)
self.setWindowTitle('[{}] - {} {}'.format(
basename, QApplication.applicationName(),
QApplication.applicationVersion()))
if filename not in self.recent_files:
self.recent_files.insert(0, filename)
if len(self.recent_files) > self.max_recent:
self.recent_files = self.recent_files[:self.max_recent]
self.update_recent()
self.show_message(
self.tr('Image "{}" successfully loaded'.format(basename)))
# FIXME: disable_bold della chiusura viene chiamato DOPO open_tool e nell'albero la voce NON diventa neretto
self.mdi_area.closeAllSubWindows()
self.open_tool(self.tree_widget.topLevelItem(0).child(0), None)
def load_file(self):
filename, basename, image = load_image(self)
if filename is None:
return
self.initialize(filename, basename, image)
def open_tool(self, item, _):
if not item.data(0, Qt.UserRole):
return
group = item.data(0, Qt.UserRole + 1)
tool = item.data(0, Qt.UserRole + 2)
for sub_window in self.mdi_area.subWindowList():
if sub_window.windowTitle() == item.text(0):
sub_window.setWindowState(Qt.WindowActive)
sub_window.setFocus()
return
if group == 0:
if tool == 0:
tool_widget = OriginalWidget(self.image)
elif tool == 1:
tool_widget = DigestWidget(self.filename, self.image)
elif tool == 2:
tool_widget = EditorWidget()
elif tool == 3:
tool_widget = ReverseWidget()
else:
return
elif group == 1:
if tool == 0:
tool_widget = HeaderWidget(self.filename)
elif tool == 1:
tool_widget = ExifWidget(self.filename)
elif tool == 2:
tool_widget = ThumbWidget(self.filename, self.image)
elif tool == 3:
tool_widget = LocationWidget(self.filename)
else:
return
elif group == 2:
if tool == 0:
tool_widget = MagnifierWidget(self.image)
elif tool == 1:
tool_widget = HistWidget(self.image)
elif tool == 2:
tool_widget = AdjustWidget(self.image)
elif tool == 3:
tool_widget = ComparisonWidget(self.filename, self.image)
else:
return
elif group == 3:
if tool == 0:
tool_widget = GradientWidget(self.image)
elif tool == 1:
tool_widget = EchoWidget(self.image)
elif tool == 2:
tool_widget = WaveletWidget(self.image)
else:
return
elif group == 4:
if tool == 0:
tool_widget = PlotsWidget(self.image)
elif tool == 1:
tool_widget = SpaceWidget(self.image)
elif tool == 2:
tool_widget = PcaWidget(self.image)
elif tool == 3:
tool_widget = StatsWidget(self.image)
else:
return
elif group == 5:
if tool == 0:
tool_widget = NoiseWidget(self.image)
elif tool == 1:
tool_widget = MinMaxWidget(self.image)
elif tool == 2:
tool_widget = FrequencyWidget(self.image)
elif tool == 3:
tool_widget = PlanesWidget(self.image)
else:
return
elif group == 6:
if tool == 0:
tool_widget = ElaWidget(self.image)
elif tool == 1:
tool_widget = QualityWidget(self.filename)
elif tool == 2:
tool_widget = MultipleWidget(self.image)
else:
return
elif group == 7:
if tool == 0:
tool_widget = ContrastWidget(self.image)
elif tool == 1:
tool_widget = CloningWidget(self.image)
elif tool == 2:
# tool_widget = ResamplingWidget(self.image)
pass
else:
return
elif group == 8:
if tool == 3:
tool_widget = StereoWidget(self.image)
else:
return
else:
return
# FIXME: Aggiungere un metodo init e dopo fare il connect, sennò i messaggi inviati nel costruttore non si vedono
tool_widget.info_message.connect(self.show_message)
sub_window = QMdiSubWindow()
sub_window.setWidget(tool_widget)
sub_window.setWindowTitle(item.text(0))
sub_window.setObjectName(item.text(0))
sub_window.setAttribute(Qt.WA_DeleteOnClose)
sub_window.setWindowIcon(QIcon('icons/{}.svg'.format(group)))
self.mdi_area.addSubWindow(sub_window)
sub_window.show()
sub_window.destroyed.connect(self.disable_bold)
self.tree_widget.set_bold(item.text(0), enabled=True)
def disable_bold(self, item):
self.tree_widget.set_bold(item.windowTitle(), enabled=False)
def toggle_view(self, tabbed):
if tabbed:
self.mdi_area.setViewMode(QMdiArea.TabbedView)
self.mdi_area.setTabsClosable(True)
self.mdi_area.setTabsMovable(True)
else:
self.mdi_area.setViewMode(QMdiArea.SubWindowView)
self.findChild(QAction, 'tile_action').setEnabled(not tabbed)
self.findChild(QAction, 'cascade_action').setEnabled(not tabbed)
def show_about(self):
message = '<h2>{} {}</h2>'.format(QApplication.applicationName(),
QApplication.applicationVersion())
message += '<h3>A digital image forensic toolkit</h3>'
message += '<p>author: <a href="{}">{}</a></p>'.format(
QApplication.organizationDomain(), QApplication.organizationName())
message += '<p>source: <a href="https://github.com/GuidoBartoli/sherloq">GitHub repository</a></p>'
QMessageBox.about(self, self.tr('About'), message)
def show_message(self, message):
self.statusBar().showMessage(message, 10000)
class Window(QMainWindow, EditActions.Mixin, FileActions.Mixin,
HelpActions.Mixin, ItemsTreeView.Mixin, OptionsActions.Mixin,
PragmaView.Mixin, ViewActions.Mixin, SaveRestoreUi.Mixin):
def __init__(self, filename):
super().__init__()
self.setWindowTitle(f'{APPNAME} {VERSION}')
self.make_variables()
self.make_widgets()
self.make_actions()
self.make_connections()
qApp.commitDataRequest.connect(self.close)
options = self.load_options(filename)
self.update_ui()
QTimer.singleShot(0, lambda: self.initalize_toggle_actions(options))
def closeEvent(self, event):
self.closing = True
options = Config.MainWindowOptions(
state=self.saveState(),
geometry=self.saveGeometry(),
last_filename=str(self.db.filename or ''),
recent_files=list(self.recent_files),
show_items_tree=self.itemsTreeDock.isVisible(),
show_pragmas=self.pragmasDock.isVisible(),
show_as_tabs=self.mdiArea.viewMode() == QMdiArea.TabbedView)
Config.write_main_window_options(options)
self.clear()
event.accept()
def make_variables(self):
self.db = Db.Db()
self.path = self.export_path = QStandardPaths.writableLocation(
QStandardPaths.DocumentsLocation)
self.recent_files = RecentFiles.get(RECENT_FILES_MAX)
self.closing = False
def make_widgets(self):
self.mdiArea = QMdiArea()
self.mdiArea.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.mdiArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.mdiArea.setTabsClosable(True)
self.mdiArea.setTabsMovable(True)
self.setCentralWidget(self.mdiArea)
allowedAreas = Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea
view = ItemsTreeView.View(self.db)
self.itemsTreeDock = make_dock_widget(self, 'Items Tree', view,
Qt.LeftDockWidgetArea,
allowedAreas)
view = PragmaView.View(self.db)
self.pragmasDock = make_dock_widget(self, 'Pragmas', view,
Qt.RightDockWidgetArea,
allowedAreas)
# TODO Calendar dock widget
def make_actions(self):
self.make_file_actions()
self.file_menu = self.menuBar().addMenu('&File')
add_actions(self.file_menu, self.file_actions_for_menu)
self.file_toolbar = self.addToolBar('File')
self.file_toolbar.setObjectName('File')
add_actions(self.file_toolbar, self.file_actions_for_toolbar)
self.make_edit_actions()
self.edit_menu = self.menuBar().addMenu('&Edit')
add_actions(self.edit_menu, self.edit_actions_for_menu)
self.edit_toolbar = self.addToolBar('Edit')
self.edit_toolbar.setObjectName('Edit')
add_actions(self.edit_toolbar, self.edit_actions_for_toolbar)
self.make_view_actions()
self.view_menu = self.menuBar().addMenu('&View')
add_actions(self.view_menu, self.view_actions_for_menu)
self.view_toolbar = self.addToolBar('View')
self.view_toolbar.setObjectName('View')
add_actions(self.view_toolbar, self.view_actions_for_toolbar)
# TODO record actions & database actions & (sdi) window actions +
# update OptionsActions options_restore_toolbars()
self.make_options_actions()
self.options_menu = self.menuBar().addMenu('&Options')
add_actions(self.options_menu, self.options_actions_for_menu)
# self.options_toolbar = self.addToolBar('Options')
# self.options_toolbar.setObjectName('Options')
# add_actions(self.options_toolbar, self.options_actions_for_toolbar)
self.make_help_actions()
self.help_menu = self.menuBar().addMenu('&Help')
add_actions(self.help_menu, self.help_actions_for_menu)
def make_connections(self):
widget = self.itemsTreeDock.widget()
widget.itemDoubleClicked.connect(self.maybe_show_item)
widget.itemSelectionChanged.connect(self.view_update_ui)
# TODO
def load_options(self, filename):
options = Config.read_main_window_options()
if options.state is not None:
self.restoreState(options.state)
if options.geometry is not None:
self.restoreGeometry(options.geometry)
self.recent_files.load(options.recent_files)
if (not filename and options.last_filename
and pathlib.Path(options.last_filename).exists()):
filename = options.last_filename
if filename and not pathlib.Path(filename).exists():
filename = None
if filename:
if options.last_filename:
self.recent_files.add(options.last_filename)
self.file_load(filename)
else:
self.statusBar().showMessage(
'Click File→New or File→Open to open or create a database',
TIMEOUT_LONG)
return options
def initalize_toggle_actions(self, options):
self.itemsTreeDock.setVisible(options.show_items_tree)
self.view_update_toggle_action(options.show_items_tree)
show_pragmas = bool(self.db) and options.show_pragmas
self.pragmasDock.setVisible(show_pragmas)
self.view_pragmas_update_toggle_action(show_pragmas)
self.mdiArea.setViewMode(
QMdiArea.SubWindowView if options.show_as_tabs else
QMdiArea.TabbedView) # Start with the opposite
self.view_items_tree_toggle_tabs() # Toggle to correct & set action
def update_ui(self):
self.file_update_ui()
self.edit_update_ui()
self.view_update_ui()
# TODO record & database & (sdi) window actions
self.options_update_ui()
def clear(self):
self.maybe_save_ui()
widget = self.pragmasDock.widget()
widget.save(closing=self.closing)
widget.clear()
for widget in self.mdiArea.subWindowList():
widget.close() # Will save if dirty
def findSubWindow(self, name):
for widget in self.mdiArea.subWindowList():
if widget.windowTitle() == name:
return widget
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()