def __init__(self, opts, log):
self.log = log
QWebPage.__init__(self)
settings = self.settings()
settings.setFontSize(QWebSettings.DefaultFontSize,
opts.pdf_default_font_size)
settings.setFontSize(QWebSettings.DefaultFixedFontSize,
opts.pdf_mono_font_size)
settings.setFontSize(QWebSettings.MinimumLogicalFontSize, 8)
settings.setFontSize(QWebSettings.MinimumFontSize, 8)
std = {
'serif': opts.pdf_serif_family,
'sans': opts.pdf_sans_family,
'mono': opts.pdf_mono_family
}.get(opts.pdf_standard_font, opts.pdf_serif_family)
if std:
settings.setFontFamily(QWebSettings.StandardFont, std)
if opts.pdf_serif_family:
settings.setFontFamily(QWebSettings.SerifFont,
opts.pdf_serif_family)
if opts.pdf_sans_family:
settings.setFontFamily(QWebSettings.SansSerifFont,
opts.pdf_sans_family)
if opts.pdf_mono_family:
settings.setFontFamily(QWebSettings.FixedFont,
opts.pdf_mono_family)
def __init__(self, url):
self.timerScreen = QTimer()
self.app = QApplication(sys.argv)
QWebPage.__init__(self)
self.loadFinished.connect(self._loadFinished)
self.mainFrame().load(QUrl(url))
self.app.exec_()
def __init__(self, opts, log):
from calibre.gui2 import secure_web_page
self.log = log
QWebPage.__init__(self)
settings = self.settings()
secure_web_page(settings)
settings.setFontSize(QWebSettings.DefaultFontSize,
opts.pdf_default_font_size)
settings.setFontSize(QWebSettings.DefaultFixedFontSize,
opts.pdf_mono_font_size)
settings.setFontSize(QWebSettings.MinimumLogicalFontSize, 8)
settings.setFontSize(QWebSettings.MinimumFontSize, 8)
std = {'serif':opts.pdf_serif_family, 'sans':opts.pdf_sans_family,
'mono':opts.pdf_mono_family}.get(opts.pdf_standard_font,
opts.pdf_serif_family)
if std:
settings.setFontFamily(QWebSettings.StandardFont, std)
if opts.pdf_serif_family:
settings.setFontFamily(QWebSettings.SerifFont, opts.pdf_serif_family)
if opts.pdf_sans_family:
settings.setFontFamily(QWebSettings.SansSerifFont,
opts.pdf_sans_family)
if opts.pdf_mono_family:
settings.setFontFamily(QWebSettings.FixedFont, opts.pdf_mono_family)
def __init__(self, opts, log):
from calibre.gui2 import secure_web_page
self.log = log
QWebPage.__init__(self)
settings = self.settings()
settings.setFontSize(QWebSettings.DefaultFontSize,
opts.pdf_default_font_size)
settings.setFontSize(QWebSettings.DefaultFixedFontSize,
opts.pdf_mono_font_size)
settings.setFontSize(QWebSettings.MinimumLogicalFontSize, 8)
settings.setFontSize(QWebSettings.MinimumFontSize, 8)
secure_web_page(settings)
std = {
'serif': opts.pdf_serif_family,
'sans': opts.pdf_sans_family,
'mono': opts.pdf_mono_family
}.get(opts.pdf_standard_font, opts.pdf_serif_family)
if std:
settings.setFontFamily(QWebSettings.StandardFont, std)
if opts.pdf_serif_family:
settings.setFontFamily(QWebSettings.SerifFont,
opts.pdf_serif_family)
if opts.pdf_sans_family:
settings.setFontFamily(QWebSettings.SansSerifFont,
opts.pdf_sans_family)
if opts.pdf_mono_family:
settings.setFontFamily(QWebSettings.FixedFont,
opts.pdf_mono_family)
self.longjs_counter = 0
def __init__(self, p):
QWebPage.__init__(self, p)
self.mainFrame().urlChanged.connect(self._urlChanged)
self.loadStarted.connect(self._loadStarted)
self.previousUrl = None
self.nam = RedirectLoggerNetworkAccessManager()
self.setNetworkAccessManager(self.nam)
def __init__(self,
log,
confirm_callback=None,
prompt_callback=None,
user_agent=USER_AGENT,
enable_developer_tools=False,
parent=None):
QWebPage.__init__(self, parent)
self.log = log
self.user_agent = user_agent if user_agent else USER_AGENT
self.confirm_callback = confirm_callback
self.prompt_callback = prompt_callback
self.setForwardUnsupportedContent(True)
self.unsupportedContent.connect(self.on_unsupported_content)
settings = self.settings()
if enable_developer_tools:
settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
QWebSettings.enablePersistentStorage(
os.path.join(cache_dir(), 'webkit-persistence'))
QWebSettings.setMaximumPagesInCache(0)
self.bridge_name = 'b' + uuid.uuid4().get_hex()
self.mainFrame().javaScriptWindowObjectCleared.connect(
self.add_window_objects)
self.dom_loaded = False
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object (QObject)
"""
super(PageThumbnailer, self).__init__(parent)
self.__page = QWebPage(self)
self.__size = QSize(231, 130)
self.__loadTitle = False
self.__title = ""
self.__url = QUrl()
self.__proxy = NetworkAccessManagerProxy(self)
import Helpviewer.HelpWindow
self.__proxy.setPrimaryNetworkAccessManager(
Helpviewer.HelpWindow.HelpWindow.networkAccessManager())
self.__page.setNetworkAccessManager(self.__proxy)
self.__page.mainFrame().setScrollBarPolicy(Qt.Horizontal,
Qt.ScrollBarAlwaysOff)
self.__page.mainFrame().setScrollBarPolicy(Qt.Vertical,
Qt.ScrollBarAlwaysOff)
# Full HD
# Every page should fit in this resolution
self.__page.setViewportSize(QSize(1920, 1080))
def __init__(self, parent, networkmanager):
QWebPage.__init__(self, parent)
self.setForwardUnsupportedContent(True)
self.setLinkDelegationPolicy(2)
self.setNetworkAccessManager(networkmanager)
self.useragent_desktop = QWebPage.userAgentForUrl(self, QUrl())
self.useragent_mobile = 'Nokia 5130'
def __init__(self, html):
self.html = None
self.app = QApplication(sys.argv)
QWebPage.__init__(self)
self.loadFinished.connect(self._loadFinished)
self.mainFrame().setHtml(html)
self.app.exec_()
def __init__(self, parent, size, url):
super(GISCloudQgisWebBrowserDialog,
self).__init__(parent.manager.main_widget)
self.parent = parent
self.setModal(True)
self.cookies = None
self.url = QUrl(url)
self.nam = QtNetwork.QNetworkAccessManager()
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.nam)
self.web_page.loadFinished.connect(self.loading_finished)
def customuseragent(url):
"""setting up our own user agent"""
# pylint: disable=W0613
return ("Mozilla/5.0 " + GISCloudNetworkHandler.app_id.encode(
"unicode_escape").decode("latin-1"))
self.web_page.userAgentForUrl = customuseragent
self.web_view = QWebView(self)
self.web_view.setPage(self.web_page)
self.resize(size)
def webpage(qnam):
"""Get a new QWebPage object."""
from PyQt5.QtWebKitWidgets import QWebPage
page = QWebPage()
page.networkAccessManager().deleteLater()
page.setNetworkAccessManager(qnam)
return page
def __init__(self, parent=None):
QWebPage.__init__(self, parent)
self.modelLoadersLoaded = False
if DEBUG_MODE == 2:
# open log file
self.logfile = open(pluginDir("q3dview.log"), "w")
def __init__(self, parent, networkmanager):
QWebPage.__init__(self, parent)
self.setForwardUnsupportedContent(True)
self.setLinkDelegationPolicy(2)
self.setNetworkAccessManager(networkmanager)
#self.useragent_desktop = QWebPage.userAgentForUrl(self, QUrl())
self.useragent_desktop = "Mozilla/5.0 (X11; Linux) AppleWebKit/538.1 (KHTML, like Gecko) Quartz Safari/538.1"
self.useragent_mobile = 'Nokia 5130'
def __init__(self, parent=None):
QWebPage.__init__(self, parent)
self.loadedScripts = {}
if DEBUG_MODE == 2:
# open log file
self.logfile = open(pluginDir("q3dview.log"), "w")
def __init__(self):
self.log = default_log
QWebPage.__init__(self)
secure_web_page(self.settings())
self.js = None
self.evaljs = self.mainFrame().evaluateJavaScript
nam = self.networkAccessManager()
nam.setNetworkAccessible(nam.NotAccessible)
self.setLinkDelegationPolicy(self.DelegateAllLinks)
def __init__(self, log):
self.log = log
QWebPage.__init__(self)
self.js = None
self.evaljs = self.mainFrame().evaluateJavaScript
self.bridge_value = None
nam = self.networkAccessManager()
nam.setNetworkAccessible(nam.NotAccessible)
self.longjs_counter = 0
def webpage():
"""Get a new QWebPage object."""
from PyQt5.QtWebKitWidgets import QWebPage
from PyQt5.QtNetwork import QNetworkAccessManager
page = QWebPage()
nam = page.networkAccessManager()
nam.setNetworkAccessible(QNetworkAccessManager.NotAccessible)
return page
def __init__(self, log):
self.log = log
QWebPage.__init__(self)
self.js = None
self.evaljs = self.mainFrame().evaluateJavaScript
self.bridge_value = None
nam = self.networkAccessManager()
nam.setNetworkAccessible(nam.NotAccessible)
self.longjs_counter = 0
def __init__(self):
self.log = default_log
QWebPage.__init__(self)
self.js = None
self.evaljs = self.mainFrame().evaluateJavaScript
self.bridge_value = None
nam = self.networkAccessManager()
nam.setNetworkAccessible(nam.NotAccessible)
self.setLinkDelegationPolicy(self.DelegateAllLinks)
def __init__(self, url):
self.app = QApplication(sys.argv)
QWebPage.__init__(self)
self.loadFinished.connect(self._loadFinished)
self.mainFrame().load(QUrl(url))
#issue:QNetworkReplyImplPrivate::error: Internal problem, this method must only be called once.
#self.mainFrame().wait_load() #https://github.com/jeanphix/Ghost.py/issues/62
self.app.exec_()
def __init__(self):
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.network_manager.finished.connect(self._request_finished)
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view = QWebView()
self.web_view.setPage(self.web_page)
def __init__(self):
super(FrameCapture, self).__init__()
self._percent = 0
self._page = QWebPage()
self._page.mainFrame().setScrollBarPolicy(Qt.Vertical,
Qt.ScrollBarAlwaysOff)
self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal,
Qt.ScrollBarAlwaysOff)
self._page.loadProgress.connect(self.printProgress)
self._page.loadFinished.connect(self.saveResult)
def __init__(self, parent):
QWebPage.__init__(self, parent)
self.js_loader = None
self._footnote_data = ''
from calibre.gui2.viewer.documentview import apply_basic_settings
settings = self.settings()
apply_basic_settings(settings)
settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, False)
self.setLinkDelegationPolicy(self.DelegateAllLinks)
self.mainFrame().javaScriptWindowObjectCleared.connect(self.add_window_objects)
self.add_window_objects()
def __init__(self, parent):
QWebPage.__init__(self, parent)
self.js_loader = None
self._footnote_data = ''
from calibre.gui2.viewer.documentview import apply_basic_settings
settings = self.settings()
apply_basic_settings(settings)
settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, False)
self.setLinkDelegationPolicy(self.DelegateAllLinks)
self.mainFrame().javaScriptWindowObjectCleared.connect(self.add_window_objects)
self.add_window_objects()
class Browser(object):
def __init__(self):
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.network_manager.finished.connect(self._request_finished)
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view = QWebView()
self.web_view.setPage(self.web_page)
def _create_request(self, operation, request, data):
print(data.readAll())
reply = QNetworkAccessManager.createRequest(self.network_manager,
operation,
request,
data)
return reply
def _request_finished(self, reply):
if not reply.error() == QNetworkReply.NoError:
# request probably failed
print(reply.error())
print(reply.errorString())
def _make_request(self, url):
request = QNetworkRequest()
request.setUrl(QUrl(url))
return request
def _urlencode_post_data(self, post_data):
post_params = QUrl()
for (key, value) in post_data.items():
post_params.addQueryItem(key, value)
return post_params.encodedQuery()
def perform(self, url, method='GET', post_data=dict()):
request = self._make_request(url)
if method == 'GET':
self.web_view.load(request)
else:
encoded_data = self._urlencode_post_data(post_data)
request.setRawHeader('Content-Type',
QByteArray('application/x-www-form-urlencoded'))
self.web_view.load(request,
QNetworkAccessManager.PostOperation,
encoded_data)
class WebLoader(QObject):
_finished = pyqtSignal(str)
def __init__(self, key):
super(WebLoader, self).__init__()
# if platform.python_version() < '3.0.0':
# self._key = unicode(key)
self._key = key
self._percent = 0
self._page = QWebPage()
self._page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self._page.loadProgress.connect(self.printProgress)
def printProgress(self, percent):
if self._percent >= percent:
cout("\n")
return
else:
cout('#' * (percent - self._percent))
self._percent = percent
def load(self, url):
self._percent = 0
self._url = QUrl.fromUserInput(url)
self._page.mainFrame().load(self._url)
self._page.setViewportSize(QSize(1920, 10000))
print("Loading... %s" % url)
class Browser(object):
def __init__(self):
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.network_manager.finished.connect(self._request_finished)
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view = QWebView()
self.web_view.setPage(self.web_page)
def _create_request(self, operation, request, data):
print(data.readAll())
reply = QNetworkAccessManager.createRequest(self.network_manager,
operation, request, data)
return reply
def _request_finished(self, reply):
if not reply.error() == QNetworkReply.NoError:
# request probably failed
print(reply.error())
print(reply.errorString())
def _make_request(self, url):
request = QNetworkRequest()
request.setUrl(QUrl(url))
return request
def _urlencode_post_data(self, post_data):
post_params = QUrl()
for (key, value) in post_data.items():
post_params.addQueryItem(key, value)
return post_params.encodedQuery()
def perform(self, url, method='GET', post_data=dict()):
request = self._make_request(url)
if method == 'GET':
self.web_view.load(request)
else:
encoded_data = self._urlencode_post_data(post_data)
request.setRawHeader(
'Content-Type',
QByteArray('application/x-www-form-urlencoded'))
self.web_view.load(request, QNetworkAccessManager.PostOperation,
encoded_data)
def search(self,
text,
*,
ignore_case=usertypes.IgnoreCase.never,
reverse=False,
wrap=True,
result_cb=None):
# Don't go to next entry on duplicate search
if self.text == text and self.search_displayed:
log.webview.debug("Ignoring duplicate search request"
" for {}".format(text))
return
# Clear old search results, this is done automatically on QtWebEngine.
self.clear()
self.text = text
self.search_displayed = True
self._flags = QWebPage.FindFlags(0) # type: ignore
if self._is_case_sensitive(ignore_case):
self._flags |= QWebPage.FindCaseSensitively
if reverse:
self._flags |= QWebPage.FindBackward
if wrap:
self._flags |= QWebPage.FindWrapsAroundDocument
# We actually search *twice* - once to highlight everything, then again
# to get a mark so we can navigate.
found = self._widget.findText(text, self._flags)
self._widget.findText(text,
self._flags | QWebPage.HighlightAllOccurrences)
self._call_cb(result_cb, found, text, self._flags, 'search')
def search(self, text, flags):
"""Search for text in the current page.
Args:
text: The text to search for.
flags: The QWebPage::FindFlags.
"""
log.webview.debug("Searching with text '{}' and flags "
"0x{:04x}.".format(text, int(flags)))
old_scroll_pos = self.scroll_pos
flags = QWebPage.FindFlags(flags)
found = self.findText(text, flags)
if not found and not flags & QWebPage.HighlightAllOccurrences and text:
message.error(self.win_id, "Text '{}' not found on "
"page!".format(text), immediately=True)
else:
backward = int(flags) & QWebPage.FindBackward
def check_scroll_pos():
"""Check if the scroll position got smaller and show info."""
if not backward and self.scroll_pos < old_scroll_pos:
message.info(self.win_id, "Search hit BOTTOM, continuing "
"at TOP", immediately=True)
elif backward and self.scroll_pos > old_scroll_pos:
message.info(self.win_id, "Search hit TOP, continuing at "
"BOTTOM", immediately=True)
# We first want QWebPage to refresh.
QTimer.singleShot(0, check_scroll_pos)
def __init__(self, callback, xpos, ypos, width, height):
super(Window, self).__init__()
self._xpos = xpos
self._ypos = ypos
self._width = width
self._height = height
self._callback = callback
self.setStyleSheet(
"QWidget { background-color : #1B1D1E; color : #FFFFFF; }")
self.setAsBar()
view = QWebView(self)
view.setContextMenuPolicy(Qt.CustomContextMenu)
view.statusBarMessage.connect(self.qt_statusbar_callback)
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(view)
view.setPage(QWebPage())
view.setHtml(
htmltemplate(self._width, self._height,
"bottom" if ypos == 0 else "top"))
self.view = view
self.updateContent.connect(self.handle_updateContent)
def userAgentForUrl(self, url):
"""Handle reqests for the browser's user agent
Overridden from QWebPage so we can force a user agent from the config.
"""
return (self.config.get("user_agent")
or QWebPage.userAgentForUrl(self, url))
class CustomQWebPage(QWebPage):
"""
QWebPage subclass with a signal for load finished with a parameter for
page errors.
"""
loadFinishedWithError = pyqtSignal(bool, QWebPage.ErrorPageExtensionOption)
_dummy_error = QWebPage.ErrorPageExtensionOption()
def __init__(self, *args, **kwargs):
super(CustomQWebPage, self).__init__(*args, **kwargs)
self.webview = None
self._current_error = None
self.loadFinished.connect(self._on_load_finished)
self.loadStarted.connect(self.reset_curent_error)
def setNetworkAccessManager(self, nam):
super(CustomQWebPage, self).setNetworkAccessManager(nam)
self.networkAccessManager().finished.connect(self._on_network_reply)
def reset_curent_error(self):
self._current_error = None
def _on_network_reply(self, reply):
if self._current_error:
return
if reply.error() == QNetworkReply.NoError:
self._current_error = MyErrorPageExtensionOption()
self._current_error.domain = QWebPage.Http
self._current_error.error = reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
self._current_error.url = reply.url()
self._current_error.errorString = reply.attribute(
QNetworkRequest.HttpReasonPhraseAttribute)
self._current_error.headers = dict(
map(partial(map, str), reply.rawHeaderPairs()))
def _on_load_finished(self, ok):
# TODO: check if Qt accepts None instead of _dummy_error.
error = self._current_error or self._dummy_error
if error.domain == QWebPage.Http:
ok = True
self.loadFinishedWithError.emit(ok, error)
self.reset_curent_error()
def extension(self, extension, option=None, output=None):
if extension == QWebPage.ErrorPageExtension:
if self._current_error is None:
self._current_error = option
return False
def supportsExtension(self, extension):
if extension == QWebPage.ErrorPageExtension:
return True
return super(CustomQWebPage, self).supportsExtension(extension)
def find(self, forwards=True):
text = str(self.search_text.text()).strip()
flags = QWebPage.FindFlags(0) if forwards else QWebPage.FindBackward
d = self.dest_list
if d.count() == 1:
flags |= QWebPage.FindWrapsAroundDocument
if not self.view.findText(text, flags) and text:
if d.count() == 1:
return error_dialog(self,
_('No match found'),
_('No match found for: %s') % text,
show=True)
delta = 1 if forwards else -1
current = str(d.currentItem().data(Qt.DisplayRole) or '')
next_index = (d.currentRow() + delta) % d.count()
next = str(d.item(next_index).data(Qt.DisplayRole) or '')
msg = '<p>' + _(
'No matches for %(text)s found in the current file [%(current)s].'
' Do you want to search in the %(which)s file [%(next)s]?')
msg = msg % dict(text=text,
current=current,
next=next,
which=_('next') if forwards else _('previous'))
if question_dialog(self, _('No match found'), msg):
self.pending_search = self.find_next if forwards else self.find_previous
d.setCurrentRow(next_index)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object (QObject)
"""
super(PageThumbnailer, self).__init__(parent)
self.__page = QWebPage(self)
self.__size = QSize(231, 130)
self.__loadTitle = False
self.__title = ""
self.__url = QUrl()
self.__proxy = NetworkAccessManagerProxy(self)
import Helpviewer.HelpWindow
self.__proxy.setPrimaryNetworkAccessManager(
Helpviewer.HelpWindow.HelpWindow.networkAccessManager())
self.__page.setNetworkAccessManager(self.__proxy)
self.__page.mainFrame().setScrollBarPolicy(
Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.__page.mainFrame().setScrollBarPolicy(
Qt.Vertical, Qt.ScrollBarAlwaysOff)
# Full HD
# Every page should fit in this resolution
self.__page.setViewportSize(QSize(1920, 1080))
def createWindow(self, QWebEnginePage_WebWindowType):
new_webview = QWebView()
page = QWebPage()
new_webview.setPage(page)
win = MainWin()
win.setCentralWidget(new_webview)
self.windowList.append(win) # 注：没有这句会崩溃！！！
return new_webview
class MMyWebPage(object):
@staticmethod
def instance(webview):
if not hasattr(MyWebPage, "_instance"):
MMyWebPage._instance = MMyWebPage(webview)
return MMyWebPage._instance
def __init__(self, webview, *args, **kwargs):
super(MMyWebPage, self).__init__(*args, **kwargs)
self.webview = webview
self.webpage = QWebPage()
self.webpage.loadFinished.connect(self.on_loadFinished)
def set_content(self, url):
self.content = ''
self.result = False
self.qurl = QUrl(url)
self.webpage.mainFrame().load(self.qurl)
def on_loadFinished(self, result):
self.result = result
if result:
self.frame = self.webpage.mainFrame()
self.content = self.frame.toHtml()
doc = BeautifulSoup(self.content, 'lxml')
temp = doc.find('div', class_='word')
try:
# adcontent = temp.find("div", class_="basic clearfix").find("ul", class_="dict-basic-ul").findAll('li')[-1]
# adcontent.replaceWith('')
adcontent = temp.find(
"div",
class_="basic clearfix").find("ul").findAll('li')[-1]
adcontent.replaceWith('')
except:
pass
finally:
self.webview.setHtml(str(temp))
# with open('temp.html', 'w') as f:
# f.write(str(temp))
@property
def get_content(self):
doc = BeautifulSoup(self.content, 'lxml')
self.content = doc.find('div', class_='word')
return self.content
def userAgentForUrl(self, url):
"""Handle reqests for the browser's user agent
Overridden from QWebPage so we can force a user agent from the config.
"""
return (
self.config.get("user_agent")
or QWebPage.userAgentForUrl(self, url)
)
def acceptNavigationRequest(self, frame, request, type):
if (type == QWebPage.NavigationTypeLinkClicked):
if (frame == self.mainFrame()):
self.view().link_clicked(request.url())
else:
call_method("open-url", [request.url().toString()])
return False
return QWebPage.acceptNavigationRequest(self, frame, request, type)
def prev_result(self, *, result_cb=None):
# The int() here makes sure we get a copy of the flags.
flags = QWebPage.FindFlags(int(self._flags))
if flags & QWebPage.FindBackward:
flags &= ~QWebPage.FindBackward
else:
flags |= QWebPage.FindBackward
found = self._widget.findText(self.text, flags)
self._call_cb(result_cb, found)
def acceptNavigationRequest(self, frame, request, type):
if(type == QWebPage.NavigationTypeLinkClicked):
if(frame == self.mainFrame()):
self.view().link_clicked(request.url())
else:
call_method("open-url", [request.url().toString()])
return False
return QWebPage.acceptNavigationRequest(self, frame, request, type)
def __init__(self, html, base_dir, width, height, dpi, factor):
'''
`width, height`: page width and height in pixels
`base_dir`: The directory in which the HTML file that contains the table resides
'''
QObject.__init__(self)
self.app = None
self.width, self.height, self.dpi = width, height, dpi
self.base_dir = base_dir
self.images = []
self.tdir = tempfile.mkdtemp(prefix='calibre_render_table')
self.loop = QEventLoop()
self.page = QWebPage()
self.page.loadFinished.connect(self.render_html)
self.page.mainFrame().setTextSizeMultiplier(factor)
self.page.mainFrame().setHtml(
html, QUrl('file:' + os.path.abspath(self.base_dir)))
def __init__(self, parent):
QWebPage.__init__(self, parent)
settings = self.settings()
apply_settings(settings, config().parse())
settings.setMaximumPagesInCache(0)
secure_web_page(settings)
settings.setAttribute(settings.PrivateBrowsingEnabled, True)
settings.setAttribute(settings.LinksIncludedInFocusChain, False)
settings.setAttribute(settings.DeveloperExtrasEnabled, True)
settings.setDefaultTextEncoding('utf-8')
data = 'data:text/css;charset=utf-8;base64,'
css = '[data-in-split-mode="1"] [data-is-block="1"]:hover { cursor: pointer !important; border-top: solid 5px green !important }'
data += b64encode(css.encode('utf-8'))
settings.setUserStyleSheetUrl(QUrl(data))
self.setNetworkAccessManager(NetworkAccessManager(self))
self.setLinkDelegationPolicy(self.DelegateAllLinks)
self.mainFrame().javaScriptWindowObjectCleared.connect(self.init_javascript)
self.init_javascript()
def __init__(self):
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.network_manager.finished.connect(self._request_finished)
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view = QWebView()
self.web_view.setPage(self.web_page)
def acceptNavigationRequest(self, frame, request, type): if(type == QWebPage.NavigationTypeLinkClicked): url = request.url().toString() if(frame == self.mainFrame()): self.view().load(url) return False elif frame == None: # self.createWindow(QWebPage.WebBrowserWindow, url) webbrowser.open(request.url().toString()) return False return QWebPage.acceptNavigationRequest(self, frame, request, type)
def __init__(self):
super(FrameCapture, self).__init__()
self._percent = 0
self._page = QWebPage()
self._page.mainFrame().setScrollBarPolicy(Qt.Vertical,
Qt.ScrollBarAlwaysOff)
self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal,
Qt.ScrollBarAlwaysOff)
self._page.loadProgress.connect(self.printProgress)
self._page.loadFinished.connect(self.saveResult)
def __init__(self, opts, log):
self.log = log
QWebPage.__init__(self)
settings = self.settings()
settings.setFontSize(QWebSettings.DefaultFontSize, opts.pdf_default_font_size)
settings.setFontSize(QWebSettings.DefaultFixedFontSize, opts.pdf_mono_font_size)
settings.setFontSize(QWebSettings.MinimumLogicalFontSize, 8)
settings.setFontSize(QWebSettings.MinimumFontSize, 8)
std = {"serif": opts.pdf_serif_family, "sans": opts.pdf_sans_family, "mono": opts.pdf_mono_family}.get(
opts.pdf_standard_font, opts.pdf_serif_family
)
if std:
settings.setFontFamily(QWebSettings.StandardFont, std)
if opts.pdf_serif_family:
settings.setFontFamily(QWebSettings.SerifFont, opts.pdf_serif_family)
if opts.pdf_sans_family:
settings.setFontFamily(QWebSettings.SansSerifFont, opts.pdf_sans_family)
if opts.pdf_mono_family:
settings.setFontFamily(QWebSettings.FixedFont, opts.pdf_mono_family)
self.longjs_counter = 0
def __init__(self, key):
super(WebLoader, self).__init__()
# if platform.python_version() < '3.0.0':
# self._key = unicode(key)
self._key = key
self._percent = 0
self._page = QWebPage()
self._page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self._page.loadProgress.connect(self.printProgress)
def javaScriptConfirm(self, frame, msg):
"""Handle javascript confirm() dialogs.
Overridden from QWebPage so that we can (if configured)
force yes/no on these dialogs.
"""
if self.config.get("force_js_confirm") == "accept":
return True
elif self.config.get("force_js_confirm") == "deny":
return False
else:
return QWebPage.javaScriptConfirm(self, frame, msg)
def acceptNavigationRequest(self, frame, request, type):
# Handle myself if got user event.
if type == QWebPage.NavigationTypeLinkClicked:
if self.view().press_ctrl_flag:
call_method("open-url", [request.url().toString()])
else:
self.view().load(request.url())
# Return False to stop default behavior.
return False
# Otherwise, use default behavior.
return QWebPage.acceptNavigationRequest(self, frame, request, type)
def javaScriptPrompt(self, frame, msg, default_value, *args):
if self.view() is not None:
return QWebPage.javaScriptPrompt(self, frame, msg, default_value,
*args)
if self.prompt_callback is None:
return (False, default_value) if ispy3 else False
value = self.prompt_callback(unicode(msg), unicode(default_value))
ok = value is not None
if ispy3:
return ok, value
if ok:
result = args[0]
result.clear()
result.append(value)
return ok
def __init__(self, log,
confirm_callback=None,
prompt_callback=None,
user_agent=USER_AGENT,
enable_developer_tools=False,
parent=None):
QWebPage.__init__(self, parent)
self.log = log
self.user_agent = user_agent if user_agent else USER_AGENT
self.confirm_callback = confirm_callback
self.prompt_callback = prompt_callback
self.setForwardUnsupportedContent(True)
self.unsupportedContent.connect(self.on_unsupported_content)
settings = self.settings()
if enable_developer_tools:
settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
QWebSettings.enablePersistentStorage(os.path.join(cache_dir(),
'webkit-persistence'))
QWebSettings.setMaximumPagesInCache(0)
self.bridge_name = 'b' + uuid.uuid4().get_hex()
self.mainFrame().javaScriptWindowObjectCleared.connect(
self.add_window_objects)
self.dom_loaded = False
def __init__(self, html, base_dir, width, height, dpi, factor):
'''
`width, height`: page width and height in pixels
`base_dir`: The directory in which the HTML file that contains the table resides
'''
QObject.__init__(self)
self.app = None
self.width, self.height, self.dpi = width, height, dpi
self.base_dir = base_dir
self.images = []
self.tdir = tempfile.mkdtemp(prefix='calibre_render_table')
self.loop = QEventLoop()
self.page = QWebPage()
self.page.loadFinished.connect(self.render_html)
self.page.mainFrame().setTextSizeMultiplier(factor)
self.page.mainFrame().setHtml(html,
QUrl('file:'+os.path.abspath(self.base_dir)))
def shouldInterruptJavaScript(self):
if self.view() is not None:
return QWebPage.shouldInterruptJavaScript(self)
return True
class FrameCapture(QObject):
finished = pyqtSignal()
def __init__(self):
super(FrameCapture, self).__init__()
self._percent = 0
self._page = QWebPage()
self._page.mainFrame().setScrollBarPolicy(Qt.Vertical,
Qt.ScrollBarAlwaysOff)
self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal,
Qt.ScrollBarAlwaysOff)
self._page.loadProgress.connect(self.printProgress)
self._page.loadFinished.connect(self.saveResult)
def load(self, url, outputFileName):
cout("Loading %s\n" % url.toString())
self._percent = 0
index = outputFileName.rfind('.')
self._fileName = index == -1 and outputFileName + ".png" or outputFileName
self._page.mainFrame().load(url)
self._page.setViewportSize(QSize(1024, 768))
def printProgress(self, percent):
if self._percent >= percent:
return
self._percent += 1
while self._percent < percent:
self._percent += 1
cout("#")
def saveResult(self, ok):
cout("\n")
# Crude error-checking.
if not ok:
cerr("Failed loading %s\n" % self._page.mainFrame().url().toString())
self.finished.emit()
return
# Save each frame in different image files.
self._frameCounter = 0
self.saveFrame(self._page.mainFrame())
self.finished.emit()
def saveFrame(self, frame):
fileName = self._fileName
if self._frameCounter:
index = fileName.rfind('.')
fileName = "%s_frame%s%s" % (fileName[:index], self._frameCounter, fileName[index:])
image = QImage(frame.contentsSize(), QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
frame.documentElement().render(painter)
painter.end()
image.save(fileName)
self._frameCounter += 1
for childFrame in frame.childFrames():
self.saveFrame(childFrame)
def render_html(path_to_html, width=590, height=750, as_xhtml=True):
from PyQt5.QtWebKitWidgets import QWebPage
from PyQt5.Qt import QEventLoop, QPalette, Qt, QUrl, QSize
from calibre.gui2 import is_ok_to_use_qt
if not is_ok_to_use_qt():
return None
path_to_html = os.path.abspath(path_to_html)
with CurrentDir(os.path.dirname(path_to_html)):
page = QWebPage()
settings = page.settings()
settings.setAttribute(settings.PluginsEnabled, False)
pal = page.palette()
pal.setBrush(QPalette.Background, Qt.white)
page.setPalette(pal)
page.setViewportSize(QSize(width, height))
page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
loop = QEventLoop()
renderer = HTMLRenderer(page, loop)
page.loadFinished.connect(renderer, type=Qt.QueuedConnection)
if as_xhtml:
page.mainFrame().setContent(open(path_to_html, 'rb').read(),
'application/xhtml+xml', QUrl.fromLocalFile(path_to_html))
else:
page.mainFrame().load(QUrl.fromLocalFile(path_to_html))
loop.exec_()
renderer.loop = renderer.page = None
page.loadFinished.disconnect()
del page
del loop
if isinstance(renderer.exception, ParserError) and as_xhtml:
return render_html(path_to_html, width=width, height=height,
as_xhtml=False)
return renderer
def javaScriptConfirm(self, frame, msg):
if self.view() is not None:
return QWebPage.javaScriptConfirm(self, frame, msg)
if self.confirm_callback is not None:
return self.confirm_callback(unicode(msg))
return True
def javaScriptAlert(self, frame, msg):
if self.view() is not None:
return QWebPage.javaScriptAlert(self, frame, msg)
prints('JSBrowser alert():', unicode(msg))
class PageThumbnailer(QObject):
"""
Class implementing a thumbnail creator for web sites.
@signal thumbnailCreated(QPixmap) emitted after the thumbnail has been
created
"""
thumbnailCreated = pyqtSignal(QPixmap)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object (QObject)
"""
super(PageThumbnailer, self).__init__(parent)
self.__page = QWebPage(self)
self.__size = QSize(231, 130)
self.__loadTitle = False
self.__title = ""
self.__url = QUrl()
self.__proxy = NetworkAccessManagerProxy(self)
import Helpviewer.HelpWindow
self.__proxy.setPrimaryNetworkAccessManager(
Helpviewer.HelpWindow.HelpWindow.networkAccessManager())
self.__page.setNetworkAccessManager(self.__proxy)
self.__page.mainFrame().setScrollBarPolicy(
Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.__page.mainFrame().setScrollBarPolicy(
Qt.Vertical, Qt.ScrollBarAlwaysOff)
# Full HD
# Every page should fit in this resolution
self.__page.setViewportSize(QSize(1920, 1080))
def setSize(self, size):
"""
Public method to set the size of the image.
@param size size of the image (QSize)
"""
if size.isValid():
self.__size = QSize(size)
def setUrl(self, url):
"""
Public method to set the URL of the site to be thumbnailed.
@param url URL of the web site (QUrl)
"""
if url.isValid():
self.__url = QUrl(url)
def url(self):
"""
Public method to get the URL of the thumbnail.
@return URL of the thumbnail (QUrl)
"""
return QUrl(self.__url)
def loadTitle(self):
"""
Public method to check, if the title is loaded from the web site.
@return flag indicating, that the title is loaded (boolean)
"""
return self.__loadTitle
def setLoadTitle(self, load):
"""
Public method to set a flag indicating to load the title from
the web site.
@param load flag indicating to load the title (boolean)
"""
self.__loadTitle = load
def title(self):
"""
Public method to get the title of the thumbnail.
@return title of the thumbnail (string)
"""
return self.__title
def start(self):
"""
Public method to start the thumbnailing action.
"""
self.__page.loadFinished.connect(self.__createThumbnail)
self.__page.mainFrame().load(self.__url)
def __createThumbnail(self, status):
"""
Private slot creating the thumbnail of the web site.
@param status flag indicating a successful load of the web site
(boolean)
"""
if not status:
self.thumbnailCreated.emit(QPixmap())
return
self.__title = self.__page.mainFrame().title()
image = QImage(self.__page.viewportSize(), QImage.Format_ARGB32)
painter = QPainter(image)
self.__page.mainFrame().render(painter)
painter.end()
scaledImage = image.scaled(self.__size,
Qt.KeepAspectRatioByExpanding,
Qt.SmoothTransformation)
self.thumbnailCreated.emit(QPixmap.fromImage(scaledImage))
class HTMLTableRenderer(QObject):
def __init__(self, html, base_dir, width, height, dpi, factor):
'''
`width, height`: page width and height in pixels
`base_dir`: The directory in which the HTML file that contains the table resides
'''
from calibre.gui2 import secure_web_page
QObject.__init__(self)
self.app = None
self.width, self.height, self.dpi = width, height, dpi
self.base_dir = base_dir
self.images = []
self.tdir = tempfile.mkdtemp(prefix='calibre_render_table')
self.loop = QEventLoop()
self.page = QWebPage()
secure_web_page(self.page.settings())
self.page.loadFinished.connect(self.render_html)
self.page.mainFrame().setTextSizeMultiplier(factor)
self.page.mainFrame().setHtml(html,
QUrl('file:'+os.path.abspath(self.base_dir)))
def render_html(self, ok):
try:
if not ok:
return
cwidth, cheight = self.page.mainFrame().contentsSize().width(), self.page.mainFrame().contentsSize().height()
self.page.setViewportSize(QSize(cwidth, cheight))
factor = float(self.width)/cwidth if cwidth > self.width else 1
cutoff_height = int(self.height/factor)-3
image = QImage(self.page.viewportSize(), QImage.Format_ARGB32)
image.setDotsPerMeterX(self.dpi*(100/2.54))
image.setDotsPerMeterY(self.dpi*(100/2.54))
painter = QPainter(image)
self.page.mainFrame().render(painter)
painter.end()
cheight = image.height()
cwidth = image.width()
pos = 0
while pos < cheight:
img = image.copy(0, pos, cwidth, min(cheight-pos, cutoff_height))
pos += cutoff_height-20
if cwidth > self.width:
img = img.scaledToWidth(self.width, Qt.SmoothTransform)
f = os.path.join(self.tdir, '%d.png'%pos)
img.save(f)
self.images.append((f, img.width(), img.height()))
finally:
QApplication.quit()
def __init__(self, parent):
QWebPage.__init__(self, parent)
