PySide6-Examples 6.7.0__cp39-abi3-win_amd64.whl

PySide6/examples/demos/documentviewer/recentfilemenu.py

@@ -0,0 +1,34 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtWidgets import QMenu
+from PySide6.QtCore import Signal, Slot
+
+
+class RecentFileMenu(QMenu):
+    fileOpened = Signal(str)
+
+    def __init__(self, parent, recent):
+        super().__init__(parent)
+        self._recentFiles = recent
+        self._recentFiles.changed.connect(self.updateList)
+        self._recentFiles.destroyed.connect(self.deleteLater)
+        self.updateList()
+
+    @Slot()
+    def updateList(self):
+        for a in self.actions():
+            del a
+
+        if not self._recentFiles:
+            self.addAction("<no recent files>")
+            return
+
+        for fileName in self._recentFiles.recentFiles():
+            action = self.addAction(fileName)
+            action.triggered.connect(self._emitFileOpened)
+
+    @Slot()
+    def _emitFileOpened(self):
+        action = self.sender()
+        self.fileOpened.emit(action.text())

PySide6/examples/demos/documentviewer/recentfiles.py

@@ -0,0 +1,159 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from enum import Enum, auto
+
+from PySide6.QtCore import QFileInfo, QObject, QSettings, Signal, Slot
+
+
+DEFAULT_MAX_FILES = 10
+
+
+# Test if file exists and can be opened
+def testFileAccess(fileName):
+    return QFileInfo(fileName).isReadable()
+
+
+class RemoveReason(Enum):
+    Other = auto()
+    Duplicate = auto()
+
+
+class EmitPolicy(Enum):
+    EmitWhenChanged = auto(),
+    NeverEmit = auto()
+
+
+s_maxFiles = "maxFiles"
+s_openMode = "openMode"
+s_fileNames = "fileNames"
+s_file = "file"
+
+
+class RecentFiles(QObject):
+
+    countChanged = Signal(int)
+    changed = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._maxFiles = DEFAULT_MAX_FILES
+        self._files = []
+
+    # Access to QStringList member functions
+    def recentFiles(self):
+        return self._files
+
+    def isEmpty(self):
+        return not self._files
+
+    # Properties
+    def maxFiles(self):
+        return self._maxFiles
+
+    def setMaxFiles(self, maxFiles):
+        self._maxFiles = maxFiles
+
+    def addFile(self, fileName):
+        self._addFile(fileName, EmitPolicy.EmitWhenChanged)
+
+    def removeFile(self, fileName):
+        idx = self._files.find(fileName)
+        self._removeFile(idx, RemoveReason.Other)
+
+    @Slot()
+    def clear(self):
+        if self.isEmpty():
+            return
+        self._files.clear()
+        self.countChanged.emit(0)
+
+    def _addFile(self, fileName, policy):
+        if not testFileAccess(fileName):
+            return
+
+        # Remember size, as cleanup can result in a change without size change
+        c = len(self._files)
+
+        # Clean dangling and duplicate files
+        i = 0
+        while i < len(self._files):
+            file = self._files[i]
+            if not testFileAccess(file):
+                self._removeFile(file, RemoveReason.Other)
+            elif file == fileName:
+                self._removeFile(file, RemoveReason.Duplicate)
+            else:
+                i += 1
+
+        # Cut tail
+        while len(self._files) > self._maxFiles:
+            self.removeFile((len(self._files) - 1), RemoveReason.Other)
+
+        self._files.insert(0, fileName)
+
+        if policy == EmitPolicy.NeverEmit:
+            return
+
+        if policy == EmitPolicy.EmitWhenChanged:
+            self.changed.emit()
+            if c != len(self._files):
+                self.countChanged.emit(len(self._files))
+
+    @Slot(list)
+    def addFiles(self, files):
+        if files.isEmpty():
+            return
+
+        if len(files) == 1:
+            self.addFile(files[0])
+            return
+
+        c = len(self._files)
+
+        for file in files:
+            self.addFile(file, EmitPolicy.NeverEmit)
+
+        self.changed.emit()
+        if len(self._files) != c:
+            self.countChanged.emit(len(self._files))
+
+    def _removeFile(self, p, reason):
+        index = p
+        if isinstance(p, str):
+            index = self._files.index(p) if p in self._files else -1
+        if index < 0 or index >= len(self._files):
+            return
+        del self._files[index]
+
+        # No emit for duplicate removal, add emits changed later.
+        if reason != RemoveReason.Duplicate:
+            self.changed.emit()
+
+    @Slot(QSettings, str)
+    def saveSettings(self, settings, key):
+        settings.beginGroup(key)
+        settings.setValue(s_maxFiles, self.maxFiles())
+        if self._files:
+            settings.beginWriteArray(s_fileNames, len(self._files))
+            for index, file in enumerate(self._files):
+                settings.setArrayIndex(index)
+                settings.setValue(s_file, file)
+            settings.endArray()
+        settings.endGroup()
+
+    @Slot(QSettings, str)
+    def restoreFromSettings(self, settings, key):
+        settings.beginGroup(key)
+        self.setMaxFiles(settings.value(s_maxFiles, DEFAULT_MAX_FILES, int))
+        self._files.clear()  # clear list without emitting
+        numberFiles = settings.beginReadArray(s_fileNames)
+        for index in range(0, numberFiles):
+            settings.setArrayIndex(index)
+            absoluteFilePath = settings.value(s_file)
+            self._addFile(absoluteFilePath, EmitPolicy.NeverEmit)
+        settings.endArray()
+        settings.endGroup()
+        if self._files:
+            self.changed.emit()
+        return True

PySide6/examples/demos/documentviewer/txtviewer/txtviewer.py

@@ -0,0 +1,144 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtWidgets import (QDialog, QFileDialog,
+                               QPlainTextEdit)
+from PySide6.QtGui import QAction, QGuiApplication, QIcon, QKeySequence
+from PySide6.QtCore import QDir, QFile, QTextStream, Qt, Slot
+
+from abstractviewer import AbstractViewer
+
+
+class TxtViewer(AbstractViewer):
+    def __init__(self):
+        super().__init__()
+        self.uiInitialized.connect(self.setupTxtUi)
+
+    def init(self, file, parent, mainWindow):
+        self._textEdit = QPlainTextEdit(parent)
+        super().init(file, self._textEdit, mainWindow)
+
+    def viewerName(self):
+        return "TxtViewer"
+
+    def supportedMimeTypes(self):
+        return ["text/plain"]
+
+    @Slot()
+    def setupTxtUi(self):
+        editMenu = self.addMenu("Edit")
+        editToolBar = self.addToolBar("Edit")
+        cutIcon = QIcon.fromTheme(QIcon.ThemeIcon.EditCut,
+                                  QIcon(":/demos/documentviewer/images/cut.png"))
+        cutAct = QAction(cutIcon, "Cut", self)
+        cutAct.setShortcuts(QKeySequence.Cut)
+        cutAct.setStatusTip("Cut the current selection's contents to the clipboard")
+        cutAct.triggered.connect(self._textEdit.cut)
+        editMenu.addAction(cutAct)
+        editToolBar.addAction(cutAct)
+
+        copyIcon = QIcon.fromTheme(QIcon.ThemeIcon.EditCopy,
+                                   QIcon(":/demos/documentviewer/images/copy.png"))
+        copyAct = QAction(copyIcon, "Copy", self)
+        copyAct.setShortcuts(QKeySequence.Copy)
+        copyAct.setStatusTip("Copy the current selection's contents to the clipboard")
+        copyAct.triggered.connect(self._textEdit.copy)
+        editMenu.addAction(copyAct)
+        editToolBar.addAction(copyAct)
+
+        pasteIcon = QIcon.fromTheme(QIcon.ThemeIcon.EditPaste,
+                                    QIcon(":/demos/documentviewer/images/paste.png"))
+        pasteAct = QAction(pasteIcon, "Paste", self)
+        pasteAct.setShortcuts(QKeySequence.Paste)
+        pasteAct.setStatusTip("Paste the clipboard's contents into the current selection")
+        pasteAct.triggered.connect(self._textEdit.paste)
+        editMenu.addAction(pasteAct)
+        editToolBar.addAction(pasteAct)
+
+        self.menuBar().addSeparator()
+
+        cutAct.setEnabled(False)
+        copyAct.setEnabled(False)
+        self._textEdit.copyAvailable.connect(cutAct.setEnabled)
+        self._textEdit.copyAvailable.connect(copyAct.setEnabled)
+
+        self.openFile()
+
+        self._textEdit.textChanged.connect(self._textChanged)
+        self._uiAssets_back.triggered.connect(self._back)
+        self._uiAssets_forward.triggered.connect(self._forward)
+
+    @Slot()
+    def _textChanged(self):
+        self.maybeSetPrintingEnabled(self.hasContent())
+
+    @Slot()
+    def _back(self):
+        bar = self._textEdit.verticalScrollBar()
+        if bar.value() > bar.minimum():
+            bar.setValue(bar.value() - 1)
+
+    @Slot()
+    def _forward(self):
+        bar = self._textEdit.verticalScrollBar()
+        if bar.value() < bar.maximum():
+            bar.setValue(bar.value() + 1)
+
+    def openFile(self):
+        type = "open"
+        file_name = QDir.toNativeSeparators(self._file.fileName())
+        if not self._file.open(QFile.ReadOnly | QFile.Text):
+            err = self._file.errorString()
+            self.statusMessage(f"Cannot read file {file_name}:\n{err}.", type)
+            return
+
+        in_str = QTextStream(self._file)
+        QGuiApplication.setOverrideCursor(Qt.WaitCursor)
+        if self._textEdit.toPlainText():
+            self._textEdit.clear()
+            self.disablePrinting()
+
+        self._textEdit.setPlainText(in_str.readAll())
+        QGuiApplication.restoreOverrideCursor()
+
+        self.statusMessage(f"File {file_name} loaded.", type)
+        self.maybeEnablePrinting()
+
+    def hasContent(self):
+        return bool(self._textEdit.toPlainText())
+
+    def printDocument(self, printer):
+        if not self.hasContent():
+            return
+
+        self._textEdit.print_(printer)
+
+    def saveFile(self, file):
+        file_name = QDir.toNativeSeparators(self._file.fileName())
+        errorMessage = ""
+        QGuiApplication.setOverrideCursor(Qt.WaitCursor)
+        if file.open(QFile.WriteOnly | QFile.Text):
+            out = QTextStream(file)
+            out << self._textEdit.toPlainText()
+        else:
+            error = file.errorString()
+            errorMessage = f"Cannot open file {file_name} for writing:\n{error}."
+        QGuiApplication.restoreOverrideCursor()
+
+        if errorMessage:
+            self.statusMessage(errorMessage)
+            return False
+
+        self.statusMessage(f"File {file_name} saved")
+        return True
+
+    def saveDocumentAs(self):
+        dialog = QFileDialog(self.mainWindow())
+        dialog.setWindowModality(Qt.WindowModal)
+        dialog.setAcceptMode(QFileDialog.AcceptSave)
+        if dialog.exec() != QDialog.Accepted:
+            return False
+
+        files = dialog.selectedFiles()
+        self._file.setFileName(files[0])
+        return self.saveDocument()

PySide6/examples/demos/documentviewer/ui_mainwindow.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'mainwindow.ui'
+##
+## Created by: Qt User Interface Compiler version 6.5.3
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QAction, QBrush, QColor, QConicalGradient,
+    QCursor, QFont, QFontDatabase, QGradient,
+    QIcon, QImage, QKeySequence, QLinearGradient,
+    QPainter, QPalette, QPixmap, QRadialGradient,
+    QTransform)
+from PySide6.QtWidgets import (QApplication, QMainWindow, QMenu, QMenuBar,
+    QScrollArea, QSizePolicy, QSplitter, QStatusBar,
+    QTabWidget, QToolBar, QVBoxLayout, QWidget)
+import rc_documentviewer
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        if not MainWindow.objectName():
+            MainWindow.setObjectName(u"MainWindow")
+        MainWindow.resize(983, 602)
+        icon = QIcon()
+        icon.addFile(u":/demos/documentviewer/images/qt-logo.png", QSize(), QIcon.Normal, QIcon.Off)
+        MainWindow.setWindowIcon(icon)
+        self.actionOpen = QAction(MainWindow)
+        self.actionOpen.setObjectName(u"actionOpen")
+        icon1 = QIcon()
+        icon1.addFile(u":/demos/documentviewer/images/open.png", QSize(), QIcon.Normal, QIcon.Off)
+        self.actionOpen.setIcon(icon1)
+        self.actionAbout = QAction(MainWindow)
+        self.actionAbout.setObjectName(u"actionAbout")
+        icon2 = QIcon()
+        iconThemeName = u"help-about"
+        if QIcon.hasThemeIcon(iconThemeName):
+            icon2 = QIcon.fromTheme(iconThemeName)
+        else:
+            icon2.addFile(u":/demos/documentviewer/images/help-about.svgz", QSize(), QIcon.Normal, QIcon.Off)
+
+        self.actionAbout.setIcon(icon2)
+        self.actionForward = QAction(MainWindow)
+        self.actionForward.setObjectName(u"actionForward")
+        icon3 = QIcon()
+        icon3.addFile(u":/demos/documentviewer/images/go-next.svgz", QSize(), QIcon.Normal, QIcon.Off)
+        self.actionForward.setIcon(icon3)
+        self.actionBack = QAction(MainWindow)
+        self.actionBack.setObjectName(u"actionBack")
+        icon4 = QIcon()
+        icon4.addFile(u":/demos/documentviewer/images/go-previous.svgz", QSize(), QIcon.Normal, QIcon.Off)
+        self.actionBack.setIcon(icon4)
+        self.actionPrint = QAction(MainWindow)
+        self.actionPrint.setObjectName(u"actionPrint")
+        self.actionPrint.setEnabled(False)
+        icon5 = QIcon()
+        iconThemeName = u"document-print"
+        if QIcon.hasThemeIcon(iconThemeName):
+            icon5 = QIcon.fromTheme(iconThemeName)
+        else:
+            icon5.addFile(u":/demos/documentviewer/images/print2x.png", QSize(), QIcon.Normal, QIcon.Off)
+
+        self.actionPrint.setIcon(icon5)
+        self.actionAboutQt = QAction(MainWindow)
+        self.actionAboutQt.setObjectName(u"actionAboutQt")
+        icon6 = QIcon()
+        icon6.addFile(u":/demos/documentviewer/images/qt-logo.png", QSize(), QIcon.Normal, QIcon.Off)
+        icon6.addFile(u":/demos/documentviewer/images/qt-logo.png", QSize(), QIcon.Normal, QIcon.On)
+        self.actionAboutQt.setIcon(icon6)
+        self.actionRecent = QAction(MainWindow)
+        self.actionRecent.setObjectName(u"actionRecent")
+        icon7 = QIcon()
+        icon7.addFile(u":/demos/documentviewer/images/document-open-recent.svgz", QSize(), QIcon.Normal, QIcon.Off)
+        self.actionRecent.setIcon(icon7)
+        self.actionQuit = QAction(MainWindow)
+        self.actionQuit.setObjectName(u"actionQuit")
+        icon8 = QIcon()
+        iconThemeName = u"application-exit"
+        if QIcon.hasThemeIcon(iconThemeName):
+            icon8 = QIcon.fromTheme(iconThemeName)
+        else:
+            icon8.addFile(u".", QSize(), QIcon.Normal, QIcon.Off)
+
+        self.actionQuit.setIcon(icon8)
+        self.centralwidget = QWidget(MainWindow)
+        self.centralwidget.setObjectName(u"centralwidget")
+        self.centralwidget.setEnabled(True)
+        self.verticalLayout = QVBoxLayout(self.centralwidget)
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.viewArea = QWidget(self.centralwidget)
+        self.viewArea.setObjectName(u"viewArea")
+        self.verticalLayout_2 = QVBoxLayout(self.viewArea)
+        self.verticalLayout_2.setObjectName(u"verticalLayout_2")
+        self.splitter = QSplitter(self.viewArea)
+        self.splitter.setObjectName(u"splitter")
+        self.splitter.setOrientation(Qt.Horizontal)
+        self.tabWidget = QTabWidget(self.splitter)
+        self.tabWidget.setObjectName(u"tabWidget")
+        self.tabWidget.setTabPosition(QTabWidget.West)
+        self.bookmarkTab = QWidget()
+        self.bookmarkTab.setObjectName(u"bookmarkTab")
+        self.tabWidget.addTab(self.bookmarkTab, "")
+        self.pagesTab = QWidget()
+        self.pagesTab.setObjectName(u"pagesTab")
+        self.tabWidget.addTab(self.pagesTab, "")
+        self.splitter.addWidget(self.tabWidget)
+        self.scrollArea = QScrollArea(self.splitter)
+        self.scrollArea.setObjectName(u"scrollArea")
+        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.scrollArea.sizePolicy().hasHeightForWidth())
+        self.scrollArea.setSizePolicy(sizePolicy)
+        self.scrollArea.setMinimumSize(QSize(800, 0))
+        self.scrollArea.setWidgetResizable(True)
+        self.scrollAreaWidgetContents = QWidget()
+        self.scrollAreaWidgetContents.setObjectName(u"scrollAreaWidgetContents")
+        self.scrollAreaWidgetContents.setGeometry(QRect(0, 0, 798, 479))
+        self.scrollArea.setWidget(self.scrollAreaWidgetContents)
+        self.splitter.addWidget(self.scrollArea)
+
+        self.verticalLayout_2.addWidget(self.splitter)
+
+
+        self.verticalLayout.addWidget(self.viewArea)
+
+        MainWindow.setCentralWidget(self.centralwidget)
+        self.menubar = QMenuBar(MainWindow)
+        self.menubar.setObjectName(u"menubar")
+        self.menubar.setGeometry(QRect(0, 0, 983, 23))
+        self.qtFileMenu = QMenu(self.menubar)
+        self.qtFileMenu.setObjectName(u"qtFileMenu")
+        self.menuHelp = QMenu(self.menubar)
+        self.menuHelp.setObjectName(u"menuHelp")
+        MainWindow.setMenuBar(self.menubar)
+        self.statusbar = QStatusBar(MainWindow)
+        self.statusbar.setObjectName(u"statusbar")
+        MainWindow.setStatusBar(self.statusbar)
+        self.mainToolBar = QToolBar(MainWindow)
+        self.mainToolBar.setObjectName(u"mainToolBar")
+        MainWindow.addToolBar(Qt.TopToolBarArea, self.mainToolBar)
+
+        self.menubar.addAction(self.qtFileMenu.menuAction())
+        self.menubar.addAction(self.menuHelp.menuAction())
+        self.qtFileMenu.addAction(self.actionOpen)
+        self.qtFileMenu.addAction(self.actionRecent)
+        self.qtFileMenu.addAction(self.actionPrint)
+        self.qtFileMenu.addAction(self.actionQuit)
+        self.menuHelp.addAction(self.actionAbout)
+        self.menuHelp.addAction(self.actionAboutQt)
+        self.mainToolBar.addAction(self.actionOpen)
+        self.mainToolBar.addAction(self.actionRecent)
+        self.mainToolBar.addAction(self.actionPrint)
+        self.mainToolBar.addSeparator()
+        self.mainToolBar.addAction(self.actionBack)
+        self.mainToolBar.addAction(self.actionForward)
+        self.mainToolBar.addSeparator()
+
+        self.retranslateUi(MainWindow)
+        self.actionQuit.triggered.connect(MainWindow.close)
+
+        self.tabWidget.setCurrentIndex(0)
+
+
+        QMetaObject.connectSlotsByName(MainWindow)
+    # setupUi
+
+    def retranslateUi(self, MainWindow):
+        MainWindow.setWindowTitle(QCoreApplication.translate("MainWindow", u"Document Viewer Demo", None))
+        self.actionOpen.setText(QCoreApplication.translate("MainWindow", u"Open", None))
+#if QT_CONFIG(shortcut)
+        self.actionOpen.setShortcut(QCoreApplication.translate("MainWindow", u"Ctrl+O", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionAbout.setText(QCoreApplication.translate("MainWindow", u"about documentviewer", None))
+#if QT_CONFIG(tooltip)
+        self.actionAbout.setToolTip(QCoreApplication.translate("MainWindow", u"Show information about the Document Viewer deomo.", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(shortcut)
+        self.actionAbout.setShortcut(QCoreApplication.translate("MainWindow", u"Ctrl+H", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionForward.setText(QCoreApplication.translate("MainWindow", u"actionForward", None))
+#if QT_CONFIG(tooltip)
+        self.actionForward.setToolTip(QCoreApplication.translate("MainWindow", u"One step forward", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(shortcut)
+        self.actionForward.setShortcut(QCoreApplication.translate("MainWindow", u"Right", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionBack.setText(QCoreApplication.translate("MainWindow", u"actionBack", None))
+#if QT_CONFIG(tooltip)
+        self.actionBack.setToolTip(QCoreApplication.translate("MainWindow", u"One step back", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(shortcut)
+        self.actionBack.setShortcut(QCoreApplication.translate("MainWindow", u"Left", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionPrint.setText(QCoreApplication.translate("MainWindow", u"Print", None))
+#if QT_CONFIG(tooltip)
+        self.actionPrint.setToolTip(QCoreApplication.translate("MainWindow", u"Print current file", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(shortcut)
+        self.actionPrint.setShortcut(QCoreApplication.translate("MainWindow", u"Ctrl+P", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionAboutQt.setText(QCoreApplication.translate("MainWindow", u"About Qt", None))
+#if QT_CONFIG(tooltip)
+        self.actionAboutQt.setToolTip(QCoreApplication.translate("MainWindow", u"Show Qt license information", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(shortcut)
+        self.actionAboutQt.setShortcut(QCoreApplication.translate("MainWindow", u"Ctrl+I", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionRecent.setText(QCoreApplication.translate("MainWindow", u"Recently opened...", None))
+#if QT_CONFIG(shortcut)
+        self.actionRecent.setShortcut(QCoreApplication.translate("MainWindow", u"Meta+R", None))
+#endif // QT_CONFIG(shortcut)
+        self.actionQuit.setText(QCoreApplication.translate("MainWindow", u"Quit", None))
+#if QT_CONFIG(tooltip)
+        self.actionQuit.setToolTip(QCoreApplication.translate("MainWindow", u"Quit the application", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(shortcut)
+        self.actionQuit.setShortcut(QCoreApplication.translate("MainWindow", u"Ctrl+Q", None))
+#endif // QT_CONFIG(shortcut)
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.bookmarkTab), QCoreApplication.translate("MainWindow", u"Pages", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.pagesTab), QCoreApplication.translate("MainWindow", u"Bookmarks", None))
+        self.qtFileMenu.setTitle(QCoreApplication.translate("MainWindow", u"File", None))
+        self.menuHelp.setTitle(QCoreApplication.translate("MainWindow", u"Help", None))
+        self.mainToolBar.setWindowTitle(QCoreApplication.translate("MainWindow", u"toolBar", None))
+    # retranslateUi
+

PySide6/examples/demos/documentviewer/viewerfactory.py

@@ -0,0 +1,114 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from enum import Enum, auto
+
+from PySide6.QtWidgets import (QMessageBox)
+from PySide6.QtCore import (QFileInfo, QMimeDatabase, QTimer)
+
+from txtviewer.txtviewer import TxtViewer
+from jsonviewer.jsonviewer import JsonViewer
+from pdfviewer.pdfviewer import PdfViewer
+
+
+class DefaultPolicy(Enum):
+    NeverDefault = auto()
+    DefaultToTxtViewer = auto()
+    DefaultToCustomViewer = auto()
+
+
+class ViewerFactory:
+
+    def __init__(self, displayWidget, mainWindow,
+                 policy=DefaultPolicy.NeverDefault):
+        self._viewers = {}
+        self._defaultViewer = None
+        self._defaultWarning = True
+        self._defaultPolicy = policy
+        self._displayWidget = displayWidget
+        self._mainWindow = mainWindow
+        self._mimeTypes = []
+        for v in [PdfViewer(), JsonViewer(), TxtViewer()]:
+            self._viewers[v.viewerName()] = v
+            if v.isDefaultViewer():
+                self._defaultViewer = v
+
+    def defaultPolicy(self):
+        return self._defaultPolicy
+
+    def setDefaultPolicy(self, policy):
+        self._defaultPolicy = policy
+
+    def defaultWarning(self):
+        return self._defaultWarning
+
+    def setDefaultWarning(self, on):
+        self._defaultWarning = on
+
+    def viewer(self, file):
+        info = QFileInfo(file)
+        db = QMimeDatabase()
+        mimeType = db.mimeTypeForFile(info)
+
+        viewer = self.viewerForMimeType(mimeType)
+        if not viewer:
+            print(f"Mime type {mimeType.name()} not supported.")
+            return None
+
+        viewer.init(file, self._displayWidget, self._mainWindow)
+        return viewer
+
+    def viewerNames(self, showDefault=False):
+        if not showDefault:
+            return self._viewers.keys()
+
+        list = []
+        for name, viewer in self._viewers.items():
+            if ((self._defaultViewer and viewer.isDefaultViewer())
+                    or (not self._defaultViewer and name == "TxtViewer")):
+                name += "(default)"
+            list.append(name)
+        return list
+
+    def viewers(self):
+        return self._viewers.values()
+
+    def findViewer(self, viewerName):
+        for viewer in self.viewers():
+            if viewer.viewerName() == viewerName:
+                return viewer
+        print(f"Plugin {viewerName} not loaded.")
+        return None
+
+    def viewerForMimeType(self, mimeType):
+        for viewer in self.viewers():
+            for type in viewer.supportedMimeTypes():
+                if mimeType.inherits(type):
+                    return viewer
+
+        viewer = self.defaultViewer()
+
+        if self._defaultWarning:
+            mbox = QMessageBox()
+            mbox.setIcon(QMessageBox.Warning)
+            name = mimeType.name()
+            viewer_name = viewer.viewerName()
+            m = f"Mime type {name} not supported. Falling back to {viewer_name}."
+            mbox.setText(m)
+            mbox.setStandardButtons(QMessageBox.Ok)
+            QTimer.singleShot(8000, mbox.close)
+            mbox.exec()
+        return viewer
+
+    def defaultViewer(self):
+        if self._defaultPolicy == DefaultPolicy.NeverDefault:
+            return None
+        if self._defaultPolicy == DefaultPolicy.DefaultToCustomViewer and self._defaultViewer:
+            return self._defaultViewer
+        return self.findViewer("TxtViewer")
+
+    def supportedMimeTypes(self):
+        if not self._mimeTypes:
+            for viewer in self.viewers():
+                self._mimeTypes.extend(viewer.supportedMimeTypes())
+        return self._mimeTypes