eric: comparison src/eric7/PdfViewer/PdfViewerWindow.py

-:69e183e4db6f
+:92dcd34d54e4
 """
 Module implementing the PDF viewer main window.
 """
 import contextlib
+import math
 import os
 import pathlib
 from PyQt6.QtCore import Qt, pyqtSignal, QSize, pyqtSlot, QPointF
 from PyQt6.QtGui import QAction, QKeySequence
 from PyQt6.QtPdf import QPdfDocument
 from PyQt6.QtPdfWidgets import QPdfView
 from PyQt6.QtWidgets import (
-QWhatsThis, QMenu, QTabWidget, QSplitter, QSpinBox, QAbstractSpinBox
+QWhatsThis, QMenu, QTabWidget, QSplitter, QToolBar, QDialog
 )
 from eric7 import Preferences
 from eric7.EricGui import EricPixmapCache
 from eric7.EricGui.EricAction import EricAction
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricMainWindow import EricMainWindow
+from eric7.EricWidgets.EricStretchableSpacer import EricStretchableSpacer
 from eric7.Globals import recentNamePdfFiles
 from eric7.SystemUtilities import FileSystemUtilities
 from .PdfPageSelector import PdfPageSelector
+from .PdfZoomSelector import PdfZoomSelector
+# TODO: make this an eric widget
 class PdfViewerWindow(EricMainWindow):
 """
 Class implementing the PDF viewer main window.
 viewerClosed = pyqtSignal()
 windows = []
 maxMenuFilePathLen = 75
+ZoomMultiplier = math.sqrt(2.0)
 def __init__(self, fileName="", parent=None, fromEric=False, project=None):
 """
 Constructor
 self.__view.setPageMode(QPdfView.PageMode.MultiPage)
 self.__cw.addWidget(self.__view)
 self.setCentralWidget(self.__cw)
 # create a few widgets needed in the toolbars
-self.__pageSelector = PdfPageSelector()
+self.__pageSelector = PdfPageSelector(self)
 self.__pageSelector.setDocument(self.__pdfDocument)
 self.__view.pageNavigator().currentPageChanged.connect(
 self.__pageSelector.setValue
 )
 self.__pageSelector.valueChanged.connect(self.__pageSelected)
 self.__pageSelector.gotoPage.connect(self.__gotoPage)
+self.__zoomSelector = PdfZoomSelector(self)
+self.__zoomSelector.zoomModeChanged.connect(self.__view.setZoomMode)
+##self.__zoomSelector.zoomModeChanged.connect(self.__setFocusToView)
+self.__zoomSelector.zoomFactorChanged.connect(self.__view.setZoomFactor)
+##self.__zoomSelector.zoomFactorChanged.connect(self.__setFocusToView)
+self.__zoomSelector.reset()
 g = Preferences.getGeometry("PdfViewerGeometry")
 if g.isEmpty():
 s = QSize(1000, 1000)
 self.resize(s)
 self.backwardAct.setEnabled
 )
 self.__view.pageNavigator().forwardAvailableChanged.connect(
 self.forwardAct.setEnabled
 )
+self.__view.zoomFactorChanged.connect(self.__zoomSelector.setZoomFactor)
 PdfViewerWindow.windows.append(self)
-state = Preferences.getPdfViewer("PdfViewerState")
+self.__restoreViewerState()
-self.restoreState(state)
-splitterState = Preferences.getPdfViewer("PdfViewerSplitterState")
-self.__cw.restoreState(splitterState)
 self.__checkActions()
 self.__project = project
 self.__lastOpenPath = ""
 def __initGotoActions(self):
 """
 Private method to define the navigation related user interface actions.
 """
-# TODO: Goto page (goto dialog) (Ctrl+G)
 self.previousPageAct = EricAction(
 self.tr("Previous Page"),
 EricPixmapCache.getIcon("1leftarrow"),
 self.tr("&Previous Page"),
 0,
 self.tr("Go forward in the view history")
 )
 self.forwardAct.triggered.connect(self.__forwardInHistory)
 self.__actions.append(self.forwardAct)
+self.gotoAct = EricAction(
+self.tr("Go to Page"),
+EricPixmapCache.getIcon("gotoJump"),
+self.tr("&Go to Page..."),
+QKeySequence(self.tr("Ctrl+G", "Goto|Go to Page")),
+0,
+self,
+"pdfviewer_goto_gotopage",
+)
+self.gotoAct.setStatusTip(
+self.tr("Jump to a page selected via a dialog")
+)
+self.gotoAct.triggered.connect(self.__gotoPage)
+self.__actions.append(self.gotoAct)
 def __initViewActions(self):
 """
 Private method to define the view related user interface actions.
 """
-# Zoom in (Ctrl++)
-# Zoom out (Ctrl+-)
-# Zoom reset (Ctrl+0)
 # Page Width (checkable, exclusive)
 # Whole Page (checkable, exclusive)
+self.zoomInAct = EricAction(
+self.tr("Zoom in"),
+EricPixmapCache.getIcon("zoomIn"),
+self.tr("Zoom &in"),
+QKeySequence(self.tr("Ctrl++", "View|Zoom in")),
+0,
+self,
+"pdfviewer_view_zoomin",
+)
+self.zoomInAct.triggered.connect(self.__zoomIn)
+self.__actions.append(self.zoomInAct)
+self.zoomOutAct = EricAction(
+self.tr("Zoom out"),
+EricPixmapCache.getIcon("zoomOut"),
+self.tr("Zoom &out"),
+QKeySequence(self.tr("Ctrl+-", "View|Zoom out")),
+0,
+self,
+"pdfviewer_view_zoomout",
+)
+self.zoomOutAct.triggered.connect(self.__zoomOut)
+self.__actions.append(self.zoomOutAct)
+self.zoomResetAct = EricAction(
+self.tr("Zoom to 100%"),
+EricPixmapCache.getIcon("zoomReset"),
+self.tr("Zoom to &100%"),
+QKeySequence(self.tr("Ctrl+0", "View|Zoom reset")),
+0,
+self,
+"pdfviewer_view_zoomreset",
+)
+self.zoomResetAct.triggered.connect(self.__zoomReset)
+self.__actions.append(self.zoomResetAct)
 def __initHelpActions(self):
 """
 Private method to create the Help actions.
 """
 @pyqtSlot()
 def __checkActions(self):
 """
 Private slot to check some actions for their enable/disable status.
 """
-self.reloadAct.setEnabled(
+ready = self.__pdfDocument.status() == QPdfDocument.Status.Ready
-self.__pdfDocument.status() == QPdfDocument.Status.Ready
-)
+self.reloadAct.setEnabled(ready)
+self.propertiesAct.setEnabled(ready)
 curPage = self.__view.pageNavigator().currentPage()
-self.previousPageAct.setEnabled(curPage > 0)
+self.previousPageAct.setEnabled(curPage > 0 and ready)
-self.nextPageAct.setEnabled(curPage < self.__pdfDocument.pageCount() - 1)
+self.nextPageAct.setEnabled(
-self.startDocumentAct.setEnabled(curPage != 0)
+curPage < self.__pdfDocument.pageCount() - 1 and ready
-self.endDocumentAct.setEnabled(curPage != self.__pdfDocument.pageCount() - 1)
+)
+self.startDocumentAct.setEnabled(curPage != 0 and ready)
+self.endDocumentAct.setEnabled(
+curPage != self.__pdfDocument.pageCount() - 1 and ready
+)
+self.gotoAct.setEnabled(ready)
 self.backwardAct.setEnabled(self.__view.pageNavigator().backAvailable())
 self.forwardAct.setEnabled(self.__view.pageNavigator().forwardAvailable())
+self.zoomInAct.setEnabled(ready)
+self.zoomOutAct.setEnabled(ready)
+self.zoomResetAct.setEnabled(ready)
+self.__zoomSelector.setEnabled(ready)
 # TODO: not yet implemented
 ##def setRecentPath(self, openPath):
 ##"""
 menu.addAction(self.exitAct)
 menu.aboutToShow.connect(self.__showFileMenu)
 self.__recentMenu.aboutToShow.connect(self.__showRecentMenu)
 self.__recentMenu.triggered.connect(self.__openRecentPdfFile)
+menu = mb.addMenu(self.tr("&View"))
+menu.setTearOffEnabled(True)
+menu.addAction(self.zoomInAct)
+menu.addAction(self.zoomOutAct)
+menu.addAction(self.zoomResetAct)
+# TODO: not yet implemented
 menu = mb.addMenu(self.tr("&Go To"))
 menu.setTearOffEnabled(True)
 menu.addAction(self.previousPageAct)
 menu.addAction(self.nextPageAct)
 menu.addSeparator()
 menu.addAction(self.endDocumentAct)
 menu.addSeparator()
 menu.addAction(self.backwardAct)
 menu.addAction(self.forwardAct)
 menu.addSeparator()
-# TODO: not yet implemented
+menu.addAction(self.gotoAct)
 mb.addSeparator()
 menu = mb.addMenu(self.tr("&Help"))
 menu.addAction(self.aboutAct)
 def __initToolbars(self):
 """
 Private method to create the toolbars.
 """
-filetb = self.addToolBar(self.tr("File"))
+mainToolBar = QToolBar()
-filetb.setObjectName("FileToolBar")
+mainToolBar.setObjectName("main_toolbar")
-filetb.addAction(self.newWindowAct)
+mainToolBar.setMovable(False)
-filetb.addAction(self.openAct)
+mainToolBar.setFloatable(False)
-filetb.addSeparator()
-filetb.addAction(self.closeAct)
+# 1. File actions
+mainToolBar.addAction(self.newWindowAct)
+mainToolBar.addAction(self.openAct)
+mainToolBar.addSeparator()
+mainToolBar.addAction(self.closeAct)
 if not self.__fromEric:
-filetb.addAction(self.exitAct)
+mainToolBar.addAction(self.exitAct)
+mainToolBar.addSeparator()
-gototb = self.addToolBar(self.tr("Goto"))
-gototb.setObjectName("GotoToolBar")
+# 2. Go to actions
-gototb.addAction(self.startDocumentAct)
+mainToolBar.addWidget(EricStretchableSpacer())
-gototb.addWidget(self.__pageSelector)
+mainToolBar.addAction(self.startDocumentAct)
-gototb.addAction(self.endDocumentAct)
+mainToolBar.addWidget(self.__pageSelector)
+mainToolBar.addAction(self.endDocumentAct)
-viewtb = self.addToolBar(self.tr("View"))
+mainToolBar.addWidget(EricStretchableSpacer())
-viewtb.setObjectName("ViewToolBar")
+mainToolBar.addSeparator()
+# 3. View actions
 # TODO: not yet implemented
+mainToolBar.addAction(self.zoomOutAct)
-helptb = self.addToolBar(self.tr("Help"))
+mainToolBar.addWidget(self.__zoomSelector)
-helptb.setObjectName("HelpToolBar")
+mainToolBar.addAction(self.zoomInAct)
-helptb.addAction(self.whatsThisAct)
+mainToolBar.addAction(self.zoomResetAct)
+self.addToolBar(mainToolBar)
+self.addToolBarBreak()
 def __createStatusBar(self):
 """
 Private method to initialize the status bar.
 """
 Protected method handling the close event.
 @param evt reference to the close event
 @type QCloseEvent
 """
+Preferences.setGeometry("PdfViewerGeometry", self.saveGeometry())
+self.__saveViewerState()
+with contextlib.suppress(ValueError):
+if self.__fromEric or len(PdfViewerWindow.windows) > 1:
+PdfViewerWindow.windows.remove(self)
+self.__saveRecent()
+evt.accept()
+self.viewerClosed.emit()
+def __saveViewerState(self):
+"""
+Private method to save the PDF Viewer state data.
+"""
+# TODO: save current zoom factor and mode + page mode
 state = self.saveState()
 Preferences.setPdfViewer("PdfViewerState", state)
 splitterState = self.__cw.saveState()
 Preferences.setPdfViewer("PdfViewerSplitterState", splitterState)
-Preferences.setGeometry("PdfViewerGeometry", self.saveGeometry())
-with contextlib.suppress(ValueError):
-if self.__fromEric or len(PdfViewerWindow.windows) > 1:
-PdfViewerWindow.windows.remove(self)
 if not self.__fromEric:
 Preferences.syncPreferences()
-self.__saveRecent()
+def __restoreViewerState(self):
+"""
-evt.accept()
+Private method to restore the PDF Viewer state data.
-self.viewerClosed.emit()
+"""
+# TODO: restore zoom factor and mode + page mode
+state = Preferences.getPdfViewer("PdfViewerState")
+self.restoreState(state)
+splitterState = Preferences.getPdfViewer("PdfViewerSplitterState")
+self.__cw.restoreState(splitterState)
 def __setViewerTitle(self, title):
 """
 Private method to set the viewer title.
 Private method to load a PDF file.
 @param fileName path of the PDF file to load
 @type str
 """
+# TODO: if error is QPdfDocument.Error.IncorrectPassword ask for PW and try
+#       again until cancelled
 err = self.__pdfDocument.load(fileName)
 if err != QPdfDocument.Error.None_:
 EricMessageBox.critical(
 self,
 self.tr("Load PDF File"),
 Private method to open a file from the list of recently opened files.
 @param act reference to the action that triggered
 @type QAction
 """
+# TODO: add config option to open recent files in new viewer or the same one
 fileName = act.data()
 self.__loadPdfFile(fileName)
 @pyqtSlot()
 def __clearRecent(self):
 def __gotoPage(self):
 """
 Private slot to show a dialog to select a page to jump to.
 """
 # TODO: not yet implemented
+from .PdfGoToDialog import PdfGoToDialog
+dlg = PdfGoToDialog(
+self.__view.pageNavigator().currentPage(),
+self.__pdfDocument.pageCount(),
+self,
+)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+page = dlg.getPage()
+self.__pageSelected(page)
 @pyqtSlot()
 def __previousPage(self):
 """
 Private slot to go to the previous page.
 def __forwardInHistory(self):
 """
 Private slot to go forward in the view history.
 """
 self.__view.pageNavigator().forward()
+def __calculateZoomFactor(self):
+if self.__view.ZoomMode == QPdfView.ZoomMode.FitToWidth:
+pass
+else:
+return self.__view.zoomFactor()
+@pyqtSlot()
+def __zoomIn(self):
+"""
+Private slot to zoom into the view.
+"""
+self.__view.setZoomFactor(
+self.__view.zoomFactor() * PdfViewerWindow.ZoomMultiplier
+)
+@pyqtSlot()
+def __zoomOut(self):
+"""
+Private slot to zoom out of the view.
+"""
+self.__view.setZoomFactor(
+self.__view.zoomFactor() / PdfViewerWindow.ZoomMultiplier
+)
+@pyqtSlot()
+def __zoomReset(self):
+"""
+Private slot to reset the zoom factor of the view.
+"""
+self.__view.setZoomFactor(1.0)
+@pyqtSlot()
+def __setFocusToView(self):
+"""
+Private slot to set the focus to the PDF document view.
+"""
+self.__view.setFocus(Qt.FocusReason.OtherFocusReason)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/PdfViewer/PdfViewerWindow.py

src/eric7/PdfViewer/PdfViewerWindow.py