class WebView(QtGui.QMdiSubWindow):
closed = QtCore.Signal(object)
def __init__(self, title, work_path, request_handler, message_handler,
*args, **kwargs):
# Window Setup
super().__init__(*args, **kwargs)
self.setObjectName("freecad.extman.webview")
self.setWindowTitle(title)
self.setAttribute(Qt.WA_DeleteOnClose, True)
# Scheme setup (extman://)
self.handler = SchemeHandler(self, request_handler)
# WebView setup
self.webView = QWebEngineView(self)
self.webView.setContextMenuPolicy(Qt.NoContextMenu)
self.setWidget(self.webView)
# Page setup
self.webView.setPage(Page(self.webView))
# Profile setup
profile = self.webView.page().profile()
profile.setPersistentStoragePath(str(Path(work_path, 'web_data')))
profile.setCachePath(str(Path(work_path, 'web_cache')))
handler = profile.urlSchemeHandler(EXTMAN_URL_SCHEME)
if handler is not None:
profile.removeUrlSchemeHandler(handler)
profile.installUrlSchemeHandler(EXTMAN_URL_SCHEME, self.handler)
# Setting setup
settings = self.webView.settings()
settings.setAttribute(QWebEngineSettings.AutoLoadIconsForPage, True)
settings.setAttribute(QWebEngineSettings.LocalContentCanAccessFileUrls,
True)
settings.setAttribute(
QWebEngineSettings.LocalContentCanAccessRemoteUrls, True)
# Page settings
page = self.webView.page().settings()
page.setAttribute(QWebEngineSettings.LocalContentCanAccessFileUrls,
True)
page.setAttribute(QWebEngineSettings.LocalContentCanAccessRemoteUrls,
True)
page.setAttribute(QWebEngineSettings.LocalStorageEnabled, True)
# WebChannel Setup
self.messageBus = MessageBus(message_handler, self.webView)
self.channel = QtWebChannel.QWebChannel(self.webView)
self.channel.registerObject('ExtManMessageBus', self.messageBus)
self.webView.page().setWebChannel(self.channel)
def closeEvent(self, event):
self.closed.emit(event)
event.accept()
def load(self, url):
self.webView.load(url)
class FormWidget(QWidget):
def __init__(self, parent):
super(FormWidget, self).__init__(parent)
self.__controls()
self.__layout()
def __controls(self):
path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"test2.html")
print(path)
#html = open('test2.html', 'r').read()
self.browser = QWebEngineView()
self.browser.setPage(WebPage(self.browser))
#self.browser.load(QUrl.fromLocalFile(path))
self.browser.load(QUrl("http://localhost:5000"))
#//self.browser.setHtml(")
#self.browser.loadFinished.connect(self.onLoadFinished)
"""
def onLoadFinished(self, ok):
pass
#if ok:
# #self.browser.page().runJavaScript("helloWorld(1, \"2\")", self.ready)
"""
def __layout(self):
self.vbox = QVBoxLayout()
self.hBox = QVBoxLayout()
self.hBox.addWidget(self.browser)
self.vbox.addLayout(self.hBox)
self.setLayout(self.vbox)
def ready(self, returnValue):
print(returnValue)
class HelpWindow(QMainWindow):
def __init__(self, parent=None):
super(HelpWindow, self).__init__(parent)
self.setWindowTitle("Facepager 4.0 - Help")
self.setMinimumWidth(600)
self.setMinimumHeight(600)
central = QWidget()
self.setCentralWidget(central)
vLayout = QVBoxLayout(central)
self.page = MyQWebEnginePage()
self.browser = QWebEngineView(central)
self.browser.setPage(self.page)
vLayout.addWidget(self.browser)
hLayout = QHBoxLayout()
vLayout.addLayout(hLayout)
hLayout.addStretch(5)
dismiss = QPushButton(central)
dismiss.setText("Close")
dismiss.clicked.connect(self.hide)
hLayout.addWidget(dismiss)
#browser.setBackgroundRole(QPalette.Window)
def show(self):
super(HelpWindow, self).show()
self.loadPage()
def loadPage(self):
self.browser.load(QUrl("http://strohne.github.io/Facepager/"))
class HelpWindow(QMainWindow):
def __init__(self, parent=None):
super(HelpWindow,self).__init__(parent)
self.setWindowTitle("Facepager 3.0 - Help")
self.setMinimumWidth(600);
self.setMinimumHeight(600);
central = QWidget()
self.setCentralWidget(central)
vLayout = QVBoxLayout(central)
self.page = MyQWebEnginePage()
self.browser = QWebEngineView(central)
self.browser.setPage(self.page)
vLayout.addWidget(self.browser)
hLayout = QHBoxLayout()
vLayout.addLayout(hLayout)
hLayout.addStretch(5)
dismiss = QPushButton(central)
dismiss.setText("Close")
dismiss.clicked.connect(self.hide)
hLayout.addWidget(dismiss)
#browser.setBackgroundRole(QPalette.Window)
def show(self):
super(HelpWindow,self).show()
self.loadPage()
def loadPage(self):
self.browser.load(QUrl("http://strohne.github.io/Facepager/"))
def _create_view(
self,
) -> QWebEngineView:
page = QWebEnginePage(self)
page.setHtml(
markdown.markdown(
root_configuration_as_markdown(),
),
)
view = QWebEngineView(self)
view.setPage(page)
return view
def CheckWebGL():
script = QWebEngineScript()
script.setInjectionPoint(QWebEngineScript.DocumentCreation)
script.setSourceCode(jsstr)
script.setInjectionPoint(QWebEngineScript.Deferred)
browser = QWebEngineView()
webpage = MyQWebEnginePage()
webpage.setHtml(htmlstr)
browser.setPage(webpage)
#browser.show()
browser.page().scripts().insert(script)
print('WebGL=' + str(webglsupport), )
# avoid "Release of profile requested but WebEnginePage still not deleted. Expect troubles !"
webpage.deleteLater()
class PreLoginWebDialog(QDialog):
def __init__(self, parent=None, caption="", url=""):
super(PreLoginWebDialog, self).__init__(parent)
self.url = url
self.setWindowTitle(caption)
self.setMinimumWidth(600)
self.setMinimumHeight(500)
vLayout = QVBoxLayout()
self.setLayout(vLayout)
self.browser = QWebEngineView(self)
self.page = WebPageCustom(self.browser)
self.page.allowLinks = False
self.browser.setPage(self.page)
vLayout.addWidget(self.browser)
# Buttons
hLayout = QHBoxLayout()
vLayout.addLayout(hLayout)
hLayout.addStretch(5)
buttonDismiss = QPushButton(self)
buttonDismiss.setText("Cancel")
buttonDismiss.clicked.connect(self.reject)
hLayout.addWidget(buttonDismiss)
buttonProceed = QPushButton(self)
buttonProceed.setText("Proceed")
buttonProceed.setDefault(True)
buttonProceed.clicked.connect(self.accept)
hLayout.addWidget(buttonProceed)
self.loadPage()
#browser.setBackgroundRole(QPalette.Window)
def loadPage(self):
self.browser.load(QUrl(self.url))
def show(self):
#super(WebDialog, self).show()
return self.exec_()
class MyWidget(QWidget):
def __init__(self, parent=None):
super(MyWidget, self).__init__()
self.parent = parent
self.initUI()
def initUI(self):
mainLayout = QVBoxLayout()
self.setLayout(mainLayout)
self.webview = QWebEngineView()
self.webpage = QWebEnginePage()
self.webview.setPage(self.webpage)
url = QUrl.fromLocalFile(
resource_filename("yaogua", "html_resource/zhou_yi_yao_gua.html"))
self.webview.load(url)
mainLayout.addWidget(self.webview)
class WebEngineScreenshot(QApplication):
def __init__(self, url, width, height, *args, **kwargs):
self.display = Xvfb(int(width * 1.2), int(height * 1.2))
self.display.start()
super().__init__(*args, **kwargs)
self.engine = QWebEngineView()
size = QSize(width, height)
self.engine.setFixedSize(size)
self.engine.setPage(QWebEnginePage())
settings = self.engine.page().settings()
settings.setAttribute(QWebEngineSettings.ShowScrollBars, False)
settings.setAttribute(QWebEngineSettings.JavascriptCanOpenWindows,
False)
settings.setAttribute(QWebEngineSettings.LocalStorageEnabled, False)
settings.setAttribute(QWebEngineSettings.HyperlinkAuditingEnabled,
False)
settings.setAttribute(QWebEngineSettings.PluginsEnabled, False)
settings.setAttribute(QWebEngineSettings.FullScreenSupportEnabled,
False)
settings.setAttribute(QWebEngineSettings.ScreenCaptureEnabled, False)
self.engine.loadFinished.connect(self.load_finished)
self.engine.load(QUrl(url))
self.engine.show()
@Slot(bool)
def load_finished(self, state):
pixmap = self.engine.grab()
self.image = QByteArray()
buf = QBuffer(self.image)
buf.open(QIODevice.WriteOnly)
pixmap.save(buf, "PNG")
buf.close()
self.quit()
def run(self):
try:
self.exec_()
except Exception:
return None
finally:
self.display.stop()
return self.image.data()
def main():
import sys
QCoreApplication.setOrganizationName("QtExamples")
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
WebUiHandler.registerUrlScheme()
app = QApplication(sys.argv)
profile = QWebEngineProfile()
handler = WebUiHandler()
profile.installUrlSchemeHandler(WebUiHandler.schemeName, handler)
page = QWebEnginePage(profile)
page.load(WebUiHandler.aboutUrl)
view = QWebEngineView()
view.setPage(page)
view.setContextMenuPolicy(Qt.NoContextMenu)
view.resize(500, 600)
view.show()
sys.exit(app.exec_())
sourceID)
def javaScriptAlert(self, securityOrigin, msg):
print(msg)
return super(MyQWebEnginePage,
self).javaScriptAlert(securityOrigin, msg)
if (__name__ == "__main__"):
app1 = QApplication(sys.argv)
# give the browser time to instatiate and then close down gracefully
QTimer.singleShot(
10000, app1.quit) # in case pageloadFinished() is never executed
browser = QWebEngineView()
webpage = MyQWebEnginePage(browser)
browser.setPage(webpage)
def pageloadFinished(ok):
#print('webpage load has finished: ' + str(ok))
browser.page().runJavaScript(jsstr)
# give the script time to run and then close us down gracefully
QTimer.singleShot(1000, app1.quit)
webpage.loadFinished.connect(pageloadFinished)
webpage.setHtml(htmlstr1)
browser.hide() # show() or hide() is necessary for loading the html page
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
#print('WebGL=' + str(webpage.webglsupport),)
app1.exec_()
class Py2WebBrowser(QDialog):
def __init__(self, settings=None):
super(Py2WebBrowser, self).__init__()
self.pwb = QWebEngineView()
self.pwb.setAttribute(Qt.WA_DeleteOnClose, True)
if settings is not None:
self.bconf = settings
else:
self.bconf = BaseConfig()
self.raw_cookies = []
self.cookie_list = []
self.req_obj = QWebEngineHttpRequest()
profile = QWebEngineProfile("pyweb", self.pwb)
profile.setHttpUserAgent(random.choice(self.bconf.USER_AGENT_LIST))
cookie_store = profile.cookieStore()
cookie_store.cookieAdded.connect(self._on_cookie)
wp = QWebEnginePage(profile, self.pwb)
self.pwb.setPage(wp)
self._settings()
self.pwb.show()
def _settings(self):
self.pwb.settings().setAttribute(ws.AutoLoadImages, self.bconf.AUTO_LOAD_IMAGES)
self.pwb.settings().setAttribute(ws.JavascriptEnabled, self.bconf.JAVASCRIPT_ENABLED)
self.pwb.settings().setAttribute(ws.JavascriptCanOpenWindows, self.bconf.JAVASCRIPT_CAN_OPEN_WINDOWS)
self.pwb.settings().setAttribute(ws.LocalStorageEnabled, self.bconf.LOCAL_STORAGE_ENABLED)
self.pwb.settings().setAttribute(ws.LocalContentCanAccessRemoteUrls, self.bconf.LOCAL_CONTENT_CAN_ACCESS_REMOTE_URLS)
self.pwb.settings().setAttribute(ws.LocalContentCanAccessFileUrls, self.bconf.LOCAL_CONTENT_CAN_ACCESS_FILE_URLS)
self.pwb.settings().setAttribute(ws.ErrorPageEnabled, self.bconf.ERROR_PAGES_ENABLED)
self.pwb.settings().setAttribute(ws.PluginsEnabled, self.bconf.PLUGINS_ENABLED)
self.pwb.settings().setAttribute(ws.WebGLEnabled, self.bconf.WEBGL_ENABLED)
self.pwb.settings().setAttribute(ws.AllowRunningInsecureContent, self.bconf.ALLOW_RUNNING_INSECURE_CONTENT)
self.pwb.settings().setAttribute(ws.AllowGeolocationOnInsecureOrigins, self.bconf.ALLOW_GEOLOCATION_ON_INSECURE_ORIGINS)
self.pwb.settings().setAttribute(ws.ShowScrollBars, self.bconf.SHOW_SCROLL_BARS)
self.pwb.settings().setAttribute(ws.DnsPrefetchEnabled, self.bconf.DNS_PREFETCH_ENABLED)
def _loadFinished(self):
self.pwb.page().toHtml(self._page_to_var)
self.pwb.page().runJavaScript(self.s)
def _page_to_var(self, html):
self.page_source = html
self._to_json()
self._return()
def _on_cookie(self, cookie):
for i in self.raw_cookies:
if i.hasSameIdentifier(cookie):
return
self.raw_cookies.append(QNetworkCookie(cookie))
def _to_json(self):
for i in self.raw_cookies:
data = {
"name": bytearray(i.name()).decode(),
"domain": i.domain(),
"value": bytearray(i.value()).decode(),
"path": i.path(),
"expireData": i.expirationDate().toString(),
"secure": i.isSecure(),
"httpOnly": i.isHttpOnly()
}
self.cookie_list.append(data)
def _return(self):
self.return_ = {
"url": str(self.req_obj.url().toString()),
"cookies": self.cookie_list,
"content": str(self.page_source)
}
self.accept()
def get(self, url: str, script: str = None):
self.s = script
self.req_obj.setUrl(QUrl().fromUserInput(url))
self.pwb.page().profile().cookieStore().deleteAllCookies()
self.pwb.load(self.req_obj)
self.pwb.loadFinished.connect(self._loadFinished)
class QGithubDeviceAuthDialog(QDialog):
def __init__(self,
client_id='42e8e8e9d844e45c2d05',
hint_username=None,
parent=None):
super(QGithubDeviceAuthDialog, self).__init__(parent=parent)
self.setWindowTitle('Log into your GitHub account and enter this code')
self.__webview = QWebEngineView(parent=self)
self.__webview.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.__webview.urlChanged.connect(self.on_url_changed)
self.__infolaabel = QLabel(
'<p style="font-size:14px">'
'<br>You need to allow hpaste to modify your gists on github. for that you need to log in to your account and authorize hpaste.\n'
'<br>You can do it in <b>any</b> browser, not only in this window. Just go to <a href="https://github.com/login/device">https://github.com/login/device</a> and enter the code below.\n'
'<br>close this window when you are done'
'</p>',
parent=self)
self.__infolaabel.setTextFormat(Qt.RichText)
self.__infolaabel.setTextInteractionFlags(Qt.TextBrowserInteraction)
self.__infolaabel.setOpenExternalLinks(True)
self.__devidlabel = QLabel(parent=self)
self.__devidlabel.setTextInteractionFlags(Qt.TextBrowserInteraction)
ff = self.__devidlabel.font()
ff.setPointSize(64)
self.__devidlabel.setFont(ff)
self.__reload_button = QPushButton('log in to a different account',
parent=self)
self.__reload_button.clicked.connect(self.reload_button_clicked)
self.__layout = QVBoxLayout()
self.setLayout(self.__layout)
self.__layout.addWidget(self.__infolaabel)
self.__layout.addWidget(self.__devidlabel)
self.__layout.addWidget(self.__reload_button)
self.__layout.addWidget(self.__webview)
self.__result = None
# self.setGeometry(512, 256, 1024, 768)
self.resize(1024, 860)
# init auth process
self.__client_id = client_id
self.__headers = {
'User-Agent': 'HPaste',
'Accept': 'application/json',
'charset': 'utf-8',
'Content-Type': 'application/json'
}
self.__hint_username = hint_username
self.__webprofile = None
self.__webpage = None
self.__device_code = None
self.__interval = None
self.__await_login_redirect = False
self.reinit_code()
def reinit_code(self):
reqdata = {'client_id': self.__client_id, 'scope': 'gist'}
req = request.Request('https://github.com/login/device/code',
data=json.dumps(reqdata).encode('UTF-8'),
headers=self.__headers)
req.get_method = lambda: 'POST'
code, ret = urlopen_nt(req)
if code != 200:
raise RuntimeError('code %d when trying to register device' % code)
init_data = json.loads(ret.read().decode('UTF-8'))
print(init_data)
self.__device_code = init_data['device_code']
self.__interval = init_data.get('interval', 5)
url = init_data['verification_uri']
self.__await_login_redirect = True
self.__webprofile = QWebEngineProfile(parent=self.__webview)
self.__webpage = QWebEnginePage(
self.__webprofile, parent=self.__webview
) # just to be sure they are deleted in proper order
self.__webview.setPage(self.__webpage)
self.__webview.load(QUrl(url))
self.__devidlabel.setText('code: %s' % (init_data['user_code'], ))
def get_result(self):
return self.__result
def closeEvent(self, event):
# here we assume user has done his part, so lets get checking
for attempt in range(5):
reqdata = {
'client_id': self.__client_id,
'device_code': self.__device_code,
'grant_type': 'urn:ietf:params:oauth:grant-type:device_code'
}
req = request.Request(
'https://github.com/login/oauth/access_token',
data=json.dumps(reqdata).encode('UTF-8'),
headers=self.__headers)
req.get_method = lambda: 'POST'
code, ret = urlopen_nt(req)
if code == 200:
rep = json.loads(ret.read().decode('UTF-8'))
print(rep)
if 'error' not in rep: # a SUCC
headers = {
'User-Agent': 'HPaste',
'Authorization': 'Token %s' % rep['access_token'],
'Accept': 'application/vnd.github.v3+json'
}
req = request.Request(r'https://api.github.com/user',
headers=headers)
usercode, userrep = urlopen_nt(req)
if usercode != 200:
raise RuntimeError('could not probe! %d' %
(usercode, ))
userdata = json.loads(userrep.read().decode('UTF-8'))
print(userdata)
self.__result = {
'token': rep['access_token'],
'user': userdata['login']
}
break
# NO SUCC
errcode = rep['error']
if errcode == 'authorization_pending':
# note that this error will happen if user just closes down the window
break
elif errcode == 'slow_down':
self.__interval = rep.get('interval', self.__interval + 5)
time.sleep(self.__interval)
continue
elif errcode == 'expired_token':
if QMessageBox.warning(
self,
'device code expired',
'it took you too long to enter the code, now it\'s expired.\nWant to retry?',
buttons=QMessageBox.Yes
| QMessageBox.No) == QMessageBox.Yes:
event.reject()
self.reinit_code()
return
break
elif errcode == 'unsupported_grant_type':
raise RuntimeError(
'unsupported grant type. probably github changed API. need to update the plugin'
)
elif errcode == 'incorrect_client_credentials':
raise RuntimeError(
'incorect client id. probably pedohorse changed hpaste id for some reason. update the plugin'
)
elif errcode == 'incorrect_device_code':
if QMessageBox.warning(
self,
'bad device code',
'server reported wrong device code\nWant to retry?',
buttons=QMessageBox.Yes
| QMessageBox.No) == QMessageBox.Yes:
event.reject()
self.reinit_code()
return
break
elif errcode == 'access_denied':
# means user denied the request
break
else:
raise RuntimeError('unexpected error: %s' %
(json.dumps(rep), ))
else:
raise RuntimeError(
'bad return code. server reported with bad return code %d'
% code)
else:
if QMessageBox.warning(
self,
'unknown error',
'could not manage to check authorization in reasonable amount of attempts\nWant to retry?',
buttons=QMessageBox.Yes
| QMessageBox.No) == QMessageBox.Yes:
event.reject()
self.reinit_code()
return
return super(QGithubDeviceAuthDialog, self).closeEvent(event)
@Slot(object)
def on_url_changed(self, qurl):
url = qurl.toString()
print(url)
if not self.__await_login_redirect:
return
if qurl.path() != '/login':
return
self.__await_login_redirect = False
if self.__hint_username is not None:
if qurl.hasQuery():
qurl.setQuery('&'.join(
(qurl.query(), 'login=%s' % self.__hint_username)))
else:
qurl.setQuery('login=%s' % self.__hint_username)
print('redir to %s' % qurl.toString)
self.__webview.load(qurl)
@Slot()
def reload_button_clicked(self):
self.reinit_code()
class GISOSM_Dialog(QtWidgets.QDialog):
def __init__(self, parent=None):
super(GISOSM_Dialog, self).__init__(parent)
self.sitename = "GIS-Sitedata"
#Get/set parameters for GIS
self.tempFolderName = "GIStemp/"
self.lat = str(
GIS2BIM_FreeCAD.ArchSiteCreateCheck(self.sitename).WGS84_Latitude)
self.lon = str(
GIS2BIM_FreeCAD.ArchSiteCreateCheck(self.sitename).WGS84_Longitude)
self.bboxWidthStart = str(
GIS2BIM_FreeCAD.ArchSiteCreateCheck(
self.sitename).BoundingboxWidth)
self.bboxHeightStart = str(
GIS2BIM_FreeCAD.ArchSiteCreateCheck(
self.sitename).BoundingboxHeight)
#Set Style
self.setStyleSheet(
"QWidget {background-color: rgb(68, 68, 68)} QPushButton { background-color: black } QGroupBox {border: 1px solid grey; }"
) #margin: 2px;
#Download files
self.URLmap = GIS2BIM.GetWebServerData("HTMLwfs", "Other", "URL")
#self.filepathBaseMap = GIS2BIM.DownloadURL(GIS2BIM_FreeCAD.CreateTempFolder(self.tempFolderName),self.URLmap,"basemapWFS.html") #Basemap from GIS2BIM Repository for preview
#self.filepathNewMap = GIS2BIM.DownloadURL(GIS2BIM_FreeCAD.CreateTempFolder(self.tempFolderName),self.URLmap,"mapWFS.html") #Edited Basemap with location and bbox
self.filepathBaseMap = "C:/Users/mikev/OneDrive/Bureaublad/TEMP/GIStemp/basemapWFS.html"
self.filepathNewMap = "C:/Users/mikev/OneDrive/Bureaublad/TEMP/GIStemp/mapWFS.html"
self.tempFolderPath = GIS2BIM_FreeCAD.CreateTempFolder(
self.tempFolderName)
os.remove(self.filepathNewMap)
BaseMap = open(self.filepathBaseMap, "r")
BaseMapstr = BaseMap.read()
Newstr = BaseMapstr.replace("51LAT", str(self.lat))
Newstr = Newstr.replace("4LONG", str(self.lon))
Newstr = Newstr.replace("WBBOX", self.bboxWidthStart)
Newstr = Newstr.replace("HBBOX", self.bboxHeightStart)
open(self.filepathNewMap, "x")
f1 = open(self.filepathNewMap, "w")
f1.write(Newstr)
f1.close()
#Overall Grid
grid = QtWidgets.QGridLayout()
grid.addWidget(self.webViewGroup(), 0, 0, 1, 2)
grid.addWidget(self.locationGroup(), 3, 0, QtCore.Qt.AlignTop)
grid.addLayout(self.buttonGroup(), 4, 0, 1, 2)
grid.setRowStretch(0, 2)
self.setLayout(grid)
self.setWindowTitle("Load 2D Vector Data with WFS(Web Feature Server)")
self.resize(920, 910)
def webViewGroup(self):
groupBox = QtWidgets.QGroupBox("Map")
groupBox.setStyleSheet("QGroupBox {border: 1px solid grey;}")
radio1 = QtWidgets.QRadioButton("&Radio button 1")
radio1.setChecked(True)
webFrame = QFrame()
webFrame.setFrameShape(QFrame.StyledPanel)
vbox = QtWidgets.QVBoxLayout()
groupBox.setLayout(vbox)
self.webView = QWebEngineView()
self.webPage = QWebEnginePage()
self.webPage.load(QUrl(QtCore.QUrl(self.filepathNewMap)))
self.webView.setObjectName("webView")
self.webView.setPage(self.webPage)
self.webView.show()
vbox.addWidget(self.webView)
return groupBox
def locationGroup(self):
groupBox = QtWidgets.QGroupBox("Location / Boundingbox")
latLonLab = QtWidgets.QLabel("lat/lon (WGS-84)")
latLon = QtWidgets.QLabel("lat: " + self.lat + ", lon: " + self.lon)
bboxWidthLab = QtWidgets.QLabel("Boundingbox Width [m]")
self.bboxWidth = QtWidgets.QLineEdit()
self.bboxWidth.setText(self.bboxWidthStart)
self.bboxWidth.editingFinished.connect(self.onbboxWidth)
bboxHeightLab = QtWidgets.QLabel("Boundingbox Height [m]")
self.bboxHeight = QtWidgets.QLineEdit()
self.bboxHeight.setText(self.bboxHeightStart)
self.bboxHeight.editingFinished.connect(self.onbboxHeight)
grid = QtWidgets.QGridLayout()
grid.addWidget(latLonLab, 0, 0)
grid.addWidget(latLon, 0, 1)
grid.addWidget(CRSLab, 1, 0)
grid.addWidget(CRSText, 1, 1)
grid.addWidget(bboxWidthLab, 2, 0)
grid.addWidget(self.bboxWidth, 2, 1)
grid.addWidget(bboxHeightLab, 3, 0)
grid.addWidget(self.bboxHeight, 3, 1)
groupBox.setLayout(grid)
groupBox.setStyleSheet("QGroupBox {border: 1px solid grey;}")
return groupBox
def buttonGroup(self):
importbtn = QtWidgets.QPushButton("Import")
importbtn.clicked.connect(self.onImport)
cancelbtn = QtWidgets.QPushButton("Cancel")
cancelbtn.clicked.connect(self.onCancel)
hbox = QtWidgets.QHBoxLayout()
hbox.addWidget(importbtn)
hbox.addWidget(cancelbtn)
return hbox
def onbboxWidth(self):
JS2 = open(self.filepathJSUpdate, "r")
JS2 = JS2.read()
JS2 = JS2.replace("WBBOX", self.bboxWidth.text())
JS2 = JS2.replace("HBBOX", self.bboxHeight.text())
self.webPage.runJavaScript(JS2) # update bboxWidth in mapview
self.testWFS()
def onbboxHeight(self):
JS3 = open(self.filepathJSUpdate, "r")
JS3 = JS3.read()
JS3 = JS3.replace("WBBOX", self.bboxWidth.text())
JS3 = JS3.replace("HBBOX", self.bboxHeight.text())
self.webPage.runJavaScript(JS3) # update bboxHeight in mapview
self.testWFS()
def onImport(self):
self.bboxString = GIS2BIM.CreateBoundingBox(
float(GIS2BIM_FreeCAD.ArchSiteCreateCheck(self.sitename).CRS_x),
float(GIS2BIM_FreeCAD.ArchSiteCreateCheck(self.sitename).CRS_y),
float(self.bboxWidth.text()), float(self.bboxHeight.text()), 2)
url = self.request.text()
xpathstr = self.xPathStr.text()
closedValue = self.clsPolygon.isChecked()
makeFaceValue = self.clsCreateFace.isChecked()
drawStyle = str(self.linePattern.currentText())
Curves = GIS2BIM_FreeCAD.CurvesFromWFS(url, self.bboxString, xpathstr,
-float(self.X), -float(self.Y),
1000, 3, closedValue,
makeFaceValue, drawStyle,
(0.7, 0.0, 0.0))
GIS2BIM_FreeCAD.CreateLayer(self.groupName.text())
FreeCAD.activeDocument().getObject(
self.groupName.text()).addObjects(Curves)
FreeCAD.ActiveDocument.recompute()
self.close()
def onCancel(self):
self.close()
class BrowserDialog(QMainWindow):
logMessage = Signal(str)
scrapeData = Signal(str)
newCookie = Signal(str, str)
loadFinished = Signal(bool)
urlChanged = Signal(str)
urlNotFound = Signal(QUrl)
def __init__(self, parent=None, caption="", width=600, height=600):
super(BrowserDialog, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.resize(width, height)
self.setWindowTitle(caption)
self.url = None
self.domain = None
self.headers = {}
self.stopped = False
self.cookie = ''
central = QWidget()
self.setCentralWidget(central)
self.mainLayout = QVBoxLayout(central)
#self.browserStatus = self.statusBar()
# Create WebView
self.browserWebview = QWebEngineView(self)
self.webpage = QWebPageCustom(self.browserWebview)
self.browserWebview.setPage(self.webpage)
self.mainLayout.addWidget(self.browserWebview)
self.browserWebview.show()
# Signals
self.webpage.logMessage.connect(self.logMessage)
self.webpage.cookieChanged.connect(self.cookieChanged)
#self.browserWebview.urlChanged.connect(self.urlChanged)
#self.webpage.urlNotFound.connect(self.urlNotFound)
#self.browserWebview.loadFinished.connect(self.loadFinished)
# Buttons
self.buttonLayout = QHBoxLayout()
self.mainLayout.addLayout(self.buttonLayout)
self.statusLabel = QLabel()
self.buttonLayout.addWidget(self.statusLabel)
self.buttonLayout.addStretch(5)
buttonDismiss = QPushButton(self)
buttonDismiss.setText("Close")
buttonDismiss.setDefault(True)
buttonDismiss.clicked.connect(self.close)
self.buttonLayout.addWidget(buttonDismiss)
def loadPage(self, url="", headers={}):
self.url = url
self.headers = headers
try:
targeturl = urllib.parse.urlparse(url)
self.domain = targeturl.netloc
except:
self.domain = None
request = QWebEngineHttpRequest(QUrl(self.url))
for key, val in self.headers.items():
key = key.encode('utf-8')
val = val.encode('utf-8')
request.setHeader(QByteArray(key), QByteArray(val))
self.browserWebview.load(request)
self.show()
# Scrape HTML
def activateScrapeButton(self, handler):
self.scrapeData.connect(handler)
buttonScrape = QPushButton(self)
buttonScrape.setText("Scrape data")
buttonScrape.setDefault(True)
buttonScrape.clicked.connect(self.scrapeDataClicked)
self.buttonLayout.addWidget(buttonScrape)
@Slot()
def scrapeDataClicked(self):
self.webpage.toHtml(self.newHtmlData)
def newHtmlData(self, data):
self.scrapeData.emit(data)
# Get cookie from initial domain
def activateCookieButton(self, handler):
self.newCookie.connect(handler)
buttonCookie = QPushButton(self)
buttonCookie.setText("Transfer cookie")
buttonCookie.setDefault(True)
buttonCookie.clicked.connect(self.transferCookieClicked)
self.buttonLayout.addWidget(buttonCookie)
@Slot()
def transferCookieClicked(self):
self.newCookie.emit(self.domain, self.cookie)
@Slot(str, str)
def cookieChanged(self, domain, cookie):
if domain == self.domain:
self.cookie = cookie
self.statusLabel.setText("Domain: " + domain + ". Cookie: " +
cookie)
class GraphWidget(QWidget):
def __init__(self, log_console):
logger.debug(locals())
QWidget.__init__(self)
log_console.add_loggers(logger)
self.graph = None
self.webview = QWebEngineView(parent=self)
self.index = QWebEnginePage(self)
worklayout = QHBoxLayout(parent=self)
worklayout.addWidget(self.webview)
self.setLayout(worklayout)
def draw_index(self):
if not self.graph:
logger.warning("No graph to draw found!")
width = self.contentsRect().width()
height = self.contentsRect().height()
pagewidth = int(width) - 10
pageheight = int(height) - 10
logger.info(f"{width}x{height}")
html = importlib.resources.read_text(__package__,
"index.thtml",
encoding="utf-8-sig")
html = (html.replace(
"$graph",
"'" + json.dumps(networkx.node_link_data(self.graph)) +
"'" if self.graph else
"""'{"directed":true,"multigraph":true,"graph":[],"nodes":[],"links":[]}'""",
).replace("$width", str(pagewidth)).replace("$height",
str(pageheight)))
path = pathlib.Path(
QStandardPaths.writableLocation(
QStandardPaths.AppLocalDataLocation)) / "index.html"
logger.info(f"""Saving html to {path.absolute()}""")
path.write_text(html)
self.index.setHtml(html)
self.index.settings().setAttribute(QWebEngineSettings.ShowScrollBars,
False)
self.webview.setPage(self.index)
self.webview.resize(width, height)
self.webview.show()
self.update()
@Slot()
def draw_graph(self):
logger.debug(locals())
self.draw_index()
@Slot()
def get_open_file_extensions(self):
logger.debug(locals())
return ";;".join([
"Node Link Graph (*.json)",
"Adjacency Graph (*.json)",
"GraphML (.graphml)",
"LEDA (*.gw, *.lgr, *.leda)",
"Pajek (*.net)",
])
@Slot()
def get_save_file_extensions(self):
logger.debug(locals())
return ";;".join(
["Node Link Graph (*.json)", "Adjacency Graph (*.json)"])
@Slot(str, str)
def open_file(self, path: str, file_type: str):
logger.debug(locals())
if "json" in file_type.lower():
if "node link graph" in file_type.lower():
self.graph = networkx.node_link_graph(
json.loads(pathlib.Path(path).read_text()))
elif "adjacency graph" in file_type.lower():
self.graph = networkx.adjacency_graph(
json.loads(pathlib.Path(path).read_text()))
else:
raise NotImplementedError()
elif "graphml" in file_type.lower():
self.graph = networkx.read_graphml(path)
elif "leda" in file_type.lower():
self.graph = networkx.read_leda(path)
elif "pajek" in file_type.lower():
self.graph = networkx.read_pajek(path)
else:
raise NotImplementedError()
@Slot(str, str)
def save_file(self, path: str, file_type: str):
logger.debug(locals())
if not self.graph:
raise ValueError("No graph to save!")
if "json" in file_type.lower():
if "node link graph" in file_type.lower():
with pathlib.Path(path).open("w") as file_p:
data = networkx.node_link_data(self.graph)
json.dump(data, file_p)
del data
elif "adjacency graph" in file_type.lower():
with pathlib.Path(path).open("w") as file_p:
data = networkx.adjacency_data(self.graph)
json.dump(data, file_p)
del data
else:
raise NotImplementedError()
else:
raise NotImplementedError()
class SergeyApp(QWidget):
"""Класс основного приложения.
Тут располагаются все виджеты(кнопки, поля ввода и др.)"""
def __init__(self):
super().__init__()
with open("src/quest.json", encoding="utf-8") as f:
self.quest = json.load(f)
self.bot = SergeyBot(self)
self.initUI()
def sendMsg(self):
txt = self.inputbox.text()
self.inputbox.clear()
if txt != "" and not self.bot.is_answering:
self.bot.is_answering = True
self.chat.setTextColor(Qt.white)
self.chat.append("Вы: " + txt)
self.chat.setTextColor(Qt.black)
self.chat.insertPlainText("\nСерёга: ")
self.chat.verticalScrollBar().setValue(
self.chat.verticalScrollBar().maximum())
for i in range(3):
self.chat.insertPlainText(".")
# Чтобы отображалась "анимация" точек,
# нужно каждый раз говорить приложению обновиться
QCoreApplication.processEvents()
time.sleep(0.5)
for i in range(3):
self.chat.textCursor().deletePreviousChar()
self.bot.answer(txt)
self.bot.is_answering = False
def initUI(self):
"""Функция инициализации всех виджетов
(вызывать её не надо)"""
# showMaximized() изменяет размер окна на максимальный.
self.showMaximized()
# Присваиваем названию окна строку "SERGEY APP!!!".
self.setWindowTitle("SERGEY APP!!!")
# Должно менять иконку приложения (Почему-то не работает).
self.setWindowIcon(QIcon("icon.ico"))
# QWebEngineView - класс библиотеки, с помощью которого можно
# отображать Web страницы (сайты из интернета или
# просто локальные файлы HTML).
# Иницилиализируем его, передавая обьект нашего главного класса.
self.web = QWebEngineView(self)
# Получаем абсолютный путь файла
# map2.html (почему-то QWebEngineView
# загружает только абсолютные пути файла).
file_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "index.html"))
self.web.setPage(WebPage(self.web))
self.web.load(QUrl.fromLocalFile(file_path))
def ready(retVal):
print("Returned:", retVal)
def loadFinished(ok):
if ok:
#self.web.page().runJavaScript("bruhmoment()", ready)
pass
self.web.loadFinished.connect(loadFinished)
self.jsChannel = QWebChannel()
self.jsHandler = CallHandler()
self.jsChannel.registerObject("jsHandler", self.jsHandler)
self.web.page().setWebChannel(self.jsChannel)
input_frame = QFrame(self)
input_frame.setFrameStyle(QFrame.Box)
inputgrid = QGridLayout(input_frame)
inputButtonTexts = ["Привет!", "Квест", "Пока!"]
buttons = []
for i in range(len(inputButtonTexts)):
buttons.append(InputButton(inputButtonTexts[i], input_frame, self))
inputgrid.addWidget(buttons[i], 0, i, 1, 1)
self.inputbox = QLineEdit(input_frame)
self.inputbox.returnPressed.connect(self.sendMsg)
inputgrid.addWidget(self.inputbox, 1, 0, 1, -1)
self.chat = Chat()
# QGridLayout - один из макетных классов, которые помогает управлять
# положением виджетов. Этот класс управляет положениями виджетов
# с помощью "таблицы", например как в Excel.
# Виджеты могут занимать несколько "клеток" в таблице.
# Пример макета:
# +------------+----------------+
# | Кнопка | |
# +------------+ Что-то еще... |
# | | |
# | Поле ввода +----------------+
# | | Какой-то текст |
# +------------+----------------+
main_layout = QGridLayout(self)
# Добавляем все наши виджеты (кнопки, веб страницы и т.д.)
main_layout.addWidget(self.chat, 0, 0, 80, 60)
main_layout.addWidget(input_frame, 80, 0, 20, 60)
main_layout.addWidget(self.web, 0, 60, 100, 40)
class BrowserDialog(QMainWindow):
logMessage = Signal(str)
captureData = Signal(dict, dict, dict)
newCookie = Signal(str, str)
#loadFinished = Signal(bool)
#urlChanged = Signal(str)
#urlNotFound = Signal(QUrl)
def __init__(self, parent=None, caption="", width=600, height=600):
super(BrowserDialog, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.resize(width, height)
self.setWindowTitle(caption)
self.url = None
self.domain = None
self.headers = {}
self.stopped = False
self.cookie = ''
self.ready = False
central = QWidget()
self.setCentralWidget(central)
self.mainLayout = QVBoxLayout(central)
self.topLayout = QHBoxLayout()
self.mainLayout.addLayout(self.topLayout)
# Status bar
self.statusBar = self.statusBar()
self.cookieLabel = QScrollLabel()
self.cookieLabel.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Ignored)
self.statusBar.addWidget(self.cookieLabel)
self.cookieLabel.textVisible(False)
self.loadingLabel = QLabel()
self.statusBar.addPermanentWidget(self.loadingLabel)
# Adress bar
self.addressBar = QLineEdit()
self.addressBar.returnPressed.connect(self.addressChanged)
self.topLayout.addWidget(self.addressBar)
self.addressBar.setVisible(False)
# Create WebView
self.webview = QWebEngineView(self)
QWebEngineSettings.globalSettings().setAttribute(
QWebEngineSettings.PluginsEnabled, True)
QWebEngineSettings.globalSettings().setAttribute(
QWebEngineSettings.ScreenCaptureEnabled, True)
self.webpage = WebPageCustom(self.webview)
self.webview.setPage(self.webpage)
self.mainLayout.addWidget(self.webview)
self.webview.show()
# Signals
self.webpage.logMessage.connect(self.logMessage)
self.webpage.cookieChanged.connect(self.cookieChanged)
self.webview.urlChanged.connect(self.urlChanged)
self.webpage.loadFinished.connect(self.loadFinished)
self.webpage.loadStarted.connect(self.loadStarted)
#self.webpage.urlNotFound.connect(self.urlNotFound)
#self.browserWebview.loadFinished.connect(self.loadFinished)
#self.browserWebview.loadStarted.connect(self.loadStarted)
# Button layout
self.buttonLayout = QHBoxLayout()
self.topLayout.addLayout(self.buttonLayout)
# Buttons
buttonDismiss = QPushButton(self)
buttonDismiss.setText("Close")
buttonDismiss.setDefault(True)
buttonDismiss.clicked.connect(self.close)
self.buttonLayout.addWidget(buttonDismiss)
def loadPage(self,
url="",
headers={},
options={},
foldername=None,
filename=None,
fileext=None):
self.url = url
self.headers = headers
self.options = options
self.strip = self.options.get('access_token', '')
self.foldername = foldername
self.filename = filename
self.fileext = fileext
try:
targeturl = urllib.parse.urlparse(url)
self.domain = targeturl.netloc
except:
self.domain = None
request = QWebEngineHttpRequest(QUrl(self.url))
for key, val in self.headers.items():
key = key.encode('utf-8')
val = val.encode('utf-8')
request.setHeader(QByteArray(key), QByteArray(val))
self.webview.load(request)
self.show()
@Slot()
def loadStarted(self):
self.ready = False
self.loadingLabel.setText('Loading...')
@Slot()
def loadFinished(self, ok):
if ok:
self.ready = True
self.loadingLabel.setText('Loading finished.')
else:
self.ready = False
self.loadingLabel.setText('Loading failed.')
@Slot()
def urlChanged(self, url):
url = url.toString().replace(self.strip, '')
self.addressBar.setText(url)
@Slot()
def addressChanged(self):
url = self.addressBar.text()
request = QWebEngineHttpRequest(QUrl(url))
self.webview.load(request)
# Scrape HTML
def activateCaptureButton(self, handler):
self.captureData.connect(handler)
buttonCapture = QPushButton(self)
buttonCapture.setText("Capture")
buttonCapture.setDefault(True)
buttonCapture.clicked.connect(self.captureDataClicked)
self.buttonLayout.addWidget(buttonCapture)
self.addressBar.setVisible(True)
@Slot()
def captureDataClicked(self):
# Metadata
data = {}
data['title'] = self.webpage.title()
try:
data['url'] = {
'final':
self.webpage.url().toString().replace(self.strip, ''),
'requested':
self.webpage.requestedUrl().toString().replace(self.strip, '')
}
# Fetch HTML
data['text'] = self.getHtml()
# Fetch plain text
data['plaintext'] = self.getText()
if self.foldername is not None:
# Screenshot
try:
fullfilename = makefilename(data['url']['final'],
self.foldername,
self.filename,
fileext='.png',
appendtime=True)
data['screenshot'] = self.getScreenShot(fullfilename)
except Exception as e:
self.logMessage.emit('Error capturing screenshot: ' +
str(e))
# HTML file
try:
fullfilename = makefilename(data['url']['final'],
self.foldername,
self.filename,
self.fileext,
appendtime=True)
file = open(fullfilename, 'wb')
if file is not None:
try:
file.write(data['text'].encode())
finally:
file.close()
except Exception as e:
self.logMessage.emit('Error saving HTML: ' + str(e))
# PDF
try:
fullfilename = makefilename(data['url']['final'],
self.foldername,
self.filename,
fileext='.pdf',
appendtime=True)
self.webpage.printToPdf(fullfilename)
data['pdf'] = fullfilename
except Exception as e:
self.logMessage.emit('Error printing to PDF: ' + str(e))
except Exception as e:
data['error'] = str(e)
self.logMessage.emit(str(e))
# Options
options = self.options
options['querytime'] = str(datetime.now())
options['querystatus'] = 'captured'
options['querytype'] = 'captured'
#options['objectid'] = 'url.final'
#options['nodedata'] = None
# Headers
headers = {}
self.captureData.emit(data, options, headers)
def getHtml(self):
def newHtmlData(html):
self.capturedhtml = html
self.capturedhtml = None
self.webpage.toHtml(newHtmlData)
waitstart = QDateTime.currentDateTime()
while (self.capturedhtml is None) and (waitstart.msecsTo(
QDateTime.currentDateTime()) < 1000):
QApplication.processEvents()
time.sleep(0.01)
return self.capturedhtml
def getText(self):
def newTextData(txt):
self.capturedtext = txt
self.capturedtext = None
self.webpage.toPlainText(newTextData)
waitstart = QDateTime.currentDateTime()
while (self.capturedtext is None) and (waitstart.msecsTo(
QDateTime.currentDateTime()) < 1000):
QApplication.processEvents()
time.sleep(0.01)
return self.capturedtext
# https://stackoverflow.com/questions/55231170/taking-a-screenshot-of-a-web-page-in-pyqt5
#screenshots: https://stackoverrun.com/de/q/12970119
def getScreenShot(self, filename):
try:
# Resize
oldSize = self.webview.size()
newSize = self.webpage.contentsSize().toSize()
self.webview.settings().setAttribute(
QWebEngineSettings.ShowScrollBars, False)
self.webview.setAttribute(Qt.WA_DontShowOnScreen, True)
self.webview.resize(newSize)
#self.webview.repaint()
#self.webview.show()
# Wait for resize
waitstart = QDateTime.currentDateTime()
while (waitstart.msecsTo(QDateTime.currentDateTime()) < 500):
QApplication.processEvents()
time.sleep(0.01)
# Capture
pixmap = QPixmap(newSize)
self.webview.render(pixmap, QPoint(0, 0))
pixmap.save(filename, 'PNG')
self.webview.resize(oldSize)
self.webview.setAttribute(Qt.WA_DontShowOnScreen, False)
self.webview.settings().setAttribute(
QWebEngineSettings.ShowScrollBars, True)
self.repaint()
except Exception as e:
self.logMessage.emit(str(e))
return filename
# Get cookie from initial domain
def activateCookieButton(self, handler):
self.newCookie.connect(handler)
self.cookieLabel.textVisible(True)
buttonCookie = QPushButton(self)
buttonCookie.setText("Transfer cookie")
buttonCookie.setDefault(True)
buttonCookie.clicked.connect(self.transferCookieClicked)
self.buttonLayout.addWidget(buttonCookie)
self.addressBar.setVisible(True)
@Slot()
def transferCookieClicked(self):
self.newCookie.emit(self.domain, self.cookie)
@Slot(str, str)
def cookieChanged(self, domain, cookie):
if domain == self.domain:
self.cookie = cookie
self.cookieLabel.setText("Cookie for domain: " + domain + ": " +
cookie)
print("WebEnginePage Console: ", level, message, lineNumber, sourceId)
if __name__ == "__main__":
# Set up the main application
app = QApplication([])
app.setApplicationDisplayName("Greetings from the other side")
# Use a webengine view
view = QWebEngineView()
view.resize(500, 200)
# Set up backend communication via web channel
handler = Handler()
channel = QWebChannel()
# Make the handler object available, naming it "backend"
channel.registerObject("backend", handler)
# Use a custom page that prints console messages to make debugging easier
page = WebEnginePage()
page.setWebChannel(channel)
view.setPage(page)
# Finally, load our file in the view
url = QUrl.fromLocalFile(f"{data_dir}/index.html")
view.load(url)
view.show()
app.exec_()
if __name__ == '__main__':
print(__version_info__)
# Create the Qt Application
app = QApplication(sys.argv)
#load all javascript libraries
with open("extern/jquery-min.js",
"r") as jqFile, open("extern/qwebchannel.js") as qwFile:
content = "\n" + jqFile.read()
#content += "\n" + qwFile.read()
content += "\n" + "var qt = { 'jQuery': jQuery.noConflict(true) };"
WEBVIEW_CONTENT_SKELETON = WEBVIEW_CONTENT_SKELETON.replace(
" __replace_this_with_all_javascript_library_stuff__", content)
#socket_server = QWebSocketServer("QWebSocketServer workaround server", QWebSocketServer.NonSecureMode)##
#if not socket_server.listen(QHostAddress.LocalHost, 12345):
# raise Exception("uh cannot create socket server")
web_page = MyWebPage()
web = QWebEngineView()
web.setPage(web_page)
web.setHtml(WEBVIEW_CONTENT_SKELETON)
web.loadFinished.connect(loadfinished)
# Run the main Qt loop
web.show()
sys.exit(app.exec_())
class PreLoginWebDialog(QDialog):
def __init__(self, parent=None, caption="", url=""):
super(PreLoginWebDialog, self).__init__(parent)
self.url = url
self.setWindowTitle(caption)
self.setMinimumWidth(600)
self.setMinimumHeight(500)
vLayout = QVBoxLayout()
self.setLayout(vLayout)
self.browser = QWebEngineView(self)
self.page = WebPageCustom(self.browser)
self.page.allowLinks = False
self.page.loadFinished.connect(self.loadFinished)
self.page.loadStarted.connect(self.loadStarted)
self.browser.setPage(self.page)
vLayout.addWidget(self.browser)
# Buttons
hLayout = QHBoxLayout()
vLayout.addLayout(hLayout)
# Status bar
self.reloadButton = QPushButton(self)
self.reloadButton.setText("Retry")
self.reloadButton.clicked.connect(self.loadPage)
self.reloadButton.setVisible(False)
hLayout.addWidget(self.reloadButton)
self.loadingLabel = QLabel()
hLayout.addWidget(self.loadingLabel)
hLayout.addStretch(5)
buttonDismiss = QPushButton(self)
buttonDismiss.setText("Cancel")
buttonDismiss.clicked.connect(self.reject)
hLayout.addWidget(buttonDismiss)
self.buttonProceed = QPushButton(self)
self.buttonProceed.setText("Proceed")
self.buttonProceed.setDefault(True)
self.buttonProceed.clicked.connect(self.accept)
self.buttonProceed.setDisabled(True)
hLayout.addWidget(self.buttonProceed)
#browser.setBackgroundRole(QPalette.Window)
def loadPage(self):
#self.browser.load(QUrl(self.url))
self.browser.load(self.url)
def show(self):
#super(WebDialog, self).show()
self.loadPage()
return self.exec_()
@Slot()
def loadStarted(self):
self.ready = False
self.buttonProceed.setDisabled(True)
self.loadingLabel.setText('Loading...')
@Slot()
def loadFinished(self, ok):
if ok:
self.ready = True
self.reloadButton.setVisible(False)
self.buttonProceed.setDisabled(False)
self.loadingLabel.setText('Loading finished.')
else:
self.ready = False
self.reloadButton.setVisible(True)
self.buttonProceed.setDisabled(True)
self.loadingLabel.setText('Loading failed.')
