novelWriter 2.2.1__py3-none-any.whl → 2.3b1__py3-none-any.whl

novelwriter/extensions/switch.py

@@ -24,31 +24,22 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 
 from PyQt5.QtGui import QMouseEvent, QPainter, QPaintEvent, QResizeEvent
-from PyQt5.QtCore import QEvent, QPropertyAnimation, QRectF, Qt, pyqtProperty
+from PyQt5.QtCore import QEvent, QPropertyAnimation, Qt, pyqtProperty
 from PyQt5.QtWidgets import QAbstractButton, QSizePolicy, QWidget
 
 from novelwriter import CONFIG
-from novelwriter.constants import nwUnicode
 
 
 class NSwitch(QAbstractButton):
 
-    def __init__(self, parent: QWidget | None = None,
-                 width: int | None = None, height: int | None = None) -> None:
-        super().__init__(parent=parent)
-
-        if width is None:
-            self._xW = CONFIG.pxInt(40)
-        else:
-            self._xW = width
+    __slots__ = ("_xW", "_xH", "_xR", "_rB", "_rH", "_rR", "_offset")
 
-        if height is None:
-            self._xH = CONFIG.pxInt(20)
-        else:
-            self._xH = height
+    def __init__(self, parent: QWidget | None = None, height: int = 0) -> None:
+        super().__init__(parent=parent)
 
+        self._xH = height or CONFIG.pxInt(20)
+        self._xW = 2*self._xH
         self._xR = int(self._xH*0.5)
-        self._xT = int(self._xH*0.6)
         self._rB = int(CONFIG.guiScale*2)
         self._rH = self._xH - 2*self._rB
         self._rR = self._xR - self._rB
@@ -70,7 +61,7 @@ class NSwitch(QAbstractButton):
         return self._offset
 
     @offset.setter  # type: ignore
-    def offset(self, offset: int):
+    def offset(self, offset: int) -> None:
         self._offset = offset
         self.update()
         return
@@ -82,10 +73,7 @@ class NSwitch(QAbstractButton):
     def setChecked(self, checked: bool) -> None:
         """Overload setChecked to also alter the offset."""
         super().setChecked(checked)
-        if checked:
-            self._offset = self._xW - self._xR
-        else:
-            self._offset = self._xR
+        self._offset = (self._xW - self._xR) if checked else self._xR
         return
 
     ##
@@ -95,53 +83,36 @@ class NSwitch(QAbstractButton):
     def resizeEvent(self, event: QResizeEvent) -> None:
         """Overload resize to ensure correct offset."""
         super().resizeEvent(event)
-        if self.isChecked():
-            self._offset = self._xW - self._xR
-        else:
-            self._offset = self._xR
+        self._offset = (self._xW - self._xR) if self.isChecked() else self._xR
         return
 
     def paintEvent(self, event: QPaintEvent) -> None:
         """Drawing the switch itself."""
-        qPaint = QPainter(self)
-        qPaint.setRenderHint(QPainter.Antialiasing, True)
-        qPaint.setPen(Qt.NoPen)
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing, True)
+        painter.setPen(Qt.NoPen)
 
-        qPalette = self.palette()
+        palette = self.palette()
         if self.isChecked():
-            trackBrush = qPalette.highlight()
-            thumbBrush = qPalette.highlightedText()
-            textColor = qPalette.highlight().color()
-            thumbText = nwUnicode.U_CHECK
+            trackBrush = palette.highlight()
+            thumbBrush = palette.highlightedText()
         else:
-            trackBrush = qPalette.dark()
-            thumbBrush = qPalette.light()
-            textColor = qPalette.dark().color()
-            thumbText = nwUnicode.U_CROSS
+            trackBrush = palette.dark()
+            thumbBrush = palette.light()
 
         if self.isEnabled():
             trackOpacity = 1.0
         else:
             trackOpacity = 0.6
-            trackBrush = qPalette.shadow()
-            thumbBrush = qPalette.mid()
-            textColor = qPalette.shadow().color()
-
-        qPaint.setBrush(trackBrush)
-        qPaint.setOpacity(trackOpacity)
-        qPaint.drawRoundedRect(0, 0, self._xW, self._xH, self._xR, self._xR)
-
-        qPaint.setBrush(thumbBrush)
-        qPaint.drawEllipse(self._offset - self._rR, self._rB, self._rH, self._rH)
-
-        font = qPaint.font()
-        font.setPixelSize(self._xT)
-        qPaint.setPen(textColor)
-        qPaint.setFont(font)
-        qPaint.drawText(
-            QRectF(self._offset - self._rR, self._rB, self._rH, self._rH),
-            Qt.AlignCenter, thumbText
-        )
+            trackBrush = palette.shadow()
+            thumbBrush = palette.mid()
+
+        painter.setBrush(trackBrush)
+        painter.setOpacity(trackOpacity)
+        painter.drawRoundedRect(0, 0, self._xW, self._xH, self._xR, self._xR)
+
+        painter.setBrush(thumbBrush)
+        painter.drawEllipse(self._offset - self._rR, self._rB, self._rH, self._rH)
 
         return
 
@@ -149,14 +120,11 @@ class NSwitch(QAbstractButton):
         """Animate the switch on mouse release."""
         super().mouseReleaseEvent(event)
         if event.button() == Qt.LeftButton:
-            doAnim = QPropertyAnimation(self, b"offset", self)
-            doAnim.setDuration(120)
-            doAnim.setStartValue(self._offset)
-            if self.isChecked():
-                doAnim.setEndValue(self._xW - self._xR)
-            else:
-                doAnim.setEndValue(self._xR)
-            doAnim.start()
+            anim = QPropertyAnimation(self, b"offset", self)
+            anim.setDuration(120)
+            anim.setStartValue(self._offset)
+            anim.setEndValue((self._xW - self._xR) if self.isChecked() else self._xR)
+            anim.start()
         return
 
     def enterEvent(self, event: QEvent) -> None:

novelwriter/extensions/switchbox.py

@@ -87,7 +87,7 @@ class NSwitchBox(QScrollArea):
         label = QLabel(text)
         self._content.addWidget(label, self._index, 1, Qt.AlignLeft)
 
-        switch = NSwitch(width=self._wSwitch, height=self._hSwitch)
+        switch = NSwitch(self, height=self._hSwitch)
         switch.setChecked(default)
         switch.toggled.connect(lambda state: self._emitSwitchSignal(identifier, state))
         self._content.addWidget(switch, self._index, 2, Qt.AlignRight)

novelwriter/extensions/versioninfo.py

@@ -0,0 +1,153 @@
+"""
+novelWriter – Custom Widget: Version Info
+=========================================
+
+File History:
+Created: 2024-02-14 [2.3b1] VersionInfoWidget
+
+This file is a part of novelWriter
+Copyright 2018–2024, Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import json
+import logging
+
+from time import sleep
+from datetime import datetime
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+from PyQt5.QtGui import QDesktopServices
+from PyQt5.QtCore import QObject, QRunnable, QUrl, pyqtSignal, pyqtSlot
+from PyQt5.QtWidgets import QLabel, QVBoxLayout, QWidget
+
+from novelwriter import CONFIG, SHARED, __version__, __date__, __domain__
+from novelwriter.common import formatVersion
+from novelwriter.constants import nwConst
+
+logger = logging.getLogger(__name__)
+
+API_URL = "https://api.github.com/repos/vkbo/novelwriter/releases/latest"
+
+
+class VersionInfoWidget(QWidget):
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+
+        # Label Strings
+        self._trLatest = self.tr("Latest Version: {0}")
+        self._trChecking = self.tr("Checking ...")
+        self._trDownload = self.tr("Download from {0}")
+
+        # Labels
+        self._lblInfo = QLabel("{0} {1} \u2013 {2} {3} \u2013 {4}".format(
+            self.tr("Version"), formatVersion(__version__),
+            self.tr("Released on"), datetime.strptime(__date__, "%Y-%m-%d").strftime("%x"),
+            "<a href='#notes'>{0}</a>".format(self.tr("Release Notes")),
+        ), self)
+        self._lblInfo.linkActivated.connect(self._processLink)
+        self._lblRelease = QLabel(self._trLatest.format(
+            "<a href='#update'>{0}</a>".format(self.tr("Check Now"))
+        ), self)
+        self._lblRelease.linkActivated.connect(self._processLink)
+
+        # Assemble
+        self._layout = QVBoxLayout()
+        self._layout.addWidget(self._lblInfo)
+        self._layout.addWidget(self._lblRelease)
+        self._layout.setSpacing(CONFIG.pxInt(2))
+        self._layout.setContentsMargins(0, 0, 0, 0)
+
+        self.setLayout(self._layout)
+
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(str)
+    def _processLink(self, link: str) -> None:
+        """Process an activated link."""
+        if link == "#notes":
+            QDesktopServices.openUrl(QUrl(nwConst.URL_RELEASES))
+        elif link == "#website":
+            QDesktopServices.openUrl(QUrl(nwConst.URL_WEB))
+        elif link == "#update":
+            self._lblRelease.setText(self._trLatest.format(self._trChecking))
+            lookup = _Retriever()
+            lookup.signals.dataReady.connect(self._updateReleaseInfo)
+            SHARED.runInThreadPool(lookup)
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(str, str)
+    def _updateReleaseInfo(self, tag: str, reason: str) -> None:
+        """Update the widget release info."""
+        if version := tag.lstrip("v"):
+            download = f"<a href='#website'>{__domain__}</a>"
+            self._lblRelease.setText(self._trLatest.format(
+                f"{version} \u2013 {self._trDownload.format(download)}"
+            ))
+        else:
+            self._lblRelease.setText(self._trLatest.format(reason or self.tr("Failed")))
+        return
+
+# END Class VersionInfoWidget
+
+
+class _Retriever(QRunnable):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.signals = _RetrieverSignal()
+        return
+
+    @pyqtSlot()
+    def run(self) -> None:
+        """Poll the GitHub API in the background.
+        Note: The GitHub API is rate limited at 60 requests per hour.
+        """
+        logger.info("Contacting: %s", API_URL)
+        req = Request(API_URL)
+        req.add_header("User-Agent", nwConst.USER_AGENT)
+        req.add_header("Accept", "application/vnd.github.v3+json")
+        sleep(0.2)
+        try:
+            with urlopen(req, timeout=15) as ret:
+                if isinstance(raw := json.loads(ret.read().decode()), dict):
+                    self.signals.dataReady.emit(raw.get("tag_name", ""), "")
+        except HTTPError as e:
+            reason = f"{e.reason.capitalize()} (HTTP {e.code})"
+            logger.error(reason)
+            self.signals.dataReady.emit("", reason)
+        except Exception as e:
+            logger.error("Failed to retrieve release info")
+            self.signals.dataReady.emit("", str(e))
+        return
+
+# END Class _Retriever
+
+
+class _RetrieverSignal(QObject):
+    dataReady = pyqtSignal(str, str)
+
+# END Class _RetrieverSignal