Mercurial Repositories > eric / file revision

# -*- coding: utf-8 -*-

# Copyright (c) 2016 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing a scheme handler for the eric: scheme.
"""

from __future__ import unicode_literals

from PyQt5.QtCore import pyqtSignal, QByteArray, QBuffer, QIODevice, \
    QTextStream, QUrlQuery
from PyQt5.QtWebEngineCore import QWebEngineUrlSchemeHandler

from ..Tools.WebBrowserTools import readAllFileContents

class EricSchemeHandler(QWebEngineUrlSchemeHandler):
    """
    Class implementing a scheme handler for the eric: scheme.
    """
    SupportedPages = [
        "adblock",          # error page for URLs blocked by AdBlock
    ]
    
    def __init__(self, parent=None):
        """
        Constructor
        
        @param parent reference to the parent object
        @type QObject
        """
        super(EricSchemeHandler, self).__init__(parent)
        
        self.__replies = []
    
    def requestStarted(self, job):
        """
        Public method handling the URL request.
        
        @param job URL request job
        @type QWebEngineUrlRequestJob
        """
        if job.requestUrl().path() in self.SupportedPages:
            reply = EricSchemeReply(job)
            reply.closed.connect(self.__replyClosed)
            self.__replies.append(reply)
            job.reply(b"text/html", reply)
        else:
            job.reply(QByteArray(), QBuffer())
            # job.fail(QWebEngineUrlRequestJob.UrlNotFound)
    
    def __replyClosed(self):
        """
        Private slot handling the closed signal of a reply.
        """
        object = self.sender()
        if object and object in self.__replies:
            self.__replies.remove(object)


class EricSchemeReply(QIODevice):
    """
    Class implementing a reply for a requested eric: page.
    
    @signal closed emitted to signal that the web engine has read
        the data
    """
    closed = pyqtSignal()
    
    def __init__(self, job, parent=None):
        """
        Constructor
        
        @param job reference to the URL request
        @type QWebEngineUrlRequestJob
        @param parent reference to the parent object
        @type QObject
        """
        super(EricSchemeReply, self).__init__(parent)
        
        self.__loaded = False
        self.__job = job
        
        self.__pageName = self.__job.requestUrl().path()
        self.__buffer = QBuffer()
        
        self.open(QIODevice.ReadOnly)
        self.__buffer.open(QIODevice.ReadWrite)
        self.__loadPage()
    
    def __loadPage(self):
        """
        Private method to load the requested page.
        """
        if self.__loaded:
            return
        
        stream = QTextStream(self.__buffer)
        stream.setCodec("utf-8")
        
        if self.__pageName == "adblock":
            stream << self.__adBlockPage()
        
        stream.flush()
        self.__buffer.reset()
        self.__loaded = True
    
    def bytesAvailable(self):
        """
        Public method to get the number of available bytes.
        
        @return number of available bytes
        @rtype int
        """
        return self.__buffer.bytesAvailable()
    
    def readData(self, maxlen):
        """
        Public method to retrieve data from the reply object.
        
        @param maxlen maximum number of bytes to read (integer)
        @return string containing the data (bytes)
        """
        return self.__buffer.read(maxlen)
    
    def close(self):
        """
        Public method used to cloase the reply.
        """
        super(EricSchemeReply, self).close()
        self.closed.emit()
    
    def __adBlockPage(self):
        """
        Private method to build the AdBlock page.
        
        @return built AdBlock page
        @rtype str
        """
        query = QUrlQuery(self.__job.requestUrl())
        rule = query.queryItemValue("rule")
        subscription = query.queryItemValue("subscription")
        title = self.tr("Content blocked by AdBlock Plus")
        message = self.tr(
            "Blocked by rule: <i>{0} ({1})</i>").format(rule, subscription)
        
        page = readAllFileContents(":/html/adblockPage.html")
        page = page.replace(
            "@FAVICON@", "qrc:icons/adBlockPlus16.png")
        page = page.replace(
            "@IMAGE@", "qrc:icons/adBlockPlus64.png")
        page = page.replace("@TITLE@", title)
        page = page.replace("@MESSAGE@", message)
        
        return page