class Browser (QWidget, BaseCentralWidget):
def __init__(self, URL, process=None):
QWidget.__init__(self)
BaseCentralWidget.__init__(self)
self.path = URL
self.process = process
v_box = QVBoxLayout(self)
#Web Frame
self.webFrame = QWebView()
self.webFrame.load(QUrl(URL))
v_box.addWidget(self.webFrame)
if process is not None:
time.sleep(0.5)
self.webFrame.reload()
def shutdown_pydoc(self):
if self.process is not None:
self.process.kill()
def find_match(self, word, back=False, sensitive=False, whole=False):
b = QWebPage.FindBackward if back else None
s = QWebPage.FindCaseSensitively if sensitive else None
self.webFrame.page().findText(word)
class Browser(QWidget, BaseCentralWidget):
def __init__(self, URL, process=None):
QWidget.__init__(self)
BaseCentralWidget.__init__(self)
self.path = URL
self.process = process
v_box = QVBoxLayout(self)
#Web Frame
self.webFrame = QWebView()
self.webFrame.load(QUrl(URL))
v_box.addWidget(self.webFrame)
if process is not None:
time.sleep(0.5)
self.webFrame.reload()
def shutdown_pydoc(self):
if self.process is not None:
self.process.kill()
def find_match(self, word, back=False, sensitive=False, whole=False):
b = QWebPage.FindBackward if back else None
s = QWebPage.FindCaseSensitively if sensitive else None
self.webFrame.page().findText(word)
def __init__(self, gamedata_edit, QWidget=None):
QtGui.QVBoxLayout.__init__(self, QWidget)
self.gamedata_edit = gamedata_edit
web_view = QWebView()
web_view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
web_view.connect(web_view, SIGNAL("linkClicked(const QUrl&)"), self.link_clicked)
web_view.load(QUrl(WEBSITE_ADDRESS))
self.addWidget(web_view)
class HtmlRender(object):
def __init__(self, url, baseurl=None):
self.url = url
self.web_view = QWebView()
self.network_manager = SplashQNetworkAccessManager()
self.web_page = SplashQWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view.setPage(self.web_page)
self.web_view.setAttribute(Qt.WA_DeleteOnClose, True)
settings = self.web_view.settings()
settings.setAttribute(QWebSettings.JavascriptEnabled, True)
settings.setAttribute(QWebSettings.PluginsEnabled, False)
settings.setAttribute(QWebSettings.PrivateBrowsingEnabled, True)
settings.setAttribute(QWebSettings.LocalStorageEnabled, True)
self.web_page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.web_page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.deferred = defer.Deferred()
request = QNetworkRequest()
request.setUrl(QUrl(url))
if baseurl:
self._baseUrl = QUrl(baseurl)
self.network_manager.finished.connect(self._requestFinished)
self.network_manager.get(request)
else:
self.web_page.loadFinished.connect(self._loadFinished)
self.web_page.mainFrame().load(request)
def close(self):
self.web_view.stop()
self.web_view.close()
self.web_page.deleteLater()
self.web_view.deleteLater()
self.network_manager.deleteLater()
def _requestFinished(self, reply):
self.web_page.networkAccessManager().finished.disconnect(self._requestFinished)
self.web_view.loadFinished.connect(self._loadFinished)
mimeType = reply.header(QNetworkRequest.ContentTypeHeader).toString()
self.web_view.page().mainFrame().setContent(reply.readAll(), mimeType, self._baseUrl)
def _loadFinished(self, ok):
if self.deferred.called:
return
if ok:
try:
self.deferred.callback(self._render())
except:
self.deferred.errback()
else:
self.deferred.errback(RenderError())
def _render(self):
frame = self.web_view.page().mainFrame()
return str(frame.toHtml().toUtf8())
def _add_html5_toolbar(self):
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView, QWebSettings
view = QWebView()
view.load(QUrl("dimensionality_reduction/html5/index.html?stylesheet=ui_720p"))
view.show()
view.setFixedSize(self.args.preferred_width, HTML5_TOOLBAR_HEIGHT)
self.setFixedSize(self.args.preferred_width, self.args.preferred_height)
self.outer_vertical_layout.addWidget(view)
view.page().settings().setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
class MainForm(QWidget):
def __init__(self, parent=None):
super(QWidget, self).__init__(parent)
listLabel = QLabel("&List")
self.listWidget = QWebView()
self.listWidget.load(
QUrl('http://192.168.0.34/picture/index.php/Home/Index/mainmenu'))
self.listWidget.page().setLinkDelegationPolicy(
QWebPage.DelegateAllLinks)
self.listWidget.linkClicked.connect(self.slt_asset)
self.tableWidget = QWebView()
self.tableWidget.load(
QUrl(
'http://192.168.0.34/picture/index.php/Home/Index/indexdisplay'
))
self.tableWidget.page().setLinkDelegationPolicy(
QWebPage.DelegateAllLinks)
self.tableWidget.linkClicked.connect(self.index2)
splitter = QSplitter(Qt.Horizontal)
vbox = QVBoxLayout()
vbox.addWidget(self.listWidget)
widget = QWidget()
widget.setLayout(vbox)
# widget.setMaximumWidth(200)
splitter.addWidget(widget)
vbox = QVBoxLayout()
vbox.addWidget(self.tableWidget)
widget = QWidget()
widget.setLayout(vbox)
splitter.addWidget(widget)
layout = QVBoxLayout()
layout.addWidget(splitter)
splitter.setStretchFactor(1, 1)
self.setLayout(layout)
def slt_asset(self, url):
t_url_info = url.toString()
t_info_list = t_url_info.split("/")[-1]
urlo = 'http://192.168.0.34/picture/index.php/Home/Index/index2/id/' + t_info_list
# self.tableWidget.clear()
self.tableWidget.load(QUrl(urlo))
def index2(self, url):
self.tableWidget.load(QUrl(url))
class HtmlViewerWidget(QWidget):
def __init__(self, parent):
super(HtmlViewerWidget, self).__init__(parent)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.view = QWebView()
self.view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.layout().addWidget(self.view)
def showHTML(self, html, data):
if os.path.isfile(html):
html = open(html).read()
html = html.replace(r'\n', '<br>')
self.view.setHtml(html)
class Scraper(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self,self.app)
self.view = QWebView()
self.page = self.view.page() #QWebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.db = {}
self.attset = Set()
self.view.show()
def start(self):
print "loading %s"%self.url
self.load(self.url)
def load(self,url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
document.evaluateJavaScript("""
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
Element.prototype.click = function() {
this.dispatchEvent(evt);
};
""")
print "yay"
def _create_view(self, svg, section=None):
view = QWebView(self)
view.setRenderHint(QtGui.QPainter.TextAntialiasing, False)
view.setPage(LoggingWebPage())
view.setContextMenuPolicy(QtCore.Qt.PreventContextMenu)
# the HTML page that will contain the SVG
path = os.path.dirname(os.path.realpath(__file__))
html = QUrl(os.path.join(path, "index.html")) # make file configurable
# setup the JS interface
frame = view.page().mainFrame()
self.js = JSInterface(frame)
#self.js.registered.connect(self.register)
self.js.visibility.connect(self.listen)
# mouse interaction signals
self.clicked = self.js.leftclicked
self.rightClicked = self.js.rightclicked
# Inject JSInterface into the JS global namespace as "Widget"
frame.addToJavaScriptWindowObject('Widget', self.js) # confusing?
# when the page (and all the JS) has loaded, load the SVG
def load_svg():
print "blorrt", svg
self.js.load(svg, section)
view.loadFinished.connect(load_svg)
# load the page
# print "url", QUrl(url)
view.load(html)
return view
class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(
self.next_button, SIGNAL("clicked()"),
lambda: chlist.setCurrentRow(0 if chlist.currentRow(
) == chlist.count() - 1 else chlist.currentRow() + 1))
self.connect(
self.previous_button, SIGNAL("clicked()"),
lambda: chlist.setCurrentRow(chlist.count(
) - 1 if chlist.currentRow() == 0 else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(
self.book.get_chapter(num).decode(encoding="utf-8"))
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
class Crawler(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self,self.app)
self.view = QWebView()
self.page = self.view.page() #Q WebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.pagelist = Set()
self.movies = Set()
self.first = True
self.count = 0
def load(self,url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
if self.first:
links = document.findAll("ul#data_nav li a")
for a in links:
self.pagelist.add(a.attribute("href"))
self.first = False
else:
rows = document.findAll("div.data_table table.sdt tbody tr td a")
for a in rows:
self.movies.add(a.attribute("href"))
'''
def _create_view(self, svg, section=None):
view = QWebView(self)
view.setRenderHint(QtGui.QPainter.TextAntialiasing, False)
view.setPage(LoggingWebPage())
view.setContextMenuPolicy(QtCore.Qt.PreventContextMenu)
# the HTML page that will contain the SVG
path = os.path.dirname(os.path.realpath(__file__))
html = QUrl(os.path.join(path, "index.html")) # make file configurable
# setup the JS interface
frame = view.page().mainFrame()
self.js = JSInterface(frame)
#self.js.registered.connect(self.register)
self.js.visibility.connect(self.listen)
# mouse interaction signals
self.clicked = self.js.leftclicked
self.rightClicked = self.js.rightclicked
# Inject JSInterface into the JS global namespace as "Widget"
frame.addToJavaScriptWindowObject('Widget', self.js) # confusing?
# when the page (and all the JS) has loaded, load the SVG
def load_svg():
print "blorrt", svg
self.js.load(svg, section)
view.loadFinished.connect(load_svg)
# load the page
# print "url", QUrl(url)
view.load(html)
return view
class Scraper(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self, self.app)
self.view = QWebView()
self.page = self.view.page() #QWebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.db = {}
self.attset = Set()
self.view.show()
def start(self):
print "loading %s" % self.url
self.load(self.url)
def load(self, url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
document.evaluateJavaScript("""
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
Element.prototype.click = function() {
this.dispatchEvent(evt);
};
""")
print "yay"
class HtmlViewerWidget(QWidget):
def __init__(self, parent):
super(HtmlViewerWidget, self).__init__(parent)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.view = QWebView()
self.view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.frame = QFrame()
self.frame.setLayout(QGridLayout())
self.frame.layout().setContentsMargins(0, 0, 0, 0)
self.toolbar = QToolBar()
self.spacer = QWidget()
self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.copyAction = self.toolbar.addAction(QIcon(":/icons/clipboard"),
"Copy Text")
self.label = QLabel()
self.closeAction = self.toolbar.addAction(QIcon(":/icons/cancel"),
"Close")
self.spaceraction = self.toolbar.insertWidget(self.closeAction,
self.spacer)
self.labelaction = self.toolbar.insertWidget(self.spaceraction,
self.label)
self.closeAction.triggered.connect(self.close)
self.copyAction.triggered.connect(self.copy_text)
self.layout().addWidget(self.frame)
self.frame.layout().addWidget(self.toolbar)
self.frame.layout().addWidget(self.view)
self.effect = QGraphicsOpacityEffect()
self.label.setGraphicsEffect(self.effect)
self.anim = QPropertyAnimation(self.effect, "opacity")
self.anim.setDuration(2000)
self.anim.setStartValue(1.0)
self.anim.setEndValue(0.0)
self.anim.setEasingCurve(QEasingCurve.OutQuad)
def copy_text(self):
self.label.setText("Copied to clipboard")
text = self.view.page().mainFrame().toPlainText()
QApplication.clipboard().setText(text)
self.anim.stop()
self.anim.start()
def showHTML(self, template, level, **data):
html = templates.render_tample(template, **data)
self.view.setHtml(html, templates.baseurl)
class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(self.next_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(0
if chlist.currentRow() == chlist.count() - 1
else chlist.currentRow() + 1))
self.connect(self.previous_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(chlist.count() - 1
if chlist.currentRow() == 0
else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(self.book.get_chapter(num).decode(encoding="utf-8"))
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
class HtmlViewerWidget(QWidget):
def __init__(self, parent):
super(HtmlViewerWidget, self).__init__(parent)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.view = QWebView()
self.view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.layout().addWidget(self.view)
def showHTML(self, html, data):
if os.path.isfile(html):
html = open(html).read()
html = html.replace(r'\n', '<br>')
templte = Template(html)
html = updateTemplate(data, templte)
self.view.setHtml(html, templates.baseurl)
class Dialog(QWidget):
def __init__(self):
super(Dialog, self).__init__()
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
| Qt.Popup | Qt.Tool)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.setWindowOpacity(app.DialogOpacity)
self.resize(app.DialogWidth, app.DialogHeight)
point = Utils.getDesktopCenterPoint(self)
self.move(point["x"], point["y"])
self.webview = QWebView(self)
self.webview.settings().setAttribute(QWebSettings.JavascriptEnabled,
True)
self.webview.settings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, app.Debug)
self.webview.settings().setAttribute(
QWebSettings.LocalContentCanAccessRemoteUrls, True)
self.webview.settings().setAttribute(QWebSettings.LocalStorageEnabled,
True)
self.webview.settings().setLocalStoragePath(app.HomeDir + "/data")
#self.webview.setContextMenuPolicy(Qt.NoContextMenu)
self.webview.settings().setDefaultTextEncoding("utf-8")
self.webview.setGeometry(1, 1, self.width() - 2, self.height() - 2)
self.webview.page().mainFrame().javaScriptWindowObjectCleared.connect(
self.setJavaScriptObject)
self.webview.setStyleSheet(
"QWebView{background-color: rgba(255, 193, 245, 0%); }")
self.webview.page().networkAccessManager().setCookieJar(app.CookieJar)
self.webview.load(QUrl.fromLocalFile(app.ViewDir + app.DialogSrc))
def setJavaScriptObject(self):
self.webview.page().mainFrame().addToJavaScriptWindowObject(
"_window_", self)
self.webview.page().mainFrame().addToJavaScriptWindowObject(
"_notifications_", app._notifications_)
@pyqtSignature("")
def quit(self):
self.close()
@pyqtSignature("int,int")
def moveTo(self, offsetX, offsetY):
self.move(self.x() + offsetX, self.y() + offsetY)
@pyqtSignature("", result="QString")
def loadHtml(self):
if app.NewDialogHtml != "":
return app.NewDialogHtml
file_object = open(app.ViewDir + app.DialogCon)
try:
dialogHtml = file_object.read()
finally:
file_object.close()
app.NewDialogHtml = dialogHtml
return dialogHtml
def _run(self):
self.retval = 'NOK'
self.handler_response_cache = []
injected_qt_request = InjectedQNetworkRequest(self.start_urllib_request)
self.nam = InjectedQNetworkAccessManager(ignore_ssl_errors=True)
self.nam.setInjectedResponse(
self.start_urllib_request,
self.start_urllib_response,
self.cookie_jar
)
self.nam.setAutoCloseUrls(self.auto_close_urls)
self.nam.autocloseOk.connect(self.autoclose_ok)
self.nam.autocloseFailed.connect(self.autoclose_failed)
self.nam.requestFinishing.connect(self._update_handler_results)
app = QApplication([])
grid = QGridLayout()
browser = QWebView()
page = browser.page()
page.setNetworkAccessManager(self.nam)
browser.load(injected_qt_request, self.nam.GetOperation)
test_ok_button = QPushButton("Test &OK")
test_ok_button.clicked.connect(self.button_ok)
test_failed_button = QPushButton("Test &Failed")
test_failed_button.clicked.connect(self.button_failed)
test_abort_button = QPushButton("Abort Test")
test_abort_button.clicked.connect(self.button_abort)
url_input = UrlInput(browser)
grid.addWidget(test_ok_button, 1, 0)
grid.addWidget(test_failed_button, 1, 1)
grid.addWidget(test_abort_button, 1, 2)
grid.addWidget(url_input, 2, 0, 1, 3)
grid.addWidget(browser, 4, 0, 1, 3)
main_frame = QWidget()
main_frame.setLayout(grid)
main_frame.show()
app.exec_()
processed = False
if self.retval == 'OK' or self.retval == 'NOK':
processed = True
return self.retval
class PicOccSVGEditDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent=None)
self.ui = svg_edit_dialog.Ui_SimplePicOccQDialog()
self.ui.setupUi(self)
self.web_view_widget = QWebView()
l = QVBoxLayout()
l.setMargin(0)
l.addWidget(self.web_view_widget)
# self.setLayout(l)
self.ui.centralWidget.setLayout(l)
self.connect(self.ui.singleCardButton, SIGNAL("clicked()"),
self.add_notes_single_mask)
self.connect(self.ui.multiButton, SIGNAL("clicked()"),
self.add_notes_multiple_masks)
self.connect(self.ui.multiMaskedButton, SIGNAL("clicked()"),
self.add_notes_multiple_hiding_masks)
restoreGeom(self, "PicOccSVGEditDialog")
def initialize_webview_for(self, path, size, ed, kybd):
#image_path is fully qualified path + filename
self.image_path = path
self.image_size = size
self.current_editor = ed
#Keep hold of this so we can pass it to the NoteGenerator instance
self.kbd_modifiers = kybd
url = QtCore.QUrl.fromLocalFile(svg_edit_path)
url.setQueryItems([('initStroke[opacity]', '0'),
('initStroke[width]', '0'), ('initTool', 'rect'),
('extensions', 'ext-picocc.js'),
('initFill[color]', 'FF0000')])
url.addQueryItem(
'dimensions', '{0},{1}'.format(self.image_size.width(),
self.image_size.height()))
url.addQueryItem('bkgd_url',
QtCore.QUrl.fromLocalFile(self.image_path).toString())
self.web_view_widget.setUrl(url)
def add_note_mask_style(self, using_subclass):
svg_contents = self.web_view_widget.page().mainFrame(
).evaluateJavaScript("svgCanvas.svgCanvasToString()")
gen = using_subclass(self.image_path, self.current_editor,
self.kbd_modifiers, svg_contents)
gen.generate_notes()
saveGeom(self, "PicOccSVGEditDialog")
self.accept()
def add_notes_multiple_masks(self):
self.add_note_mask_style(PicOccNoteGeneratorSeparate)
def add_notes_multiple_hiding_masks(self):
self.add_note_mask_style(PicOccNoteGeneratorHiding)
def add_notes_single_mask(self):
self.add_note_mask_style(PicOccNoteGeneratorSingle)
class Title2Boxoffice(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self, self.app)
self.view = QWebView()
self.page = self.view.page() #QWebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.view.show()
self.movies = Set()
self.alpha = 0
self.i = 1
def load(self, url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
document.evaluateJavaScript("""
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
Element.prototype.click = function() {
this.dispatchEvent(evt);
};
""")
rows = document.findAll("table table table tbody td a b")
if rows:
for a in rows:
strfied = unicode(a.toInnerXml())
self.movies.add(strfied)
print unicode(a.toInnerXml())
if document.findFirst(
"table:nth-child(4) tbody tr td font b a").tagName():
self.i = self.i + 1
else:
self.alpha = self.alpha + 1
self.i = 1
else:
self.alpha = self.alpha + 1
self.i = 1
if (self.alpha == len(page)):
self.writeToFile()
else:
newurl = "http://boxofficemojo.com/movies/alphabetical.htm?letter=%s&page=%d&p=.htm" % (
page[self.alpha], self.i)
print newurl
self.load(newurl)
def writeToFile(self):
print "Writing to file..."
file = codecs.open('moviename.lst', encoding='utf-8', mode='w+')
for a in self.movies:
file.write('%s\n' % a)
file.close()
sys.exit()
class HtmlViewerWidget(QWidget):
def __init__(self, parent):
super(HtmlViewerWidget, self).__init__(parent)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.view = QWebView()
self.view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.frame = QFrame()
self.frame.setLayout(QGridLayout())
self.frame.layout().setContentsMargins(0, 0, 0, 0)
self.toolbar = QToolBar()
self.spacer = QWidget()
self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.copyAction = self.toolbar.addAction(QIcon(":/icons/clipboard"), "Copy Text")
self.label = QLabel()
self.closeAction = self.toolbar.addAction(QIcon(":/icons/cancel"), "Close")
self.spaceraction = self.toolbar.insertWidget(self.closeAction, self.spacer)
self.labelaction = self.toolbar.insertWidget(self.spaceraction, self.label)
self.closeAction.triggered.connect(self.close)
self.copyAction.triggered.connect(self.copy_text)
self.layout().addWidget(self.frame)
self.frame.layout().addWidget(self.toolbar)
self.frame.layout().addWidget(self.view)
self.effect = QGraphicsOpacityEffect()
self.label.setGraphicsEffect(self.effect)
self.anim = QPropertyAnimation(self.effect, "opacity")
self.anim.setDuration(2000)
self.anim.setStartValue(1.0)
self.anim.setEndValue(0.0)
self.anim.setEasingCurve(QEasingCurve.OutQuad )
def copy_text(self):
self.label.setText("Copied to clipboard")
text = self.view.page().mainFrame().toPlainText()
QApplication.clipboard().setText(text)
self.anim.stop()
self.anim.start()
def showHTML(self, template, level, **data):
html = templates.render_tample(template, **data)
self.view.setHtml(html, templates.baseurl)
class HtmlViewerWidget(QWidget):
def __init__(self, parent):
super(HtmlViewerWidget, self).__init__(parent)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.view = QWebView(linkClicked=openimage)
self.view.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.layout().addWidget(self.view)
def showHTML(self, html, data):
base = os.path.dirname(os.path.abspath(__file__))
baseurl = QUrl.fromLocalFile(base + '\\')
if os.path.isfile(html):
html = open(html).read()
html = html.replace(r'\n', '<br>')
templte = Template(html)
html = updateTemplate(data, templte)
self.view.setHtml(html, baseurl)
class Browser(QWidget, BaseCentralWidget):
def __init__(self, URL, process=None, main=None):
QWidget.__init__(self)
BaseCentralWidget.__init__(self)
self.path = URL
self.process = process
v_box = QVBoxLayout(self)
#Web Frame
QWebSettings.globalSettings().setAttribute(QWebSettings.PluginsEnabled,
True)
self.webFrame = QWebView()
self.webFrame.setAcceptDrops(False)
factory = WebPluginFactory(self, main)
self.webFrame.page().setPluginFactory(factory)
self.webFrame.load(QUrl(URL))
v_box.addWidget(self.webFrame)
if process is not None:
time.sleep(0.5)
self.webFrame.reload()
if self.path.endswith(
'startPage.html') and sys.platform.find('win') != -1:
content = manage_files.read_file_content(self.path)
pathCss = os.path.join(resources.PRJ_PATH, 'doc', 'styles',
'ninja.css')
pathJs = os.path.join(resources.PRJ_PATH, 'doc', 'rsc')
content = content.replace('styles/ninja.css',
pathCss).replace('src="rsc',
'src="' + pathJs)
self.webFrame.setHtml(content)
def shutdown_pydoc(self):
if self.process is not None:
self.process.kill()
def find_match(self, word, back=False, sensitive=False, whole=False):
b = QWebPage.FindBackward if back else None
s = QWebPage.FindCaseSensitively if sensitive else None
self.webFrame.page().findText(word)
def addTabs(self, tabs):
"""
Add tabs to the popup.
Each tab is given as a tuple (html, name, resize). The last parameter
indicates if the text should be rescaled.
Tabs should not grab focus for main window to close on loosing focus.
"""
for html, name, resize in tabs:
tab = QWebView()
tab.setFocusPolicy(Qt.NoFocus)
if resize != 1:
tab.setTextSizeMultiplier(resize)
tab.linkClicked.connect(self.unscale)
self.addTab(tab, name)
tab.setHtml(html)
if resize != 1:
tab.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
tab.parent().setFocusPolicy(Qt.NoFocus)
def _create_view(self, html=None, section=None):
"Create the webview that will display the synoptic itself"
view = QWebView(self)
# This is supposedly an optimisation. Disable if there are
# graphical artifacts or something.
view.settings().TiledBackingStoreEnabled = True
view.setRenderHint(QtGui.QPainter.TextAntialiasing, False)
page = LoggingWebPage()
view.setPage(page)
view.setContextMenuPolicy(QtCore.Qt.PreventContextMenu)
# setup the JS interface
frame = view.page().mainFrame()
self.js = JSInterface(frame)
self.js.subscription.connect(self.subscribe)
# mouse interaction signals
self.clicked = self.js.leftclicked
self.rightClicked = self.js.rightclicked
self.hovered = self.js.hovered
self.clicked.connect(self._on_click)
self.rightClicked.connect(self._on_rightclick)
self.hovered.connect(self._on_hover)
# Inject JSInterface into the JS global namespace as "Backend"
def addBackend():
frame.addToJavaScriptWindowObject('QtBackend', self.js)
view.connect(frame, QtCore.SIGNAL("javaScriptWindowObjectCleared()"),
addBackend)
# load the page
# need to set the "base URL" for the webview to find the
# resources (js, css).
base_url = QtCore.QUrl().fromLocalFile(
os.path.abspath(os.path.dirname(__file__)) + "/web/")
# some ugly magic to get the path to the SVG file right. It
# needs to be absolute because local paths go to the base URL.
abspath = os.path.dirname(os.path.abspath(html))
print("absolute path " + abspath + '/' + html)
with open(html) as f:
text = f.read().replace("${path}", abspath) # TODO: use template
if self._modelNames is not None:
if "/*configplaceholder*/" in text:
print("placeholder found")
texta, textb = text.split("/*configplaceholder*/", 1)
text = texta + self._modelNames + textb
view.setHtml(text, base_url)
return view
class PicOccSVGEditDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent=None)
self.ui = svg_edit_dialog.Ui_SimplePicOccQDialog()
self.ui.setupUi(self)
self.web_view_widget = QWebView()
l = QVBoxLayout()
l.setMargin(0)
l.addWidget(self.web_view_widget)
# self.setLayout(l)
self.ui.centralWidget.setLayout(l)
self.connect(self.ui.singleCardButton, SIGNAL("clicked()"), self.add_notes_single_mask)
self.connect(self.ui.multiButton, SIGNAL("clicked()"), self.add_notes_multiple_masks)
self.connect(self.ui.multiMaskedButton, SIGNAL("clicked()"), self.add_notes_multiple_hiding_masks)
restoreGeom(self, "PicOccSVGEditDialog")
def initialize_webview_for(self, path, size, ed, kybd):
#image_path is fully qualified path + filename
self.image_path = path
self.image_size = size
self.current_editor = ed
#Keep hold of this so we can pass it to the NoteGenerator instance
self.kbd_modifiers = kybd
url = QtCore.QUrl.fromLocalFile(svg_edit_path)
url.setQueryItems([('initStroke[opacity]', '0'),
('initStroke[width]', '0'),
('initTool', 'rect'),
('extensions', 'ext-picocc.js'),
('initFill[color]', 'FF0000')])
url.addQueryItem('dimensions', '{0},{1}'.format(self.image_size.width(), self.image_size.height()))
url.addQueryItem('bkgd_url', QtCore.QUrl.fromLocalFile(self.image_path).toString())
self.web_view_widget.setUrl(url)
def add_note_mask_style(self, using_subclass):
svg_contents = self.web_view_widget.page().mainFrame().evaluateJavaScript("svgCanvas.svgCanvasToString()")
gen = using_subclass(self.image_path, self.current_editor, self.kbd_modifiers, svg_contents)
gen.generate_notes()
saveGeom(self, "PicOccSVGEditDialog")
self.accept()
def add_notes_multiple_masks(self):
self.add_note_mask_style(PicOccNoteGeneratorSeparate)
def add_notes_multiple_hiding_masks(self):
self.add_note_mask_style(PicOccNoteGeneratorHiding)
def add_notes_single_mask(self):
self.add_note_mask_style(PicOccNoteGeneratorSingle)
def addTabs(self, tabs):
"""
Add tabs to the popup.
Each tab is given as a tuple (html, name, resize). The last parameter
indicates if the text should be rescaled.
Tabs should not grab focus for main window to close on loosing focus.
"""
for html, name, resize in tabs:
tab = QWebView()
tab.setFocusPolicy(Qt.NoFocus)
if resize != 1:
tab.setTextSizeMultiplier(resize)
tab.linkClicked.connect(self.unscale)
self.addTab(tab, name)
tab.setHtml(html)
if resize != 1:
tab.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
tab.parent().setFocusPolicy(Qt.NoFocus)
class LookUp(QApplication):
def __init__(self):
QApplication.__init__(self, [])
self.window = QWidget()
self.window.setWindowTitle("IP Geolocator")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/ico/python.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.window.setWindowFlags(PyQt4.QtCore.Qt.WindowStaysOnTopHint)
self.window.setWindowIcon(icon)
self.web = QWebView(self.window)
self.web.setMinimumSize(1024, 800)
self.web.page().mainFrame().addToJavaScriptWindowObject('self', self)
self.web.setHtml(maphtml)
self.layout = QVBoxLayout(self.window)
self.layout.addWidget(self.web)
self.window.show()
self.exec_()
class ShoutCastForm(PluginBase.PluginBase):
'''Grab Shoutcast streams and save them as "bookmarks" - and play them on
the currently selected server.
General shoutcast information is not preserved between runs. Also, the
shoutcast server/API is pretty lame so timeouts actually occur quite
frequently.
'''
moduleName = '&Shoutcast'
moduleIcon = "network-workgroup"
def load(self):
pass
def event(self, event):
if event.type() == QEvent.Paint:
if not hasattr(self, 'webView'):
self._load()
self.event = super(ShoutCastForm, self).event
return False
def _load(self):
self.cookie = QNetworkCookie('Settings', 'Player~others|Bandwidth~ALL|Codec~ALL')
self.cookie.setDomain('.shoutcast.com')
self.cookie.setExpirationDate(QDateTime())
self.cookie.setPath('/')
self.webView = QWebView(self)
self.webPage = self.webView.page()
self.cookiejar = QNetworkCookieJar()
self.cookiejar.setAllCookies([self.cookie])
self.webPage.networkAccessManager().setCookieJar(self.cookiejar)
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.webView)
self.webView.load(QUrl(HOMEURL))
self.webPage.setLinkDelegationPolicy(QWebPage.DelegateExternalLinks)
self.connect(self.webPage, SIGNAL('linkClicked(const QUrl&)'), self._processLink)
def _processLink(self, url):
if url.host() == TUNEIN:
self._playStation(unicode(url.toString()))
else:
self.webView.load(url)
self.webView.show()
def _playStation(self, url):
try:
streamList = streamTools.getStreamList(url)
except streamTools.ParseError:
return
if streamList:
self.modelManager.playQueue.extend(streamList)
class QBrowserApp:
def __init__(self, filename, width, height):
self._listeners = []
self.app = QApplication(sys.argv)
self.win = QMainWindow()
self.win.resize(width, height)
self.browser = QWebView(_win)
filename = os.path.abspath(filename)
self.browser.setUrl(QUrl(filename))
filename = filename.split("?")[0]
path, path = os.path.split(filename)
self.browser.setHtml(open(filename).read(),
QUrl.fromLocalFile(filename))
self.win.setCentralWidget(self.browser)
self.win.show()
from __pyjamas__ import pygwt_processMetas, set_main_frame
from __pyjamas__ import set_gtk_module
set_main_frame(self)
def current_web_frame(self):
return self.browser.page().currentFrame()
def getDomDocument(self):
element = self.current_web_frame().documentElement()
return _Document(element)
def addEventListener(self, element, event, callback):
listener = Listener(element, event, callback)
l_id = "__pyjamas_listener_%s__" % abs(id(listener))
self.current_web_frame().addToJavaScriptWindowObject(l_id, listener)
js = "this.%s=function(e) { window.%s.execute(e); }" % (event, l_id)
element._element.evaluateJavaScript(js)
self._listeners.append(listener)
def _alert(self, txt):
js = "window.alert('%s');" % (txt)
doc = self.getDomDocument()
doc._element.evaluateJavaScript(js)
def _addWindowEventListener(self, event, callback):
listener = Listener(self.current_web_frame(), event, callback)
l_id = "__pyjamas_listener_%s__" % abs(id(listener))
self.current_web_frame().addToJavaScriptWindowObject(l_id, listener)
js = "this.%s=function(e) { window.%s.execute(e); }" % (event, l_id)
doc = self.getDomDocument()
doc._element.evaluateJavaScript(js)
self._listeners.append(listener)
def getUri(self):
return unicode(self.current_web_frame().baseUrl().toString())
class Title2Boxoffice(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self,self.app)
self.view = QWebView()
self.page = self.view.page() #QWebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.view.show()
self.movies = Set()
self.alpha = 0
self.i = 1
def load(self,url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
document.evaluateJavaScript("""
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
Element.prototype.click = function() {
this.dispatchEvent(evt);
};
""")
rows = document.findAll("table table table tbody td a b")
if rows:
for a in rows:
strfied = unicode(a.toInnerXml())
self.movies.add(strfied)
print unicode(a.toInnerXml())
if document.findFirst("table:nth-child(4) tbody tr td font b a").tagName():
self.i = self.i + 1
else:
self.alpha = self.alpha + 1
self.i = 1
else:
self.alpha = self.alpha + 1
self.i = 1
if(self.alpha == len(page)):
self.writeToFile()
else:
newurl = "http://boxofficemojo.com/movies/alphabetical.htm?letter=%s&page=%d&p=.htm"%(page[self.alpha],self.i)
print newurl
self.load(newurl)
def writeToFile(self):
print "Writing to file..."
file = codecs.open('moviename.lst', encoding='utf-8', mode='w+')
for a in self.movies:
file.write('%s\n'%a)
file.close()
sys.exit()
class QBrowserApp:
def __init__(self, filename, width, height):
self._listeners = []
self.app = QApplication(sys.argv)
self.win = QMainWindow()
self.win.resize(width, height)
self.browser = QWebView(_win)
filename = os.path.abspath(filename)
self.browser.setUrl(QUrl(filename))
filename = filename.split("?")[0]
path, path = os.path.split(filename)
self.browser.setHtml(
open(filename).read(), QUrl.fromLocalFile(filename))
self.win.setCentralWidget(self.browser)
self.win.show()
from __pyjamas__ import pygwt_processMetas, set_main_frame
from __pyjamas__ import set_gtk_module
set_main_frame(self)
def current_web_frame(self):
return self.browser.page().currentFrame()
def getDomDocument(self):
element = self.current_web_frame().documentElement()
return _Document(element)
def addEventListener(self, element, event, callback):
listener = Listener(element, event, callback)
l_id = "__pyjamas_listener_%s__" % abs(id(listener))
self.current_web_frame().addToJavaScriptWindowObject(l_id, listener)
js = "this.%s=function(e) { window.%s.execute(e); }" % (event, l_id)
element._element.evaluateJavaScript(js)
self._listeners.append(listener)
def _alert(self, txt):
js = "window.alert('%s');" % (txt)
doc = self.getDomDocument()
doc._element.evaluateJavaScript(js)
def _addWindowEventListener(self, event, callback):
listener = Listener(self.current_web_frame(), event, callback)
l_id = "__pyjamas_listener_%s__" % abs(id(listener))
self.current_web_frame().addToJavaScriptWindowObject(l_id, listener)
js = "this.%s=function(e) { window.%s.execute(e); }" % (event, l_id)
doc = self.getDomDocument()
doc._element.evaluateJavaScript(js)
self._listeners.append(listener)
def getUri(self):
return unicode(self.current_web_frame().baseUrl().toString())
class GoogleSearchBot(QApplication):
def __init__(self, argv, show_window=True):
super(GoogleSearchBot, self).__init__(argv)
self.jquery = get_jquery()
self.web_view = QWebView()
self.web_page = WebPage()
self.web_view.setPage(self.web_page)
if show_window is True:
self.web_view.show()
self.connect(self.web_view, SIGNAL("loadFinished(bool)"),
self.load_finished)
self.set_load_function(None)
def google_search(self, keyword_string):
self.set_load_function(self.parse_google_search)
current_frame = self.web_view.page().currentFrame()
current_frame.evaluateJavaScript(r"""
$("input[title=Google Search]").val("%s");
$("input[value=Google Search]").parents("form").submit();
""" % keyword_string)
def load_finished(self, ok):
current_frame = self.web_page.currentFrame()
current_frame.evaluateJavaScript(self.jquery)
self.load_function(*self.load_function_args,
**self.load_function_kwargs)
def parse_google_search(self):
current_frame = self.web_page.currentFrame()
results = current_frame.evaluateJavaScript(r"""
var results = "";
$("h3[class=r]").each(function(i) {
results += $(this).text() + "\n";
});
results;
""")
print('Google search result\n====================')
for i, result in enumerate(
unicode(results.toString(), 'utf-8').splitlines()):
print('%d. %s' % (i + 1, result))
self.exit()
def search(self, keyword):
self.set_load_function(self.google_search, keyword)
self.web_page.currentFrame().load(QUrl('http://www.google.com/'))
def set_load_function(self, load_function, *args, **kwargs):
self.load_function = load_function
self.load_function_args = args
self.load_function_kwargs = kwargs
class Browser(QWidget, BaseCentralWidget):
def __init__(self, URL, process=None, main=None):
QWidget.__init__(self)
BaseCentralWidget.__init__(self)
self.path = URL
self.process = process
v_box = QVBoxLayout(self)
#Web Frame
QWebSettings.globalSettings().setAttribute(QWebSettings.PluginsEnabled, True)
self.webFrame = QWebView()
self.webFrame.setAcceptDrops(False)
factory = WebPluginFactory(self, main)
self.webFrame.page().setPluginFactory(factory)
self.webFrame.load(QUrl(URL))
v_box.addWidget(self.webFrame)
if process is not None:
time.sleep(0.5)
self.webFrame.reload()
if self.path.endswith('startPage.html') and sys.platform.find('win') != -1:
content = manage_files.read_file_content(self.path)
pathCss = os.path.join(resources.PRJ_PATH, 'doc', 'styles', 'ninja.css')
pathJs = os.path.join(resources.PRJ_PATH, 'doc', 'rsc')
content = content.replace('styles/ninja.css', pathCss).replace('src="rsc', 'src="' + pathJs)
self.webFrame.setHtml(content)
def shutdown_pydoc(self):
if self.process is not None:
self.process.kill()
def find_match(self, word, back=False, sensitive=False, whole=False):
b = QWebPage.FindBackward if back else None
s = QWebPage.FindCaseSensitively if sensitive else None
self.webFrame.page().findText(word)
class TweetWindow(QWidget):
def __init__(self):
super(TweetWindow, self).__init__()
self.setWindowFlags(Qt.FramelessWindowHint|Qt.WindowStaysOnTopHint|Qt.Popup|Qt.Tool)
self.setAttribute(Qt.WA_TranslucentBackground,True)
self.resize(550,520)
point = Utils.getDesktopCenterPoint(self)
self.move(point["x"],point["y"])
self.webview = QWebView(self)
self.webview.settings().setAttribute(QWebSettings.JavascriptEnabled, True)
self.webview.settings().setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
self.webview.settings().setAttribute(QWebSettings.LocalContentCanAccessRemoteUrls, True)
self.webview.settings().setAttribute(QWebSettings.LocalStorageEnabled, True)
self.webview.settings().setLocalStoragePath(AppProperty.HomeDir+"/data")
#self.webview.setContextMenuPolicy(Qt.NoContextMenu)
self.webview.settings().setDefaultTextEncoding("utf-8")
self.webview.setGeometry(1,1,self.width()-2,self.height()-2)
self.webview.page().mainFrame().javaScriptWindowObjectCleared.connect(self.setJavaScriptObject)
self.webview.setStyleSheet("QWebView{background-color: rgba(255, 193, 245, 0%); }")
self.webview.page().networkAccessManager().setCookieJar(AppProperty.CookieJar)
self.webview.load(QUrl.fromLocalFile(AppProperty.HomeDir+"/html/tweetWindow.html"))
def setJavaScriptObject(self):
self.webview.page().mainFrame().addToJavaScriptWindowObject("_window_", self)
#self.webview.page().mainFrame().addToJavaScriptWindowObject("_service_", self._service_)
self.webview.page().mainFrame().addToJavaScriptWindowObject("_notifications_", AppProperty._notifications_)
@pyqtSignature("")
def quit(self):
self.close()
@pyqtSignature("int,int")
def moveTo(self,offsetX,offsetY):
self.move(self.x()+offsetX,self.y()+offsetY)
@pyqtSignature("",result="QString")
def loadHtml(self):
if AppProperty.NewTweetHtml!="":
return AppProperty.NewTweetHtml
file_object = open('html/sendTweetPage.html')
try:
tweetHtml = file_object.read()
finally:
file_object.close()
tweetHtml = tweetHtml.replace("${home}","file:///"+AppProperty.HomeDir.replace("\\","/")+"/")
AppProperty.NewTweetHtml = tweetHtml
return tweetHtml
class JsBridge(QtGui.QWidget):
def __init__(self, parent=None):
super(JsBridge, self).__init__(parent)
self.ui = QWebView()
self.ui.setHtml("""
<input type="text" id="username" value="Vasya Pupkin"><br>
<a onclick="bridge.someEvent()">Hello, Python!</a>
""")
self.ui.page().mainFrame().javaScriptWindowObjectCleared.connect(
self.populateJavaScriptWindowObject)
@QtCore.pyqtSlot()
def someEvent(self):
print('someEvent() called!')
frame = self.ui.page().mainFrame()
username = frame.findFirstElement('#username').evaluateJavaScript('this.value')
QtGui.QMessageBox.about(self, "Aloha", "Hello, " + username + "!")
def populateJavaScriptWindowObject(self):
print("Bridge request handled")
self.ui.page().mainFrame().addToJavaScriptWindowObject('bridge', self)
def _create_view(self, html=None, section=None):
"Create the webview that will display the synoptic itself"
view = QWebView(self)
# This is supposedly an optimisation. Disable if there are
# graphical artifacts or something.
view.settings().TiledBackingStoreEnabled = True
view.setRenderHint(QtGui.QPainter.TextAntialiasing, False)
page = LoggingWebPage()
view.setPage(page)
view.setContextMenuPolicy(QtCore.Qt.PreventContextMenu)
# setup the JS interface
frame = view.page().mainFrame()
self.js = JSInterface(frame)
self.js.subscription.connect(self.subscribe)
# mouse interaction signals
self.clicked = self.js.leftclicked
self.rightClicked = self.js.rightclicked
self.hovered = self.js.hovered
self.clicked.connect(self._on_click)
self.rightClicked.connect(self._on_rightclick)
self.hovered.connect(self._on_hover)
# Inject JSInterface into the JS global namespace as "Backend"
def addBackend():
frame.addToJavaScriptWindowObject('Backend', self.js)
view.connect(frame, QtCore.SIGNAL("javaScriptWindowObjectCleared()"), addBackend)
# load the page
# need to set the "base URL" for the webview to find the
# resources (js, css).
base_url = QtCore.QUrl().fromLocalFile(
os.path.abspath(os.path.dirname(__file__)) + "/web/")
# some ugly magic to get the path to the SVG file right. It
# needs to be absolute because local paths go to the base URL.
abspath = os.path.dirname(os.path.abspath(html))
with open(html) as f:
text = f.read().replace("${path}", abspath) # TODO: use template
view.setHtml(text, base_url)
return view
def run(self,urllib_response,request_url):
self.retval = False
request = InjectedQNetworkRequest(request_url)
nam = InjectedQNetworkAccessManager()
nam.setInjectedResponse(urllib_response)
nam.setAutoCloseUrls(self.autocloseurls)
nam.autocloseOk.connect(self.button_ok)
app = QApplication([])
grid = QGridLayout()
browser = QWebView()
page = browser.page()
page.setNetworkAccessManager(nam)
browser.load(request, nam.GetOperation)
test_ok_button = QPushButton("Test &OK")
test_ok_button.clicked.connect(self.button_ok)
test_failed_button = QPushButton("Test &Failed")
test_failed_button.clicked.connect(self.button_failed)
url_input = UrlInput(browser)
grid.addWidget(test_ok_button, 1, 0)
grid.addWidget(test_failed_button, 1, 1)
grid.addWidget(url_input, 2, 0, 1, 2)
grid.addWidget(browser, 4, 0, 1, 2)
main_frame = QWidget()
main_frame.setLayout(grid)
main_frame.show()
app.exec_()
print "done"
return self.retval
class IcecastForm(PluginBase.PluginBase):
''' Embeds the xiph.org Icecast yellow pages, and loads the
streams from the m3u and XSPF playlist files.
'''
moduleName = 'I&cecast'
moduleIcon = "network-workgroup"
def load(self):
pass
def event(self, event):
if event.type() == QEvent.Paint:
if not hasattr(self, 'webView'):
self._load()
self.event = super(IcecastForm, self).event
return False
def _load(self):
self.webView = QWebView(self)
self.webPage = self.webView.page()
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.webView)
self.webView.load(QUrl(HOMEURL))
self.webPage.setLinkDelegationPolicy(QWebPage.DelegateExternalLinks)
self.connect(self.webPage, SIGNAL('linkClicked(const QUrl&)'), self._processLink)
def _processLink(self, url):
urlString = unicode(url.toString())
urlMatch = TUNEIN.search(urlString)
if urlMatch is not None:
self._playStation(urlString)
else:
self.webView.load(url)
self.webView.show()
def _playStation(self, url):
try:
streamList = streamTools.getStreamList(url)
except streamTools.ParseError:
return
if streamList:
self.modelManager.playQueue.extend(streamList)
class Browser(QObject):
def __init__(self, callback):
QObject.__init__(self, app)
self.callback = callback
self.view = QWebView()
self.page = self.view.page()
self.page.mainFrame().loadFinished.connect(self.cb)
def load(self, url):
self.page.mainFrame().setUrl(QUrl(url))
self.current_url = url
def back(self):
self.view.back()
def cb(self):
usleep(INITIAL_SLEEP)
document = self.page.mainFrame().documentElement()
self.callback(self, self.current_url, document)
class Browser(QObject):
def __init__(self, callback):
QObject.__init__(self, app)
self.callback = callback
self.view = QWebView()
self.page = self.view.page()
self.page.mainFrame().loadFinished.connect(self.cb)
def load(self, url):
self.page.mainFrame().setUrl(QUrl(url))
self.current_url = url
def back(self):
self.view.back()
def cb(self):
usleep(INITIAL_SLEEP)
document = self.page.mainFrame().documentElement()
self.callback(self, self.current_url, document)
def main():
app = QApplication([])
webview = QWebView()
loop = QEventLoop()
webview.loadFinished.connect(loop.quit)
webview.load(QUrl('http://example.webscraping.com/search'))
loop.exec_()
webview.show()
frame = webview.page().mainFrame()
frame.findFirstElement('#search_term').setAttribute('value', '.')
frame.findFirstElement('#page_size option:checked').setPlainText('1000')
frame.findFirstElement('#search').evaluateJavaScript('this.click()')
elements = None
while not elements:
app.processEvents()
elements = frame.findAllElements('#result a')
countries = [e.toPlainText().strip() for e in elements]
print countries
class Browser(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
pixmap = QPixmap('./banner_nuevo_2016.png')
print pixmap.width(), pixmap.height()
self.ui.L_ima.setGeometry(20, 10, pixmap.width(), pixmap.height())
self.ui.L_ima.setPixmap(pixmap)
self.Web = QWebView()
self.la = QVBoxLayout()
self.la.addWidget(self.Web)
self.ui.W_map.setLayout(self.la)
self.timer = QTimer(self)
self.timer.timeout.connect(self._result_available)
self.timer.start(5000) #milisegundos
def _result_available(self):
frame = self.Web.page().mainFrame()
view.Web.reload()
def url2image(url, file_name=None):
"""Function at the specified url downloads the page and stores it QImage object and returns it.
If you pass file_name, then the function will save the picture in the file.
Функция по указанному url загружает страницу и сохраняет ее объект QImage и возвращает его.
Если передать file_name, тогда функция сохранит в файл картинку.
"""
# Нужно создавать только один раз
global qApp
if qApp is None:
qApp = QApplication([])
# Пришлось добавить из-за того, что картинки не прогружались
load_pyqt4_plugins()
# TODO: прятать вертикальный и горизонтальный ползунки
# Загрузка url и ожидание ее
view = QWebView()
view.setPage(WebPage())
# view.show()
view.load(QUrl(url))
loop = QEventLoop()
view.loadFinished.connect(loop.quit)
loop.exec_()
# Запрашиваем через javascript размеры страницы сайта
width = view.page().mainFrame().evaluateJavaScript(
"window.document.body.scrollWidth")
height = view.page().mainFrame().evaluateJavaScript(
"window.document.body.scrollHeight")
# Устанавливаем границы документа
view.page().setViewportSize(QSize(width, height))
img = QImage(width, height, QImage.Format_ARGB32)
painter = QPainter(img)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
view.page().mainFrame().render(painter)
painter.end()
if file_name:
img.save(file_name)
# qApp.exec()
return img
class GoogleScraper(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self,self.app)
self.view = QWebView()
self.page = self.view.page() #QWebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.view.show()
self.movies = Set()
def load(self,url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
document.evaluateJavaScript("""
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
Element.prototype.click = function() {
this.dispatchEvent(evt);
};
""")
rows = document.findAll("h3.r a.l")
nextbtn = document.findFirst("a#pnnext")
for a in rows:
print a.attribute("href")
self.movies.add(a.attribute("href"))
if nextbtn.tagName():
usleep(random.randint(20,300))
nextbtn.evaluateJavaScript("this.click()")
else:
self.writeToFile()
def writeToFile(self):
print "Writing to file..."
file = open('ggmovie.lst', 'w')
for a in self.movies:
file.write('%s\n'%a)
file.close()
class GoogleScraper(QObject):
def __init__(self):
self.app = QApplication(sys.argv)
QObject.__init__(self, self.app)
self.view = QWebView()
self.page = self.view.page() #QWebPage(self.app)
self.page.mainFrame().loadFinished.connect(self.loadFinished)
self.view.show()
self.movies = Set()
def load(self, url):
self.page.mainFrame().setUrl(QUrl(url))
def loadFinished(self):
document = self.page.mainFrame().documentElement()
document.evaluateJavaScript("""
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
Element.prototype.click = function() {
this.dispatchEvent(evt);
};
""")
rows = document.findAll("h3.r a.l")
nextbtn = document.findFirst("a#pnnext")
for a in rows:
print a.attribute("href")
self.movies.add(a.attribute("href"))
if nextbtn.tagName():
usleep(random.randint(20, 300))
nextbtn.evaluateJavaScript("this.click()")
else:
self.writeToFile()
def writeToFile(self):
print "Writing to file..."
file = open('ggmovie.lst', 'w')
for a in self.movies:
file.write('%s\n' % a)
file.close()
class BrowserWidget(QWidget, itab_item.ITabItem):
###############################################################################
# RecentProjectItem SIGNALS
###############################################################################
"""
openProject(QString)
openPreferences()
dontOpenStartPage()
"""
###############################################################################
def __init__(self, url, process=None, parent=None):
QWidget.__init__(self, parent)
itab_item.ITabItem.__init__(self)
self._id = url
self._process = process
vbox = QVBoxLayout(self)
#Web Frame
self.webFrame = QWebView(self)
self.webFrame.setAcceptDrops(False)
self.webFrame.load(QUrl(url))
vbox.addWidget(self.webFrame)
if process is not None:
time.sleep(0.5)
self.webFrame.load(QUrl(url))
self.webFrame.page().currentFrame().setScrollBarPolicy(
Qt.Vertical, Qt.ScrollBarAsNeeded)
self.webFrame.page().currentFrame().setScrollBarPolicy(
Qt.Horizontal, Qt.ScrollBarAsNeeded)
def start_page_operations(self, url):
opt = file_manager.get_basename(url.toString())
self.emit(SIGNAL(opt))
def shutdown_pydoc(self):
if self._process is not None:
self._process.kill()
def find_match(self, word, back=False, sensitive=False, whole=False):
self.webFrame.page().findText(word)
class BrowserWidget(QWidget, itab_item.ITabItem):
###############################################################################
# RecentProjectItem SIGNALS
###############################################################################
"""
openProject(QString)
openPreferences()
dontOpenStartPage()
"""
###############################################################################
def __init__(self, url, process=None, parent=None):
QWidget.__init__(self, parent)
itab_item.ITabItem.__init__(self)
self._id = url
self._process = process
vbox = QVBoxLayout(self)
#Web Frame
self.webFrame = QWebView(self)
self.webFrame.setAcceptDrops(False)
self.webFrame.load(QUrl(url))
vbox.addWidget(self.webFrame)
if process is not None:
time.sleep(0.5)
self.webFrame.load(QUrl(url))
self.webFrame.page().currentFrame().setScrollBarPolicy(
Qt.Vertical, Qt.ScrollBarAsNeeded)
self.webFrame.page().currentFrame().setScrollBarPolicy(
Qt.Horizontal, Qt.ScrollBarAsNeeded)
def start_page_operations(self, url):
opt = file_manager.get_basename(url.toString())
self.emit(SIGNAL(opt))
def shutdown_pydoc(self):
if self._process is not None:
self._process.kill()
def find_match(self, word, back=False, sensitive=False, whole=False):
self.webFrame.page().findText(word)
def run(self):
global data
from PyQt4.QtCore import QObject, pyqtSlot
from PyQt4.QtGui import QApplication
from PyQt4.QtWebKit import QWebView
html = '''
<html>
<body>
<h1>Hello!</h1><br>
<h2><a href=“#” onclick=“printer.text(‘Message from QWebView')“>QObject Test</a></h2>
<h2><a href=“#” onclick=“alert(‘Javascript works!')“>JS test</a></h2>
</body>
</html>
'''
class ConsolePrinter(QObject):
def __init__(self, parent=None):
super(ConsolePrinter, self).__init__(parent)
@pyqtSlot(str)
def text(self, message):
print message
self.app = QApplication(sys.argv)
view = QWebView()
frame = view.page().mainFrame()
printer = ConsolePrinter()
view.setHtml(html)
#frame.addToJavaScriptWindowObject('printer', printer)
#frame.evaluateJavaScript("alert('Hello');")
#frame.evaluateJavaScript(“printer.text(‘Goooooooooo!');“)
view.show()
self.app.exec_()
print 'exiting'
self.join()
class HTMLViewerDialog(SizePersistedDialog, Ui_Dialog, Logger):
marvin_device_status_changed = pyqtSignal(dict)
def accept(self):
self._log_location()
super(HTMLViewerDialog, self).accept()
def close(self):
self._log_location()
super(HTMLViewerDialog, self).close()
def copy_to_clipboard(self, *args):
'''
Store window contents to system clipboard
'''
modifiers = Application.keyboardModifiers()
if bool(modifiers & Qt.AltModifier):
contents = self.html_wv.page().currentFrame().toHtml()
#contents = BeautifulSoup(str(contents)).prettify()
QApplication.clipboard().setText(contents)
else:
contents = self.html_wv.page().currentFrame().toPlainText()
QApplication.clipboard().setText(unicode(contents))
if hasattr(self, 'ctc_button'):
self.ctc_button.setText('Copied')
self.ctc_button.setIcon(QIcon(I('ok.png')))
def dispatch_button_click(self, button):
'''
BUTTON_ROLES = ['AcceptRole', 'RejectRole', 'DestructiveRole', 'ActionRole',
'HelpRole', 'YesRole', 'NoRole', 'ApplyRole', 'ResetRole']
'''
self._log_location()
if self.bb.buttonRole(button) == QDialogButtonBox.AcceptRole:
# Save content
self.accept()
elif self.bb.buttonRole(button) == QDialogButtonBox.ActionRole:
if button.objectName() == 'refresh_button':
self.refresh_custom_column()
elif button.objectName() == 'copy_to_clipboard_button':
self.copy_to_clipboard()
elif self.bb.buttonRole(button) == QDialogButtonBox.RejectRole:
# Cancelled
self.close()
def esc(self, *args):
self.close()
def initialize(self, parent, content, book_id, installed_book, marvin_db_path, use_qwv=True):
'''
__init__ is called on SizePersistedDialog()
'''
self.setupUi(self)
self.book_id = book_id
self.connected_device = parent.opts.gui.device_manager.device
self.installed_book = installed_book
self.marvin_db_path = marvin_db_path
self.opts = parent.opts
self.parent = parent
self.stored_command = None
self.verbose = parent.verbose
self._log_location(installed_book.title)
# Subscribe to Marvin driver change events
self.connected_device.marvin_device_signals.reader_app_status_changed.connect(
self.marvin_status_changed)
# Set the icon
self.setWindowIcon(self.parent.icon)
# Set or hide the header
if content['header']:
self.header.setText(content['header'])
else:
self.header.setVisible(False)
# Set the titles
self.setWindowTitle(content['title'])
self.html_gb.setTitle(content['group_box_title'])
if content['toolTip']:
self.html_gb.setToolTip(content['toolTip'])
# Set the bg color of the content to the dialog bg color
bgcolor = self.palette().color(QPalette.Background)
palette = QPalette()
palette.setColor(QPalette.Base, bgcolor)
#self._log(repr(content['html_content']))
# Initialize the window content
if use_qwv:
# Add a QWebView to layout
self.html_wv = QWebView()
self.html_wv.setHtml(content['html_content'])
self.html_wv.sizeHint = self.wv_sizeHint
self.html_wv.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
self.html_wv.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.html_wv.linkClicked.connect(self.link_clicked)
self.html_gb_vl.addWidget(self.html_wv)
self.html_tb.setVisible(False)
else:
# Initialize the contents of the TextBrowser
self.html_tb.setText(content['html_content'])
#self.html_tb.setPalette(palette)
# Set or hide the footer
if content['footer']:
self.footer.setText(content['footer'])
else:
self.footer.setVisible(False)
# Add Copy to Clipboard button
self.ctc_button = self.bb.addButton('&Copy to clipboard',
self.bb.ActionRole)
self.ctc_button.clicked.connect(self.copy_to_clipboard)
self.ctc_button.setIcon(QIcon(I('edit-copy.png')))
self.ctc_button.setObjectName('copy_to_clipboard_button')
self.ctc_button.setToolTip('<p>Copy plain text to clipboard, <b>Alt/Option-click</b> for HTML</p>')
self.copy_action = QAction(self)
self.addAction(self.copy_action)
self.copy_action.setShortcuts(QKeySequence.Copy)
self.copy_action.triggered.connect(self.copy_to_clipboard)
# Add Refresh button if enabled
if content['refresh']:
self.refresh_method = content['refresh']['method']
self.refresh_button = self.bb.addButton("Refresh '%s'" % content['refresh']['name'],
self.bb.ActionRole)
self.refresh_button.setIcon(QIcon(os.path.join(self.parent.opts.resources_path,
'icons',
'from_marvin.png')))
self.refresh_button.setObjectName('refresh_button')
self.refresh_button.setEnabled(bool(self.installed_book.cid))
# Hook the button events
self.bb.clicked.connect(self.dispatch_button_click)
# Restore position
self.resize_dialog()
def link_clicked(self, url):
'''
Open clicked link in regular browser
'''
open_url(url)
def marvin_status_changed(self, cmd_dict):
'''
'''
self.marvin_device_status_changed.emit(cmd_dict)
command = cmd_dict['cmd']
self._log_location(command)
if command in ['disconnected', 'yanked']:
self._log("closing dialog: %s" % command)
self.close()
def refresh_custom_column(self):
'''
If enabled, pass window content to custom column
'''
refresh = getattr(self.parent, self.refresh_method, None)
if refresh is not None:
refresh()
self.refresh_button.setText('Refreshed')
self.refresh_button.setIcon(QIcon(I('ok.png')))
else:
self._log_location("ERROR: Can't execute '%s'" % self.refresh_method)
def store_command(self, command):
'''
'''
self._log_location(command)
self.stored_command = command
self.close()
def wv_sizeHint(self):
'''
QWebVew apparently has a default size of 800, 600
'''
return QSize(400,200)
class Browser(QWidget):
"""LilyPond documentation browser widget."""
def __init__(self, dockwidget):
super(Browser, self).__init__(dockwidget)
layout = QVBoxLayout(spacing=0)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.toolbar = tb = QToolBar()
self.webview = QWebView(contextMenuPolicy=Qt.CustomContextMenu)
self.chooser = QComboBox(sizeAdjustPolicy=QComboBox.AdjustToContents)
self.search = SearchEntry(maximumWidth=200)
layout.addWidget(self.toolbar)
layout.addWidget(self.webview)
ac = dockwidget.actionCollection
ac.help_back.triggered.connect(self.webview.back)
ac.help_forward.triggered.connect(self.webview.forward)
ac.help_home.triggered.connect(self.showHomePage)
ac.help_print.triggered.connect(self.slotPrint)
self.webview.page().setNetworkAccessManager(
lilydoc.network.accessmanager())
self.webview.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.webview.page().linkClicked.connect(self.openUrl)
self.webview.page().setForwardUnsupportedContent(True)
self.webview.page().unsupportedContent.connect(self.slotUnsupported)
self.webview.urlChanged.connect(self.slotUrlChanged)
self.webview.customContextMenuRequested.connect(
self.slotShowContextMenu)
tb.addAction(ac.help_back)
tb.addAction(ac.help_forward)
tb.addSeparator()
tb.addAction(ac.help_home)
tb.addAction(ac.help_print)
tb.addSeparator()
tb.addWidget(self.chooser)
tb.addWidget(self.search)
self.chooser.activated[int].connect(self.showHomePage)
self.search.textEdited.connect(self.slotSearchChanged)
self.search.returnPressed.connect(self.slotSearchReturnPressed)
dockwidget.mainwindow().iconSizeChanged.connect(
self.updateToolBarSettings)
dockwidget.mainwindow().toolButtonStyleChanged.connect(
self.updateToolBarSettings)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.loadDocumentation()
self.showInitialPage()
app.settingsChanged.connect(self.loadDocumentation)
app.translateUI(self)
def readSettings(self):
s = QSettings()
s.beginGroup("documentation")
ws = self.webview.page().settings()
family = s.value("fontfamily", self.font().family(), type(""))
size = s.value("fontsize", 16, int)
ws.setFontFamily(QWebSettings.StandardFont, family)
ws.setFontSize(QWebSettings.DefaultFontSize, size)
fixed = textformats.formatData('editor').font
ws.setFontFamily(QWebSettings.FixedFont, fixed.family())
ws.setFontSize(QWebSettings.DefaultFixedFontSize,
fixed.pointSizeF() * 96 / 72)
def keyPressEvent(self, ev):
if ev.text() == "/":
self.search.setFocus()
else:
super(Browser, self).keyPressEvent(ev)
def translateUI(self):
try:
self.search.setPlaceholderText(_("Search..."))
except AttributeError:
pass # not in Qt 4.6
def showInitialPage(self):
"""Shows the preferred start page.
If a local documentation instance already has a suitable version,
just loads it. Otherwise connects to the allLoaded signal, that is
emitted when all the documentation instances have loaded their version
information and then shows the start page (if another page wasn't yet
loaded).
"""
if self.webview.url().isEmpty():
docs = lilydoc.manager.docs()
version = lilypondinfo.preferred().version()
index = -1
if version:
for num, doc in enumerate(docs):
if doc.version() is not None and doc.version() >= version:
index = num # a suitable documentation is found
break
if index == -1:
# nothing found (or LilyPond version not available),
# wait for loading or show the most recent version
if not lilydoc.manager.loaded():
lilydoc.manager.allLoaded.connect(self.showInitialPage)
return
index = len(docs) - 1
self.chooser.setCurrentIndex(index)
self.showHomePage()
def loadDocumentation(self):
"""Puts the available documentation instances in the combobox."""
i = self.chooser.currentIndex()
self.chooser.clear()
for doc in lilydoc.manager.docs():
v = doc.versionString()
if doc.isLocal():
t = _("(local)")
else:
t = _("({hostname})").format(hostname=doc.url().host())
self.chooser.addItem("{0} {1}".format(v or _("<unknown>"), t))
self.chooser.setCurrentIndex(i)
if not lilydoc.manager.loaded():
lilydoc.manager.allLoaded.connect(self.loadDocumentation, -1)
return
def updateToolBarSettings(self):
mainwin = self.parentWidget().mainwindow()
self.toolbar.setIconSize(mainwin.iconSize())
self.toolbar.setToolButtonStyle(mainwin.toolButtonStyle())
def showManual(self):
"""Invoked when the user presses F1."""
self.slotHomeFrescobaldi() # TEMP
def slotUrlChanged(self):
ac = self.parentWidget().actionCollection
ac.help_back.setEnabled(self.webview.history().canGoBack())
ac.help_forward.setEnabled(self.webview.history().canGoForward())
def openUrl(self, url):
if url.path().endswith(('.ily', '.lyi', '.ly')):
self.sourceViewer().showReply(lilydoc.network.get(url))
else:
self.webview.load(url)
def slotUnsupported(self, reply):
helpers.openUrl(reply.url())
def slotSearchChanged(self):
text = self.search.text()
if not text.startswith(':'):
self.webview.page().findText(text,
QWebPage.FindWrapsAroundDocument)
def slotSearchReturnPressed(self):
text = self.search.text()
if not text.startswith(':'):
self.slotSearchChanged()
else:
pass # TODO: implement full doc search
def sourceViewer(self):
try:
return self._sourceviewer
except AttributeError:
from . import sourceviewer
self._sourceviewer = sourceviewer.SourceViewer(self)
return self._sourceviewer
def showHomePage(self):
"""Shows the homepage of the LilyPond documentation."""
i = self.chooser.currentIndex()
if i < 0:
i = 0
doc = lilydoc.manager.docs()[i]
url = doc.home()
if doc.isLocal():
path = url.toLocalFile()
langs = lilydoc.network.langs()
if langs:
for lang in langs:
if os.path.exists(path + '.' + lang + '.html'):
path += '.' + lang
break
url = QUrl.fromLocalFile(path + '.html')
self.webview.load(url)
def slotPrint(self):
printer = QPrinter()
dlg = QPrintDialog(printer, self)
dlg.setWindowTitle(app.caption(_("Print")))
if dlg.exec_():
self.webview.print_(printer)
def slotShowContextMenu(self, pos):
hit = self.webview.page().currentFrame().hitTestContent(pos)
menu = QMenu()
if hit.linkUrl().isValid():
a = self.webview.pageAction(QWebPage.CopyLinkToClipboard)
a.setIcon(icons.get("edit-copy"))
a.setText(_("Copy &Link"))
menu.addAction(a)
menu.addSeparator()
a = menu.addAction(icons.get("window-new"),
_("Open Link in &New Window"))
a.triggered.connect(
(lambda url: lambda: self.slotNewWindow(url))(hit.linkUrl()))
else:
if hit.isContentSelected():
a = self.webview.pageAction(QWebPage.Copy)
a.setIcon(icons.get("edit-copy"))
a.setText(_("&Copy"))
menu.addAction(a)
menu.addSeparator()
a = menu.addAction(icons.get("window-new"),
_("Open Document in &New Window"))
a.triggered.connect((lambda url: lambda: self.slotNewWindow(url))(
self.webview.url()))
if menu.actions():
menu.exec_(self.webview.mapToGlobal(pos))
def slotNewWindow(self, url):
helpers.openUrl(url)
class PDFWriter(QObject):
def _pass_json_value_getter(self):
val = json.dumps(self.bridge_value)
return QString(val)
def _pass_json_value_setter(self, value):
self.bridge_value = json.loads(unicode(value))
_pass_json_value = pyqtProperty(QString,
fget=_pass_json_value_getter,
fset=_pass_json_value_setter)
@pyqtSlot(result=unicode)
def title(self):
return self.doc_title
@pyqtSlot(result=unicode)
def author(self):
return self.doc_author
@pyqtSlot(result=unicode)
def section(self):
return self.current_section
def __init__(self, opts, log, cover_data=None, toc=None):
from calibre.gui2 import is_ok_to_use_qt
if not is_ok_to_use_qt():
raise Exception('Not OK to use Qt')
QObject.__init__(self)
self.logger = self.log = log
self.opts = opts
self.cover_data = cover_data
self.paged_js = None
self.toc = toc
self.loop = QEventLoop()
self.view = QWebView()
self.page = Page(opts, self.log)
self.view.setPage(self.page)
self.view.setRenderHints(QPainter.Antialiasing
| QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform)
self.view.loadFinished.connect(self.render_html,
type=Qt.QueuedConnection)
for x in (Qt.Horizontal, Qt.Vertical):
self.view.page().mainFrame().setScrollBarPolicy(
x, Qt.ScrollBarAlwaysOff)
self.report_progress = lambda x, y: x
self.current_section = ''
def dump(self, items, out_stream, pdf_metadata):
opts = self.opts
page_size = get_page_size(self.opts)
xdpi, ydpi = self.view.logicalDpiX(), self.view.logicalDpiY()
# We cannot set the side margins in the webview as there is no right
# margin for the last page (the margins are implemented with
# -webkit-column-gap)
ml, mr = opts.margin_left, opts.margin_right
self.doc = PdfDevice(out_stream,
page_size=page_size,
left_margin=ml,
top_margin=0,
right_margin=mr,
bottom_margin=0,
xdpi=xdpi,
ydpi=ydpi,
errors=self.log.error,
debug=self.log.debug,
compress=not opts.uncompressed_pdf,
mark_links=opts.pdf_mark_links)
self.footer = opts.pdf_footer_template
if self.footer:
self.footer = self.footer.strip()
if not self.footer and opts.pdf_page_numbers:
self.footer = '<p style="text-align:center; text-indent: 0">_PAGENUM_</p>'
self.header = opts.pdf_header_template
if self.header:
self.header = self.header.strip()
min_margin = 36
if self.footer and opts.margin_bottom < min_margin:
self.log.warn(
'Bottom margin is too small for footer, increasing it.')
opts.margin_bottom = min_margin
if self.header and opts.margin_top < min_margin:
self.log.warn('Top margin is too small for header, increasing it.')
opts.margin_top = min_margin
self.page.setViewportSize(QSize(self.doc.width(), self.doc.height()))
self.render_queue = items
self.total_items = len(items)
mt, mb = map(self.doc.to_px, (opts.margin_top, opts.margin_bottom))
self.margin_top, self.margin_bottom = map(lambda x: int(floor(x)),
(mt, mb))
self.painter = QPainter(self.doc)
self.doc.set_metadata(title=pdf_metadata.title,
author=pdf_metadata.author,
tags=pdf_metadata.tags)
self.doc_title = pdf_metadata.title
self.doc_author = pdf_metadata.author
self.painter.save()
try:
if self.cover_data is not None:
p = QPixmap()
p.loadFromData(self.cover_data)
if not p.isNull():
self.doc.init_page()
draw_image_page(QRect(*self.doc.full_page_rect),
self.painter,
p,
preserve_aspect_ratio=self.opts.
preserve_cover_aspect_ratio)
self.doc.end_page()
finally:
self.painter.restore()
QTimer.singleShot(0, self.render_book)
if self.loop.exec_() == 1:
raise Exception('PDF Output failed, see log for details')
if self.toc is not None and len(self.toc) > 0:
self.doc.add_outline(self.toc)
self.painter.end()
if self.doc.errors_occurred:
raise Exception('PDF Output failed, see log for details')
def render_book(self):
if self.doc.errors_occurred:
return self.loop.exit(1)
try:
if not self.render_queue:
self.loop.exit()
else:
self.render_next()
except:
self.logger.exception('Rendering failed')
self.loop.exit(1)
def render_next(self):
item = unicode(self.render_queue.pop(0))
self.logger.debug('Processing %s...' % item)
self.current_item = item
load_html(item, self.view)
def render_html(self, ok):
if ok:
try:
self.do_paged_render()
except:
self.log.exception('Rendering failed')
self.loop.exit(1)
return
else:
# The document is so corrupt that we can't render the page.
self.logger.error('Document cannot be rendered.')
self.loop.exit(1)
return
done = self.total_items - len(self.render_queue)
self.report_progress(
done / self.total_items,
_('Rendered %s' % os.path.basename(self.current_item)))
self.render_book()
@property
def current_page_num(self):
return self.doc.current_page_num
def load_mathjax(self):
evaljs = self.view.page().mainFrame().evaluateJavaScript
mjpath = P(u'viewer/mathjax').replace(os.sep, '/')
if iswindows:
mjpath = u'/' + mjpath
if evaljs('''
window.mathjax.base = %s;
mathjax.check_for_math(); mathjax.math_present
''' % (json.dumps(mjpath, ensure_ascii=False))).toBool():
self.log.debug('Math present, loading MathJax')
while not evaljs('mathjax.math_loaded').toBool():
self.loop.processEvents(self.loop.ExcludeUserInputEvents)
evaljs(
'document.getElementById("MathJax_Message").style.display="none";'
)
def get_sections(self, anchor_map):
sections = {}
ci = os.path.abspath(os.path.normcase(self.current_item))
if self.toc is not None:
for toc in self.toc.flat():
path = toc.abspath or None
frag = toc.fragment or None
if path is None:
continue
path = os.path.abspath(os.path.normcase(path))
if path == ci:
col = 0
if frag and frag in anchor_map:
col = anchor_map[frag]['column']
if col not in sections:
sections[col] = toc.text or _('Untitled')
return sections
def do_paged_render(self):
if self.paged_js is None:
import uuid
from calibre.utils.resources import compiled_coffeescript as cc
self.paged_js = cc('ebooks.oeb.display.utils')
self.paged_js += cc('ebooks.oeb.display.indexing')
self.paged_js += cc('ebooks.oeb.display.paged')
self.paged_js += cc('ebooks.oeb.display.mathjax')
self.hf_uuid = str(uuid.uuid4()).replace('-', '')
self.view.page().mainFrame().addToJavaScriptWindowObject(
"py_bridge", self)
self.view.page().longjs_counter = 0
evaljs = self.view.page().mainFrame().evaluateJavaScript
evaljs(self.paged_js)
self.load_mathjax()
evaljs('''
py_bridge.__defineGetter__('value', function() {
return JSON.parse(this._pass_json_value);
});
py_bridge.__defineSetter__('value', function(val) {
this._pass_json_value = JSON.stringify(val);
});
document.body.style.backgroundColor = "white";
paged_display.set_geometry(1, %d, %d, %d);
paged_display.layout();
paged_display.fit_images();
py_bridge.value = book_indexing.all_links_and_anchors();
''' % (self.margin_top, 0, self.margin_bottom))
amap = self.bridge_value
if not isinstance(amap, dict):
amap = {
'links': [],
'anchors': {}
} # Some javascript error occurred
sections = self.get_sections(amap['anchors'])
col = 0
if self.header:
self.bridge_value = self.header
evaljs('paged_display.header_template = py_bridge.value')
if self.footer:
self.bridge_value = self.footer
evaljs('paged_display.footer_template = py_bridge.value')
if self.header or self.footer:
evaljs('paged_display.create_header_footer("%s");' % self.hf_uuid)
start_page = self.current_page_num
mf = self.view.page().mainFrame()
while True:
if col in sections:
self.current_section = sections[col]
self.doc.init_page()
if self.header or self.footer:
evaljs('paged_display.update_header_footer(%d)' %
self.current_page_num)
self.painter.save()
mf.render(self.painter)
self.painter.restore()
nsl = evaljs('paged_display.next_screen_location()').toInt()
self.doc.end_page()
if not nsl[1] or nsl[0] <= 0:
break
evaljs(
'window.scrollTo(%d, 0); paged_display.position_header_footer();'
% nsl[0])
if self.doc.errors_occurred:
break
col += 1
if not self.doc.errors_occurred:
self.doc.add_links(self.current_item, start_page, amap['links'],
amap['anchors'])
class BookInfo(QDialog):
closed = pyqtSignal(object)
def __init__(self, parent, view, row, link_delegate):
QDialog.__init__(self, parent)
self.normal_brush = QBrush(Qt.white)
self.marked_brush = QBrush(Qt.lightGray)
self.marked = None
self.gui = parent
self.splitter = QSplitter(self)
self._l = l = QVBoxLayout(self)
self.setLayout(l)
l.addWidget(self.splitter)
self.cover = CoverView(self)
self.cover.resizeEvent = self.cover_view_resized
self.cover.cover_changed.connect(self.cover_changed)
self.cover_pixmap = None
self.cover.sizeHint = self.details_size_hint
self.splitter.addWidget(self.cover)
self.details = QWebView(self)
self.details.sizeHint = self.details_size_hint
self.details.page().setLinkDelegationPolicy(
self.details.page().DelegateAllLinks)
self.details.linkClicked.connect(self.link_clicked)
self.css = css()
self.link_delegate = link_delegate
self.details.setAttribute(Qt.WA_OpaquePaintEvent, False)
palette = self.details.palette()
self.details.setAcceptDrops(False)
palette.setBrush(QPalette.Base, Qt.transparent)
self.details.page().setPalette(palette)
self.c = QWidget(self)
self.c.l = l2 = QGridLayout(self.c)
self.c.setLayout(l2)
l2.addWidget(self.details, 0, 0, 1, -1)
self.splitter.addWidget(self.c)
self.fit_cover = QCheckBox(_('Fit &cover within view'), self)
self.fit_cover.setChecked(
gprefs.get('book_info_dialog_fit_cover', True))
l2.addWidget(self.fit_cover, l2.rowCount(), 0, 1, -1)
self.previous_button = QPushButton(QIcon(I('previous.png')),
_('&Previous'), self)
self.previous_button.clicked.connect(self.previous)
l2.addWidget(self.previous_button, l2.rowCount(), 0)
self.next_button = QPushButton(QIcon(I('next.png')), _('&Next'), self)
self.next_button.clicked.connect(self.next)
l2.addWidget(self.next_button, l2.rowCount() - 1, 1)
self.view = view
self.current_row = None
self.refresh(row)
self.view.selectionModel().currentChanged.connect(self.slave)
self.fit_cover.stateChanged.connect(self.toggle_cover_fit)
self.ns = QShortcut(QKeySequence('Alt+Right'), self)
self.ns.activated.connect(self.next)
self.ps = QShortcut(QKeySequence('Alt+Left'), self)
self.ps.activated.connect(self.previous)
self.next_button.setToolTip(
_('Next [%s]') %
unicode(self.ns.key().toString(QKeySequence.NativeText)))
self.previous_button.setToolTip(
_('Previous [%s]') %
unicode(self.ps.key().toString(QKeySequence.NativeText)))
geom = QCoreApplication.instance().desktop().availableGeometry(self)
screen_height = geom.height() - 100
screen_width = geom.width() - 100
self.resize(max(int(screen_width / 2), 700), screen_height)
saved_layout = gprefs.get('book_info_dialog_layout', None)
if saved_layout is not None:
try:
self.restoreGeometry(saved_layout[0])
self.splitter.restoreState(saved_layout[1])
except Exception:
pass
def link_clicked(self, qurl):
link = unicode(qurl.toString())
self.link_delegate(link)
def done(self, r):
saved_layout = (bytearray(self.saveGeometry()),
bytearray(self.splitter.saveState()))
gprefs.set('book_info_dialog_layout', saved_layout)
ret = QDialog.done(self, r)
self.view.selectionModel().currentChanged.disconnect(self.slave)
self.view = self.link_delegate = self.gui = None
self.closed.emit(self)
return ret
def cover_changed(self, data):
if self.current_row is not None:
id_ = self.view.model().id(self.current_row)
self.view.model().db.set_cover(id_, data)
if self.gui.cover_flow:
self.gui.cover_flow.dataChanged()
ci = self.view.currentIndex()
if ci.isValid():
self.view.model().current_changed(ci, ci)
self.cover_pixmap = QPixmap()
self.cover_pixmap.loadFromData(data)
if self.fit_cover.isChecked():
self.resize_cover()
def details_size_hint(self):
return QSize(350, 550)
def toggle_cover_fit(self, state):
gprefs.set('book_info_dialog_fit_cover', self.fit_cover.isChecked())
self.resize_cover()
def cover_view_resized(self, event):
QTimer.singleShot(1, self.resize_cover)
def slave(self, current, previous):
if current.row() != previous.row():
row = current.row()
self.refresh(row)
def move(self, delta=1):
self.view.selectionModel().currentChanged.disconnect(self.slave)
try:
idx = self.view.currentIndex()
if idx.isValid():
m = self.view.model()
ni = m.index(idx.row() + delta, idx.column())
if ni.isValid():
self.view.setCurrentIndex(ni)
self.refresh(ni.row())
if self.view.isVisible():
self.view.scrollTo(ni)
finally:
self.view.selectionModel().currentChanged.connect(self.slave)
def next(self):
self.move()
def previous(self):
self.move(-1)
def resize_cover(self):
if self.cover_pixmap is None:
return
pixmap = self.cover_pixmap
if self.fit_cover.isChecked():
scaled, new_width, new_height = fit_image(
pixmap.width(), pixmap.height(),
self.cover.size().width() - 10,
self.cover.size().height() - 10)
if scaled:
pixmap = pixmap.scaled(new_width, new_height,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.cover.set_pixmap(pixmap)
self.update_cover_tooltip()
def update_cover_tooltip(self):
tt = ''
if self.marked:
tt = _('This book is marked') if self.marked in {
True, 'true'
} else _('This book is marked as: %s') % self.marked
tt += '\n\n'
if self.cover_pixmap is not None:
sz = self.cover_pixmap.size()
tt += _('Cover size: %(width)d x %(height)d') % dict(
width=sz.width(), height=sz.height())
self.cover.setToolTip(tt)
def refresh(self, row):
if isinstance(row, QModelIndex):
row = row.row()
if row == self.current_row:
return
mi = self.view.model().get_book_display_info(row)
if mi is None:
# Indicates books was deleted from library, or row numbers have
# changed
return
self.previous_button.setEnabled(False if row == 0 else True)
self.next_button.setEnabled(False if row ==
self.view.model().rowCount(QModelIndex()) -
1 else True)
self.current_row = row
self.setWindowTitle(mi.title)
self.cover_pixmap = QPixmap.fromImage(mi.cover_data[1])
self.resize_cover()
html = render_html(mi, self.css, True, self, all_fields=True)
self.details.setHtml(html)
self.marked = mi.marked
self.cover.setBackgroundBrush(
self.marked_brush if mi.marked else self.normal_brush)
self.update_cover_tooltip()
class Morris:
def __init__(self, widget, chart='Line', data=[], xkey='',
ykeys=[], labels=[], raw='', **attrs):
'''
@param {QWidget} widget = instance of QWidget
@param {string} name = namefile chart
@param {string} chart = morris type chart: Line, Bar, Donnut
@param {list} data = list of data to show
@param {string} xkey = a string containing the name of the attribute that contains X labels
@param {string} ykeys = a list of strings containing names of attributes that contain Y values
@param {list} labels = a list of strings containing labels for the data series to be plotted
@param {string} raw = string params to append in morris options
'''
self.widget = widget
self.name = 'chart.html' # chart name file
self.chart = chart.capitalize() # Line | Bar | Donut
self.data = data # []
self.xkey = xkey
self.ykeys = ykeys # ['a', 'b']
self.labels = labels # ['label a', 'label b']
self.attrs = attrs
self.raw = raw
self.program_folder = getProgramFolderPath()
self.tmpl = convertPath(self.program_folder + 'morris/template.html')
self.path_file = convertPath(self.program_folder + self.name)
self.webview = QWebView()
self.webview.setPage(WebPage())
self.webview.page().settings().setAttribute( QWebSettings.JavascriptEnabled, True)
self.widget.setLayout(QtGui.QVBoxLayout())
self.widget.layout().setContentsMargins(0, 0, 0, 0)
self.widget.layout().addWidget(self.webview)
def __getAttrs(self):
attrs = {}
attrs['data'] = self.data
if self.chart in ['Line', 'Bar', 'Area']:
attrs['xkey'] = self.xkey
attrs['ykeys'] = self.ykeys
attrs['labels'] = self.labels
stattrs = unicode(attrs)[:-1]
if len(self.attrs.keys()) > 0:
attrs = unicode(self.attrs)
stattrs += ', ' + attrs[1:-1]
if self.chart == 'Donut':
stattrs += ', formatter: function (x) { return x + "%"}'
if self.raw:
stattrs += ', ' + self.raw
return stattrs[1:]
def __render(self):
html = open(self.tmpl).read()
html = html.replace('{chart}', self.chart)
html = html.replace('{attrs}', self.__getAttrs())
html = html.replace('{path}', self.program_folder.replace('\\', '//'))
f = open(self.path_file, 'w')
f.write(html)
f.close()
def show(self):
keys = ['widget']
if self.chart in ['Line', 'Bar', 'Area']:
keys += ['xkey', 'ykeys', 'labels']
for k in keys:
if not self.__dict__[k]:
raise ValueError("'%s' key has not seted" % k)
self.__render()
self.webview.load(QtCore.QUrl("file:///" + convertPath(self.path_file)))
self.webview.show()
try:
# remove the html generated file
os.remove(convertPath(self.path_file))
except Exception, e:
pass
def progress_loop(self):
"""prepare, copy and config the system in the core install process."""
syslog.syslog('progress_loop()')
self.current_page = None
slideshow_dir = '/usr/share/ubiquity-slideshow'
slideshow_locale = self.slideshow_get_available_locale(slideshow_dir, self.locale)
slideshow_main = slideshow_dir + '/slides/index.html'
s = self.app.desktop().availableGeometry()
fail = None
if os.path.exists(slideshow_main):
if s.height >= 600 and s.width >= 800:
slides = 'file://' + slideshow_main
if slideshow_locale != 'c': #slideshow will use default automatically
slides += '#?locale=' + slideshow_locale
ltr = i18n.get_string('default-ltr', slideshow_locale, 'ubiquity/imported')
if ltr == 'default:RTL':
slides += '?rtl'
try:
from PyQt4.QtWebKit import QWebView
from PyQt4.QtWebKit import QWebPage
def openLink(qUrl):
QDesktopServices.openUrl(qUrl)
webView = QWebView()
webView.linkClicked.connect(openLink)
webView.setContextMenuPolicy(Qt.NoContextMenu)
webView.page().setLinkDelegationPolicy(QWebPage.DelegateExternalLinks)
webView.page().mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
webView.page().mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
webView.setFixedSize(700,420)
webView.load(QUrl(slides))
#add the webview to the extra frame of the progress dialog
self.progressDialog.extraFrame.layout().addWidget(webView)
self.progressDialog.extraFrame.setVisible(True)
except ImportError:
fail = 'Webkit not present.'
else:
fail = 'Display < 800x600 (%sx%s).' % (s.width, s.height)
else:
fail = 'No slides present for %s.' % slideshow_dir
if fail:
syslog.syslog('Not displaying the slideshow: %s' % fail)
self.progressDialog.show()
self.debconf_progress_start(
0, 100, self.get_string('ubiquity/install/title'))
self.debconf_progress_region(0, 15)
if not self.oem_user_config:
self.start_debconf()
dbfilter = partman_commit.PartmanCommit(self)
if dbfilter.run_command(auto_process=True) != 0:
while self.progress_position.depth() != 0:
self.debconf_progress_stop()
self.progressDialog.hide()
self.return_to_partitioning()
return
# No return to partitioning from now on
self.installing_no_return = True
self.debconf_progress_region(15, 100)
self.start_debconf()
dbfilter = install.Install(self)
ret = dbfilter.run_command(auto_process=True)
if ret != 0:
self.installing = False
if ret == 3:
# error already handled by Install
sys.exit(ret)
elif (os.WIFSIGNALED(ret) and
os.WTERMSIG(ret) in (signal.SIGINT, signal.SIGKILL,
signal.SIGTERM)):
sys.exit(ret)
elif os.path.exists('/var/lib/ubiquity/install.trace'):
tbfile = open('/var/lib/ubiquity/install.trace')
realtb = tbfile.read()
tbfile.close()
raise RuntimeError, ("Install failed with exit code %s\n%s" %
(ret, realtb))
else:
raise RuntimeError, ("Install failed with exit code %s; see "
"/var/log/syslog" % ret)
while self.progress_position.depth() != 0:
self.debconf_progress_stop()
# just to make sure
self.progressDialog.hide()
self.installing = False
quitText = '<qt>%s</qt>' % self.get_string("finished_label")
rebootButtonText = self.get_string("reboot_button")
quitButtonText = self.get_string("quit_button")
titleText = self.get_string("finished_dialog")
##FIXME use non-stock messagebox to customise button text
#quitAnswer = QMessageBox.question(self.ui, titleText, quitText, rebootButtonText, quitButtonText)
self.run_success_cmd()
if self.oem_user_config:
self.quit()
elif not self.get_reboot_seen():
if ('UBIQUITY_ONLY' in os.environ or
'UBIQUITY_GREETER' in os.environ):
quitText = self.get_string('ubiquity/finished_restart_only')
messageBox = QMessageBox(QMessageBox.Question, titleText, quitText, QMessageBox.NoButton, self.ui)
messageBox.addButton(rebootButtonText, QMessageBox.AcceptRole)
if ('UBIQUITY_ONLY' not in os.environ and
'UBIQUITY_GREETER' not in os.environ):
messageBox.addButton(quitButtonText, QMessageBox.RejectRole)
messageBox.setWindowFlags(messageBox.windowFlags() | Qt.WindowStaysOnTopHint)
quitAnswer = messageBox.exec_()
if quitAnswer == 0:
self.reboot()
elif self.get_reboot():
self.reboot()
class AwBrowser(QDialog):
"""
Customization and configuration of a web browser to run within Anki
"""
_parent = None
_fields = []
_selectedListener = None
_web = None
_urlInfo = None
def __init__(self, myParent):
QDialog.__init__(self, myParent)
self._parent = myParent
self.setupUI()
def setupUI(self):
self.setWindowTitle('Anki :: Web Browser Addon')
self.setGeometry(450, 200, 800, 450)
self.setMinimumWidth (640)
self.setMinimumHeight(450)
mainLayout = QVBoxLayout()
mainLayout.setContentsMargins(0,0,0,0)
mainLayout.setSpacing(0)
self.setLayout(mainLayout)
topWidget = QtWidgets.QWidget(self)
topWidget.setFixedHeight(50)
topLayout = QtWidgets.QHBoxLayout(topWidget)
topLayout.setObjectName("topLayout")
lbSite = QtWidgets.QLabel(topWidget)
lbSite.setObjectName("label")
lbSite.setText("Website: ")
topLayout.addWidget(lbSite)
self._itAddress = QtWidgets.QLineEdit(topWidget)
self._itAddress.setObjectName("itSite")
topLayout.addWidget(self._itAddress)
cbGo = QtWidgets.QCommandLinkButton(topWidget)
cbGo.setObjectName("cbGo")
cbGo.setFixedSize(30, 30)
topLayout.addWidget(cbGo)
# cbImport = QtWidgets.QCommandLinkButton(topWidget)
# cbImport.setObjectName("cbImport")
# cbImport.setFixedSize(30, 30)
# topLayout.addWidget(cbImport)
self._loadingBar = QtWidgets.QProgressBar(topWidget)
self._loadingBar.setFixedWidth(100)
self._loadingBar.setProperty("value", 100)
self._loadingBar.setObjectName("loadingBar")
topLayout.addWidget(self._loadingBar)
mainLayout.addWidget(topWidget)
self._web = QWebView(self)
self._web.contextMenuEvent = self.contextMenuEvent
self._web.page().loadStarted.connect(self.onStartLoading)
self._web.page().loadFinished.connect(self.onLoadFinish)
self._web.page().loadProgress.connect(self.onProgress)
self._web.urlChanged.connect(self.onPageChange)
cbGo.clicked.connect(self._goToAddress)
mainLayout.addWidget(self._web)
if cfg.getConfig().browserAlwaysOnTop:
self.setWindowFlags(Qt.WindowStaysOnTopHint)
def formatTargetURL(self, website: str, query: str = ''):
return website.format(urllib.parse.quote(query, encoding='utf8')) #encode('utf8', 'ignore')
def open(self, website, query: str):
"""
Loads a given page with its replacing part with its query, and shows itself
"""
target = self.formatTargetURL(website, query)
self._web.load(QUrl( target ))
self._itAddress.setText(target)
self.show()
return self._web
def unload(self):
try:
self._web.setHtml(BLANK_PAGE)
except Exception:
pass
def onClose(self):
self._parent = None
self._web.close()
self.close()
def onStartLoading(self):
self._loadingBar.setProperty("value", 1)
def onProgress(self, prog):
self._loadingBar.setProperty("value", prog)
def onLoadFinish(self, result):
self._loadingBar.setProperty("value", 100)
if not result:
Feedback.showInfo('Error loading page')
Feedback.log('Error on loading page! ', result)
def _goToAddress(self):
self._web.load(QUrl( self._itAddress.text() ))
self._web.show()
def onPageChange(self, url):
self._itAddress.setText(url.toString())
def welcome(self):
self._web.setHtml(WELCOME_PAGE)
self.show()
# ------------------------------------ Menu ---------------------------------------
def _makeMenuAction(self, field, value, isLink):
"""
Creates correct operations for the context menu selection.
Only with lambda, it would repeat only the last element
"""
return lambda: self._selectedListener.handleSelection(field, value, isLink)
def contextMenuEvent(self, evt):
"""
Handles the context menu in the web view.
Shows and handle options (from field list), only if in edit mode.
"""
if not (self._fields and self._selectedListener):
return
isLink = False
value = None
if self._web.selectedText():
isLink = False
value = self._web.selectedText()
else:
if (self._web.page().contextMenuData().mediaType() == QWebHitTestResult.MediaTypeImage
and self._web.page().contextMenuData().mediaUrl()):
isLink = True
value = self._web.page().contextMenuData().mediaUrl()
if not value:
return
self.createCtxMenu(value, isLink, evt)
def createCtxMenu(self, value, isLink, evt):
'Creates and configures the menu itself'
m = QMenu(self)
sub = QMenu(Label.BROWSER_ASSIGN_TO, m)
m.setTitle(Label.BROWSER_ASSIGN_TO)
for index, label in self._fields.items():
act = QAction(label, m,
triggered=self._makeMenuAction(index, value, isLink))
sub.addAction(act)
m.addMenu(sub)
action = m.exec_(self.mapToGlobal(evt.pos()))
def load(self, qUrl):
self._web.load(qUrl)
# ----------------- getter / setter -------------------
def setFields(self, fList):
self._fields = fList
def setSelectionListener(self, value):
self._selectedListener = value
class PreviewTooltip(QWidget):
def __init__(self, url):
QWidget.__init__(self, None, Qt.ToolTip)
self.url = url
self.font = QFont(QApplication.font(self))
self.font.setPointSize(8)
desktop = QApplication.desktop().availableGeometry(self)
cursor = QCursor.pos()
rect = QRect(cursor + QPoint(-10, 10), QSize(240,180 + QFontMetrics(self.font).height()))
if rect.left() < desktop.left():
rect.moveLeft(desktop.left())
if rect.right() > desktop.right():
rect.moveRight(cursor.x() - 10)
if rect.bottom() > desktop.bottom():
rect.moveBottom(cursor.y() - 10)
self.setGeometry(rect)
self.pixmap = None
self.progress = 0
self.title = unicode(self.url)
self.webView = QWebView()
self.webView.page().mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.webView.page().mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.webView.resize(1024,768)
self.webView.load(QUrl(url))
self.timer = QTimer(self)
self.connect(self.timer, SIGNAL("timeout()"), self.refresh)
self.timer.start(3000)
self.connect(self.webView, SIGNAL("loadFinished(bool)"), self.refresh)
self.connect(self.webView, SIGNAL("loadProgress(int)"), self.updateProgress)
self.connect(self.webView, SIGNAL("urlChanged(const QUrl&)"), self.newUrl)
self.connect(self.webView, SIGNAL("titleChanged(const QString&)"), self.newTitle)
def updateProgress(self, progress):
self.progress = progress
self.update()
def newUrl(self, url):
self.title = unicode(url.toString())
self.update()
def newTitle(self, title):
self.title = unicode(title)
self.update()
def refresh(self):
view = QPixmap(self.webView.size())
self.webView.render(view)
self.pixmap = view.scaled(QSize(240,180), Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
self.update()
def paintEvent(self, event):
QWidget.paintEvent(self, event)
p = QPainter(self)
p.setFont(self.font)
if self.pixmap:
p.drawPixmap(QPoint(0,0), self.pixmap)
r = QRect(self.rect().topLeft() + QPoint(0, 180), QSize(self.rect().size().width(), p.fontMetrics().height()))
p.fillRect(r, self.palette().midlight())
if self.progress:
pr = QRect(r)
pr.setWidth( (r.width() * self.progress) / 100 )
p.fillRect(pr, self.palette().dark())
p.setBrush(Qt.NoBrush)
p.setPen(QPen(self.palette().text(), 1))
p.drawText(QRectF(r), self.title, QTextOption(Qt.AlignHCenter))
p.setPen(QPen(self.palette().shadow(), 1))
p.drawRect(self.rect().adjusted(0,0,-1,-1))
class BrowserWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
vlayout = QVBoxLayout()
vlayout.addLayout(self.get_url_bar())
javascript_bar = self.get_javascript_bar()
vlayout.addLayout(javascript_bar)
self.browser = QWebView(self)
self.browser_frame = self.browser.page().currentFrame()
self.connect(self.browser_frame, SIGNAL('javaScriptWindowObjectCleared()'),
self.add_javascript_bridge);
vlayout.addWidget(self.browser)
vlayout.addWidget(QuitButton())
self.setLayout(vlayout)
def get_url_bar(self):
url_bar = QHBoxLayout()
self.url_box = QLineEdit()
self.connect(self.url_box, SIGNAL('returnPressed()'), self.show_browser)
go = QPushButton(self)
go.setText("Go")
self.connect(go, SIGNAL('clicked()'), self.show_browser)
url_bar.addWidget(self.url_box)
url_bar.addWidget(go)
return url_bar
def get_javascript_bar(self):
javascript_bar = QHBoxLayout()
self.javascript_box = QLineEdit()
self.connect(self.javascript_box, SIGNAL('returnPressed()'), self.send_javascript)
ex = QPushButton(self)
ex.setText("Execute on page")
self.connect(ex, SIGNAL('clicked()'), self.send_javascript)
javascript_bar.addWidget(self.javascript_box)
javascript_bar.addWidget(ex)
return javascript_bar
def add_javascript_bridge(self):
self.browser_frame.addToJavaScriptWindowObject("webkitBridge", WebkitBridge())
def send_javascript(self):
self.browser.page().currentFrame().evaluateJavaScript(self.javascript_box.text())
def show_browser(self):
url = QUrl(self.url_box.text())
self.browser.load(url)
