Readability/readability/__init__.py

# Readability - plugin for Falkon
# Copyright (C) 2019  Juraj Oravec <jurajoravec@netc.it>
#
# 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 <http://www.gnu.org/licenses/>.

import Falkon
import os
from PySide2 import QtCore, QtGui
from readability.settingsDialog import SettingsDialog
from readability.button import Button
from readability.str2bool import str2bool


class Readability(Falkon.PluginInterface, QtCore.QObject):
    config = None
    view = None
    buttons = None

    def init(self, state, settingsPath):
        self.config = {
            "settingsFile": os.path.join(settingsPath, "readability", "settings.ini"),
            "icon": "dark",
            "contextMenu": False
        }
        self.buttons = {}
        self.loadSettings()
        self.onConfigUpdate()

        plugins = Falkon.MainApplication.instance().plugins()

        plugins.mainWindowCreated.connect(self.onMainWindowCreated)
        plugins.mainWindowDeleted.connect(self.onMainWindowDeleted)

        if state == Falkon.PluginInterface.LateInitState:
            for window in Falkon.MainApplication.instance().windows():
                self.onMainWindowCreated(window)

    def unload(self):
        for window in Falkon.MainApplication.instance().windows():
            self.onMainWindowDeleted(window)

    def testPlugin(self):
        return True

    def onMainWindowCreated(self, window):
        button = Button(self.config["icon"])
        button.clicked.connect(lambda: self.makeReadability(button.webView()))

        window.navigationBar().addToolButton(button)
        self.buttons[window] = button

    def onMainWindowDeleted(self, window):
        if window in self.buttons:
            del self.buttons[window]

    def populateWebViewMenu(self, menu, view, hitTestResult):
        if not self.config["contextMenu"]:
            return

        self.view = view

        if (hitTestResult.imageUrl().isEmpty()
                and hitTestResult.linkUrl().isEmpty()
                and hitTestResult.mediaUrl().isEmpty()
                and not hitTestResult.isContentEditable()
                and not hitTestResult.isContentSelected()):
            icon = "icon-light.png" if self.config["icon"] == "light" else "icon-dark.png"
            menu.addAction(
                QtGui.QIcon(os.path.join(os.path.dirname(__file__), "data", icon)),
                "Readability",
                self.makeReadability
            )

    def makeReadability(self, view=None):
        if view:
            self.view = view

        dataDir = os.path.join(os.path.dirname(__file__), "data")

        iconClose = Falkon.QzTools.pixmapToDataUrl(
            QtGui.QPixmap(os.path.join(dataDir, "RM-close.png"))
        ).toString()
        iconCloseHover = Falkon.QzTools.pixmapToDataUrl(
            QtGui.QPixmap(os.path.join(dataDir, "RM-close-hover.png"))
        ).toString()
        iconDelete = Falkon.QzTools.pixmapToDataUrl(
            QtGui.QPixmap(os.path.join(dataDir, "RM-Delete-24x24.png"))
        ).toString()
        iconPlus = Falkon.QzTools.pixmapToDataUrl(
            QtGui.QPixmap(os.path.join(dataDir, "RM-Plus-24x24.png"))
        ).toString()
        iconMinus = Falkon.QzTools.pixmapToDataUrl(
            QtGui.QPixmap(os.path.join(dataDir, "RM-Minus-24x24.png"))
        ).toString()
        iconArrow = Falkon.QzTools.readAllFileContents(
            os.path.join(dataDir, "RM-Type-Controls-Arrow.png")
        )
        iconControls = Falkon.QzTools.pixmapToDataUrl(
            QtGui.QPixmap(os.path.join(dataDir, "RM-Type-Controls-24x24.png"))
        ).toString()

        css = Falkon.QzTools.readAllFileContents(
            os.path.join(dataDir, "style.css")
        ).replace("\n", "")
        css = css.replace("{1}", iconClose)
        css = css.replace("{2}", iconCloseHover)
        css = css.replace("{3}", iconDelete)
        css = css.replace("{4}", iconPlus)
        css = css.replace("{5}", iconMinus)
        css = css.replace("{6}", iconArrow)
        css = css.replace("{7}", iconControls)

        javascript = Falkon.QzTools.readAllFileContents(
            os.path.join(dataDir, "Readability.js")
        )
        toolbar = Falkon.QzTools.readAllFileContents(
            os.path.join(dataDir, "Toolbar.js")
        )
        call = Falkon.QzTools.readAllFileContents(
            os.path.join(dataDir, "Call.js")
        )
        call = call.replace("{1}", javascript)
        call = call.replace("{2}", toolbar)
        call = call.replace("{3}", css)

        self.view.page().runJavaScript(call)

    def showSettings(self, parent):
        settings = SettingsDialog(self.config, parent)
        settings.accepted.connect(self.saveSettings)
        settings.accepted.connect(self.onConfigUpdate)
        settings.exec_()

    def saveSettings(self):
        settings = QtCore.QSettings(self.config["settingsFile"], QtCore.QSettings.IniFormat)

        settings.beginGroup("Readability")
        settings.setValue("icon", self.config["icon"])
        settings.setValue("showInContextMenu", self.config["contextMenu"])
        settings.endGroup()

        settings.sync()

    def loadSettings(self):
        settings = QtCore.QSettings(self.config["settingsFile"], QtCore.QSettings.IniFormat)

        settings.beginGroup("Readability")
        self.config["icon"] = str(settings.value("icon", self.config["icon"]))
        self.config["contextMenu"] = str2bool(
            settings.value("showInContextMenu", self.config["contextMenu"])
        )
        settings.endGroup()

    def onConfigUpdate(self):
        for _, button in self.buttons.items():
            button.updateIcon(self.config["icon"])


Falkon.registerPlugin(Readability())