class PdfExport():
def __init__(self, filename, book, status_bar):
QApplication.setOverrideCursor(Qt.WaitCursor)
self.filename = filename
self.status_bar = status_bar
html = "<html>\n<head>\n"
html += "<link href=\"../css/pastie.css\" rel=\"stylesheet\" type=\"text/css\"/>\n"
html += "<link href=\"../css/stylesheet.css\" rel=\"stylesheet\" type=\"text/css\"/>\n"
html += "</head>\n<body>\n"
for part in book._parts:
self.status_bar.showMessage("Processing " + part.name)
with open(os.path.join(book.source_path, "parts", part.src),
"r") as i:
text = i.read()
htm = markdown(text,
html4tags=False,
extras=[
"fenced-code-blocks", "wiki-tables",
"tables", "header-ids"
])
htm = addLineNumbers(htm)
html += htm
html += "\n</body>\n</html>"
self.status_bar.showMessage("Loading HTML")
self.page = QWebEnginePage()
self.page.loadFinished.connect(self.loadFinished)
self.page.pdfPrintingFinished.connect(self.printFinished)
self.page.setHtml(
html,
QUrl(
Path(os.path.join(book.source_path, "parts",
"index.html")).as_uri()))
def loadFinished(self, ok):
if ok:
self.status_bar.showMessage("Printing PDF")
self.page.printToPdf(self.filename,
pageLayout=QPageLayout(
QPageSize(QPageSize.A5),
QPageLayout.Portrait,
QMarginsF(30.0, 30.0, 30.0, 30.0)))
else:
self.status_bar.showMessage("There was an error printing the PDF")
def printFinished(self, filename, success):
QApplication.restoreOverrideCursor()
if success:
self.status_bar.showMessage("PDF created")
else:
self.status_bar.showMessage("There was an error printing the PDF")
def _registerHandler(self, scheme, url):
'''
@param: scheme QString
@param: url QUrl
'''
urlString = url.toString()
urlString = urlString.replace('%25s', '%s')
page = QWebEnginePage(self)
page.loadFinished.connect(page.deleteLater)
page.registerProtocolHandlerRequested.connect(lambda request: request.accept())
page.setHtml('<script>navigator.registerProtocolHandler("%s", "%s", "")</script>' %
(scheme, urlString), url)
def __init__(self):
super().__init__()
# setup a page with my html
my_page = QWebEnginePage(self)
my_page.setHtml(self.html)
self.setPage(my_page)
# setup channel
self.channel = QWebChannel()
self.backend = self.Backend(self)
self.channel.registerObject('backend', self.backend)
self.page().setWebChannel(self.channel)
def __unregisterHandler(self, scheme, url):
"""
Private method to unregister a protocol handler for a scheme.
@param scheme scheme of the protocol handler
@type str
@param url URL of the protocol handler
@type QUrl
"""
urlStr = url.toString().replace("%25s", "%s")
page = QWebEnginePage(self)
page.loadFinished.connect(page.deleteLater)
page.setHtml(
"<script>navigator.unregisterProtocolHandler('{0}', '{1}', '')"
"</script>".format(scheme, urlStr), url)
def __registerHandler(self, scheme, url):
"""
Private method to register a protocol handler for a scheme.
@param scheme scheme of the protocol handler
@type str
@param url URL of the protocol handler
@type QUrl
"""
urlStr = url.toString().replace("%25s", "%s")
page = QWebEnginePage(self)
page.loadFinished.connect(page.deleteLater)
try:
# for Qt >= 5.11
page.registerProtocolHandlerRequested.connect(lambda r: r.accept())
except AttributeError:
pass
page.setHtml(
"<script>navigator.registerProtocolHandler('{0}', '{1}', '')"
"</script>".format(scheme, urlStr), url)
def print_html_webengine(printer_name, html):
printer = QPrinter()
if printer_name:
printer.setPrinterName(printer_name)
# printer.setOutputFormat(QPrinter.PdfFormat)
# printer.setResolution(printer.HighResolution)
printer.setResolution(200)
text_document = QWebEnginePage()
def callback(is_ok):
if is_ok:
print('printing finished')
else:
print('printing error')
def print_exec():
text_document.print(printer, callback)
text_document.loadFinished.connect(print_exec)
text_document.setHtml(html)
class Previewer(QWidget):
instance = 0
def __init__(self, parent=None, index = -1):
super(Previewer, self).__init__(parent)
self.parent = parent
self.index = index
self.handle = QWebEngineView()
self.handle.setGeometry(100, 100, 350, 400)
self.handle.setWindowTitle("Helper")
self.handle.setWindowIcon(QIcon('icon.png'))
if self.index == 0:
link = "help\\read_time.html"
elif self.index == 1:
link = "help\\set_time.html"
elif self.index == 2:
link = "help\\read_date.html"
elif self.index == 3:
link = "help\\set_date.html"
elif self.index == 4:
link = "help\\set_cursor.html"
elif self.index == 5:
link = "help\\char_input.html"
elif self.index == 6:
link = "help\\char_output.html"
elif self.index == 7:
link = "help\\disc_space.html"
else:
link = "help\\index.html"
page = open(link, 'r').read()
self.page = QWebEnginePage()
self.page.setHtml(page)
self.handle.setPage(self.page)
self.handle.show()
def zamknij(self):
Previewer.instance -= 1
self.handle.destroy()
class TeamtoolBrowser(QWidget, design.Ui_Form):
def __init__(self, parent=None):
super(TeamtoolBrowser, self).__init__(parent)
self.setupUi(self)
self.browser = QWebEngineView()
self.profile = QWebEngineProfile("somestorage", self.browser)
self.webpage = QWebEnginePage(self.profile, self.browser)
self.browser.setPage(self.webpage)
self.initUI()
self.eventUI()
def eventUI(self):
self.btnRefresh.clicked.connect(lambda: self.browse(refresh=True))
self.codeEdit.textChanged.connect(lambda: self.browse(offline=True))
self.fileView.doubleClicked.connect(self.selectFile)
self.urlBar.returnPressed.connect(lambda: self.browse())
self.webpage.loadStarted.connect(lambda: self.startLoading())
self.webpage.loadFinished.connect(lambda: self.onLoadFinished())
self.btnPrev.clicked.connect(lambda: self.prev())
self.btnNext.clicked.connect(lambda: self.next())
def prev(self):
''' History: go back '''
self.webpage.page().triggerAction(QWebEnginePage.Back)
self.urlBar.setText(self.webpage.url().toString())
def next(self):
''' History: move forward '''
self.webpage.page().triggerAction(QWebEnginePage.Forward)
self.urlBar.setText(self.webpage.url().toString())
def startLoading(self):
''' When page starts to load '''
self.loadingAnimation.start()
self.labelLoading.setVisible(True)
def onLoadFinished(self):
''' When page has finished to load '''
self.loadingAnimation.stop()
self.labelLoading.setVisible(False)
if self.webpage.history().canGoBack():
self.btnPrev.setEnabled(True)
else:
self.btnPrev.setEnabled(False)
if self.webpage.history().canGoForward():
self.btnNext.setEnabled(True)
else:
self.btnNext.setEnabled(False)
self.urlBar.setText(self.webpage.url().toString())
def browse(self, refresh=False, offline=False):
''' Browse to urlBar URL or render a text/html string '''
# Offline mode, load plaintext html code
if offline:
self.webpage.setHtml(self.codeEdit.toPlainText())
return
# Online mode
if refresh:
url = self.browser.reload()
return
url = self.urlBar.text()
if not re.match('http://|https://', url, re.I):
url = f'http://{url}'
# print('===============>', os.path.join('statics/button', 'lock-ssl.png'), QUrl(url).scheme())
if QUrl(url).scheme() == 'https':
print('HTTPS')
self.httpsicon.setPixmap(self.pixmap_ssl)
else:
print('HTTP')
self.httpsicon.setPixmap(self.pixmap_nossl)
print(f'Browse to this URL: {url}')
if isinstance(url, str) and url != '':
self.webpage.setUrl(QUrl(url))
def selectFile(self, index):
''' Select a file in file system '''
if not self.fileModel.isDir(index) and index.data().lower().endswith(
('.html', '.txt')):
with open(self.fileModel.fileInfo(index).absoluteFilePath(),
'r',
encoding='utf-8') as f:
self.webpage.setHtml(f.read())
else:
print('Can not read this file...')
def initUI(self):
''' Configuration of widgets '''
self.gLayoutBrowser.addWidget(self.browser)
self.loadingAnimation = QMovie('loading.gif')
self.loadingAnimation.setScaledSize(QtCore.QSize(24, 24))
self.labelLoading.setMovie(self.loadingAnimation)
self.labelLoading.setVisible(False)
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath(QtCore.QDir.currentPath())
self.fileView.setModel(self.fileModel)
self.fileModel.setNameFilters(('.html', '.txt'))
self.fileView.setColumnWidth(0, 170)
self.fileView.setColumnWidth(1, 50)
self.fileView.setColumnWidth(2, 50)
self.splitterMain.setStretchFactor(1, 3)
self.splitterSidebar.setStretchFactor(0, 1)
self.urlBar.setPlaceholderText('Tapez ici votre URL')
self.loadPage(online=True)
self.pixmap_ssl = QPixmap(os.path.join('static/button',
'lock-ssl.png'))
self.pixmap_nossl = QPixmap(
os.path.join('static/button', 'lock-nossl.png'))
print(f'w: {self.pixmap_ssl.width()} | h: {self.pixmap_ssl.height()}')
self.httpsicon.setPixmap(self.pixmap_nossl)
self.setGeometry(300, 300, 1280, 720)
self.updateTitle()
# self.codeEdit = TxtInput([QPushButton('Hello'), QPushButton('World')])
# self.editor = CustomTextEditor(txtInput=self.codeEdit)
self.codeEdit = QPlainTextEdit()
self.splitterSidebar.addWidget(self.codeEdit)
self.show()
def loadPage(self, online=True):
''' Load home page '''
if online:
self.browser.setUrl(QUrl("https://www.google.com"))
return
with open('home.html', 'r') as f:
html = f.read()
self.browser.setHtml(html)
def updateTitle(self):
title = self.browser.page().title()
self.setWindowTitle(f'{title}')
def set_current_html(self, html):
page = QWebEnginePage(self.parent)
page.setHtml(html)
self.setPage(page)
self.update()
qApp.processEvents()
class POSM(QMainWindow):
def __init__(self):
super().__init__()
self.setLocale(QLocale(QLocale.English))
self.initUI()
self.setAttribute(Qt.WA_AlwaysShowToolTips)
sizegrip = QtWidgets.QSizeGrip(self)
self.layout.addWidget(sizegrip, 0,
QtCore.Qt.AlignBottom | QtCore.Qt.AlignRight)
self.record = [None]
recordAction = QAction(datetime.datetime.now().strftime('%H:%M:%S'),
self)
recordAction.triggered.connect(lambda: self.changeMap(0))
self.recordMenu.addAction(recordAction)
def initUI(self):
self.layout = QHBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.console = InformationalConsole(app)
self.horSplitter = QSplitter(Qt.Horizontal)
self.horSplitter.setChildrenCollapsible(False)
self.editionSplitter = QSplitter(Qt.Vertical)
self.editionSplitter.setChildrenCollapsible(False)
self.queryUI = QueryUI()
self.queryUI.setOnRequestChanged(self.changeCurrentMap)
self.editionSplitter.addWidget(self.queryUI)
self.queryWidget = QWidget()
self.queryWidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Maximum)
self.queryWidget.setLayout(QVBoxLayout())
self.queryWidget.layout().setContentsMargins(0, 0, 0, 0)
self.queryWidget.layout().setSpacing(0)
self.queryHeader = QLabel("Query")
self.queryHeader.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.queryHeader.setFixedHeight(self.queryHeader.sizeHint().height() +
10)
self.queryHeader.setContentsMargins(5, 5, 0, 5)
self.queryWidget.layout().addWidget(self.queryHeader)
self.queryText = CodeEditor()
self.qlHighlighter = OverpassQLHighlighter(self.queryText.document())
self.queryText.setReadOnly(True)
self.queryWidget.layout().addWidget(self.queryText)
self.editionSplitter.addWidget(self.queryWidget)
self.horSplitter.addWidget(self.editionSplitter)
self.emptyMapPage = QWebEnginePage()
self.emptyMapPage.setHtml(EMPTY_HTML)
self.manualModePage = QWebEnginePage()
soup = bs4.BeautifulSoup(EMPTY_HTML, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
self.mapRenderer = QWebEngineView()
self.mapRenderer.setMinimumWidth(500)
self.mapRenderer.setPage(self.emptyMapPage)
self.consoleSplitter = QSplitter(Qt.Vertical)
self.consoleSplitter.setChildrenCollapsible(False)
self.consoleSplitter.addWidget(self.mapRenderer)
self.consoleWidget = QWidget()
self.consoleWidget.setLayout(QVBoxLayout())
self.consoleWidget.layout().setContentsMargins(0, 0, 0, 0)
self.consoleWidget.layout().setSpacing(0)
self.consoleHeader = QLabel("Console")
self.consoleHeader.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.consoleHeader.setContentsMargins(5, 5, 0, 5)
self.consoleWidget.layout().addWidget(self.consoleHeader)
self.consoleWidget.layout().addWidget(self.console)
self.consoleSplitter.addWidget(self.consoleWidget)
self.horSplitter.addWidget(self.consoleSplitter)
self.layout.addWidget(self.horSplitter)
self.initMenuBar()
centralWidget = QWidget(self)
centralWidget.setLayout(self.layout)
self.setCentralWidget(centralWidget)
self.setWindowTitle('Python Open Street Map')
def initMenuBar(self):
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
openAct = QAction('Open netedit', self)
openAct.triggered.connect(self.openNet)
fileMenu.addAction(openAct)
saveMenu = fileMenu.addMenu("Save")
saveOutputAct = QAction('output', self)
saveOutputAct.triggered.connect(self.saveNet)
saveOutputAct.setShortcut('Ctrl+S')
saveMenu.addAction(saveOutputAct)
saveQueryAct = QAction('query', self)
saveQueryAct.triggered.connect(self.saveQuery)
saveQueryAct.setShortcut('Ctrl+Shift+S')
saveMenu.addAction(saveQueryAct)
saveInteractiveModeAct = QAction('interactive mode', self)
saveInteractiveModeAct.triggered.connect(self.saveInteractiveQuery)
saveMenu.addAction(saveInteractiveModeAct)
openMenu = fileMenu.addMenu("Open")
openQuery = QAction('query', self)
openQuery.triggered.connect(self.openQuery)
openQuery.setShortcut('Ctrl+O')
openMenu.addAction(openQuery)
openInteractiveMode = QAction('interactive mode', self)
openInteractiveMode.triggered.connect(self.openInteractiveQuery)
openMenu.addAction(openInteractiveMode)
self.recordMenu = openMenu.addMenu("record")
runMenu = menubar.addMenu('Run')
playAct = QAction('Play', self)
playAct.triggered.connect(self.playQuery)
playAct.setShortcut('Ctrl+P')
runMenu.addAction(playAct)
playTableRowAct = QAction('Play row selection', self)
playTableRowAct.triggered.connect(self.playTableRow)
playTableRowAct.setShortcut('Ctrl+T')
runMenu.addAction(playTableRowAct)
self.requestMenu = menubar.addMenu('Request')
addRequestAct = QAction('Add request', self)
addRequestAct.triggered.connect(lambda b: self.addRequest())
addRequestAct.setShortcut('Ctrl+A')
self.requestMenu.addAction(addRequestAct)
templatesMenu = self.requestMenu.addMenu("Add template")
addRoadAct = QAction('Roads', self)
addRoadAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("highway", TagComparison.EQUAL, "", False, True),
OverpassFilter("name", TagComparison.EQUAL, "", False, True),
OverpassFilter("ref", TagComparison.EQUAL, "", False, True),
OverpassFilter("maxspeed", TagComparison.AT_MOST, "120", False,
False),
OverpassFilter("lanes", TagComparison.EQUAL, "", False, True),
OverpassFilter("oneway", TagComparison.EQUAL, "", False, True)
]))
templatesMenu.addAction(addRoadAct)
addMainRoadAct = QAction('Main roads', self)
mainHighways = "^(motorway|trunk|primary|secondary|residential)(_link)?$"
everythingButYes = "^(y(e([^s]|$|s.)|[^e]|$)|[^y]|$).*"
addMainRoadAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("highway", TagComparison.EQUAL, mainHighways, False,
False),
OverpassFilter("construction", TagComparison.HAS_NOT_KEY, "",
False, False),
OverpassFilter("noexit", TagComparison.EQUAL, "yes", True, True),
OverpassFilter("access", TagComparison.EQUAL, everythingButYes,
True, False)
]))
templatesMenu.addAction(addMainRoadAct)
addParkingAct = QAction('Parking', self)
addParkingAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("service", TagComparison.EQUAL, "parking", False,
False),
OverpassFilter("highway", TagComparison.HAS_KEY, "", False, True)
]))
templatesMenu.addAction(addParkingAct)
addPedestriansAct = QAction('Pedestrians', self)
pedestrianHighway = [
"pedestrian", "footway", "path", "cycleway", "bridleway", "steps",
"crossing"
]
addPedestriansAct.triggered.connect(lambda: self.addTemplate([
OverpassFilter("highway", TagComparison.IS_ONE_OF,
pedestrianHighway, False, True)
]))
templatesMenu.addAction(addPedestriansAct)
removeRequestAct = QAction('Remove current request', self)
removeRequestAct.triggered.connect(self.removeRequest)
removeRequestAct.setShortcut('Ctrl+R')
self.requestMenu.addAction(removeRequestAct)
self.manualModeAct = QAction(
'Switch between interactive and manual mode', self)
self.manualModeAct.triggered.connect(self.switchManualMode)
self.requestMenu.addAction(self.manualModeAct)
self.manualModeMenu = menubar.addMenu('Manual mode')
self.manualModeMenu.setEnabled(False)
manualModeCleanPolygonAct = QAction('Clean polygon', self)
manualModeCleanPolygonAct.triggered.connect(
self.cleanManualModePolygon)
self.manualModeMenu.addAction(manualModeCleanPolygonAct)
manualModeGetPolygonAct = QAction('Polygon coordinates', self)
manualModeGetPolygonAct.triggered.connect(
lambda: self.manualModePage.runJavaScript(
"getPolygons();", self.logManualModePolygonCoords))
self.manualModeMenu.addAction(manualModeGetPolygonAct)
windowsMenu = menubar.addMenu('Windows')
cleanMapAct = QAction('Clean map', self)
cleanMapAct.triggered.connect(self.cleanMap)
windowsMenu.addAction(cleanMapAct)
self.showHideInteractiveModeAct = QAction('Interactive mode', self)
self.showHideInteractiveModeAct.triggered.connect(
self.showHideInteractiveMode)
windowsMenu.addAction(self.showHideInteractiveModeAct)
showHideConsole = QAction('Console', self)
showHideConsole.triggered.connect(self.showHideConsole)
windowsMenu.addAction(showHideConsole)
showHideQuery = QAction('Query', self)
showHideQuery.triggered.connect(self.showHideQuery)
windowsMenu.addAction(showHideQuery)
# ACTIONS
def cleanMap(self):
if self.queryText.isReadOnly():
if self.queryUI.getCurrentMap() is not None:
self.mapRenderer.setPage(self.queryUI.updateMaps(EMPTY_HTML))
else:
soup = bs4.BeautifulSoup(EMPTY_HTML, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
logging.info("Cleaning map")
def changeMap(self, i):
if i == 0:
if not self.queryText.isReadOnly():
self.switchManualMode()
if self.queryText.isReadOnly():
self.queryUI.reset()
self.queryText.clear()
self.mapRenderer.setPage(self.emptyMapPage)
self.queryUI.updateMaps(EMPTY_HTML)
elif self.record[i]["interactiveMode"]:
if not self.queryText.isReadOnly():
self.switchManualMode()
if self.queryText.isReadOnly():
self.queryUI.setQuery(self.record[i]["query"])
self.queryText.setPlainText(self.record[i]["query"].getQL())
self.mapRenderer.setPage(
self.queryUI.updateMaps(self.record[i]["html"]))
else:
if self.queryText.isReadOnly():
self.switchManualMode()
if not self.queryText.isReadOnly():
self.queryUI.reset()
self.queryText.setPlainText(self.record[i]["query"])
self.manualModePage.setHtml(self.record[i]["html"])
self.mapRenderer.setPage(self.manualModePage)
def logManualModePolygonCoords(self, coords):
coordsString = " ".join([str(c) for point in coords for c in point])
logging.info("Polygon coordinates:\"{}\"".format(coordsString))
pyperclip.copy(coordsString)
logging.debug("LINE")
def cleanManualModePolygon(self):
logging.info("Cleaning polygon.")
self.manualModePage.runJavaScript(
"cleanPolygon();", lambda returnValue: logging.debug("LINE"))
def showHideInteractiveMode(self):
if self.queryUI.isHidden():
if self.editionSplitter.isHidden():
self.editionSplitter.show()
self.queryText.hide()
self.queryUI.show()
logging.info("Showing 'Interactive mode' window.")
else:
if self.queryText.isHidden():
self.editionSplitter.hide()
self.queryUI.hide()
logging.info("Hiding 'Interactive mode' window.")
logging.debug("LINE")
def showHideConsole(self):
if self.console.isHidden():
self.console.show()
logging.info("Showing 'Console' window.")
self.consoleWidget.setMaximumHeight(QWIDGETSIZE_MAX)
else:
self.console.hide()
self.consoleWidget.setMaximumHeight(
self.queryHeader.sizeHint().height())
logging.info("Hiding 'Console' window.")
logging.debug("LINE")
def showHideQuery(self):
if self.queryText.isHidden():
if self.editionSplitter.isHidden():
self.editionSplitter.show()
self.queryUI.hide()
self.queryText.show()
logging.info("Showing 'Query' window.")
self.queryWidget.setMaximumHeight(QWIDGETSIZE_MAX)
else:
if self.queryUI.isHidden():
self.editionSplitter.hide()
self.queryText.hide()
self.queryWidget.setMaximumHeight(
self.queryHeader.sizeHint().height())
logging.info("Hiding 'Query' window.")
logging.debug("LINE")
def switchManualMode(self):
if self.queryText.isReadOnly():
reply = QMessageBox.question(
self, "Manual mode",
"Are you sure?\nThe interactive mode will remain as it is now."
)
if reply == QMessageBox.Yes:
self.queryText.setReadOnly(False)
self.queryUI.hide()
for action in self.requestMenu.actions():
action.setEnabled(False)
self.manualModeAct.setEnabled(True)
self.manualModeMenu.setEnabled(True)
self.showHideInteractiveModeAct.setEnabled(False)
self.mapRenderer.setPage(self.manualModePage)
logging.info("Switching to manual mode.")
else:
logging.info(
"'Switch between interactive and manual mode' cancelled.")
else:
reply = QMessageBox.question(
self, "Interactive mode",
"Are you sure?\nThe current query will be removed.")
if reply == QMessageBox.Yes:
try:
self.queryText.clear()
self.queryText.setPlainText(
self.queryUI.getQuery().getQL())
except BadFilterAttributes as e:
logging.error(str(e))
except RuntimeError:
logging.warning("Failed to write query.")
self.queryText.clear()
self.queryText.setPlainText("")
self.queryText.setReadOnly(True)
self.queryUI.show()
for action in self.requestMenu.actions():
action.setEnabled(True)
self.manualModeMenu.setEnabled(False)
self.showHideInteractiveModeAct.setEnabled(True)
self.changeCurrentMap(0)
logging.info("Switching to interactive mode.")
else:
logging.info(
"'Switch between interactive and manual mode' cancelled.")
logging.info("Showing 'manual mode' polygon.")
def addRequest(self, filters=None):
self.queryUI.addRequestByFilters(filters)
logging.info("Request added.")
logging.debug("LINE")
def addTemplate(self, filters):
logging.info("Template applied.")
self.queryUI.addRequestByFilters(filters)
def removeRequest(self):
reply = QMessageBox.question(
self, "Remove current request",
"Are you sure? This option is not undoable.")
if reply == QMessageBox.Yes:
self.queryUI.removeRequest()
logging.info("'Remove request' successfully executed.")
else:
logging.info("'Remove request' cancelled.")
logging.debug("LINE")
def saveQuery(self):
filename, selectedFilter = QFileDialog.getSaveFileName(
self, 'Save query', expanduser("~/filename.txt"),
"Text files (*.txt)")
if filename != "":
if self.queryText.isReadOnly():
try:
query = self.queryUI.getQuery().getQL()
f = open(filename, "w+")
f.seek(0)
f.truncate()
f.write(query)
f.close()
logging.info("Query saved successfully.")
except (RuntimeError, BadFilterAttributes) as e:
logging.error(str(e))
except OSError:
logging.error(
"There was a problem creating the file with the query."
)
else:
try:
f = open(filename, "w+")
f.seek(0)
f.truncate()
f.write(self.queryText.toPlainText())
f.close()
logging.info("Query saved successfully.")
except OSError:
logging.error(
"There was a problem creating the file with the query."
)
else:
logging.info("\"Save query\" canceled.")
logging.debug("LINE")
def openQuery(self):
filename, selectedFilter = QFileDialog.getOpenFileName(
self, 'Open query', expanduser("~/filename.txt"))
if filename != "":
try:
if self.queryText.isReadOnly():
self.switchManualMode()
f = open(filename, "r")
self.queryText.clear()
self.queryText.setPlainText(f.read())
f.close()
logging.info("File read successfully.")
except UnicodeDecodeError:
logging.error("The given file is not readable as text.")
except OSError:
logging.error("There was a problem opening the query file.")
else:
logging.info("\"Open query\" canceled.")
logging.debug("LINE")
def saveInteractiveQuery(self):
filename, selectedFilter = QFileDialog.getSaveFileName(
self, 'Save query', expanduser("~/filename.json"),
"JSON files (*.json)")
if filename != "":
try:
query = self.queryUI.getQuery()
query.saveToFile(filename)
logging.info("Query saved successfully.")
except (RuntimeError, BadFilterAttributes) as e:
logging.error(str(e))
except OSError:
logging.error(
"There was a problem creating the file with the query.")
else:
logging.info("\"Save query\" canceled.")
logging.debug("LINE")
def openInteractiveQuery(self):
filename, selectedFilter = QFileDialog.getOpenFileName(
self, 'Open query', expanduser("~/filename.json"))
if filename != "":
try:
self.queryUI.setQuery(OverpassQuery.getFromFile(filename))
if not self.queryText.isReadOnly():
self.switchManualMode()
except json.decoder.JSONDecodeError:
logging.error(
"The given file has not the right format (json). The file could not be opened."
)
except UnicodeDecodeError:
logging.error(
"The given file is not readable as text. The file could not be opened."
)
except (TypeError, KeyError):
logging.error(
"Fields are missing from the file or there are fields with the wrong data type. "
"The file could not be opened.")
except OSError:
logging.error(
"There was a problem opening the query file. The file could not be opened."
)
else:
logging.info("\"Open query\" canceled.")
logging.debug("LINE")
def saveNet(self):
filename, selectedFilter = QFileDialog.getSaveFileName(
self, 'Save File', expanduser("~/filenameWithoutExtension"))
if filename != "":
buildNet(filename)
else:
logging.info("\"Save File\" canceled.")
logging.debug("LINE")
return filename
def openNet(self):
try:
filename = self.saveNet()
if filename == "":
logging.error("Can't open NETEDIT without a file.")
else:
openNetedit(filename + ".net.xml")
logging.info("Opening NETEDIT.")
logging.warning(
"If NETEDIT is not open in ten seconds, there was an unhandled problem."
)
logging.debug("LINE")
except OSError:
logging.error("Can't find NETEDIT.")
except Exception:
logging.error(traceback.format_exc())
# POLYGONS
def changeCurrentMap(self, i):
if self.queryUI.getCurrentMap() is None:
self.mapRenderer.setPage(self.emptyMapPage)
else:
self.mapRenderer.setPage(self.queryUI.getCurrentMap())
def playQuery(self):
newRecord = {
"interactiveMode": self.queryText.isReadOnly(),
"query": self.queryText.toPlainText(),
"html": ""
}
if self.queryText.isReadOnly():
try:
query = self.queryUI.getQuery()
newRecord["query"] = query
self.queryText.setPlainText(query.getQL())
except (RuntimeError, BadFilterAttributes) as e:
logging.error(str(e))
return
try:
html = buildHTMLWithQuery(self.queryText.toPlainText())
if self.queryText.isReadOnly():
self.mapRenderer.setPage(self.queryUI.updateMaps(html))
newRecord["html"] = html
else:
soup = bs4.BeautifulSoup(html, features="html.parser")
js = soup.new_tag("script")
js.string = (MANUAL_MODE_JS_SCRIPT % (str([])))
soup.append(js)
self.manualModePage.setHtml(str(soup))
newRecord["html"] = str(soup)
self.mapRenderer.setPage(self.manualModePage)
logging.info("Query drawn.")
logging.debug("LINE")
self.addRecord(newRecord)
except (OverpassRequestException, OsmnxException) as e:
logging.error(str(e))
except ox.EmptyOverpassResponse:
logging.error("There are no elements with the given query.")
except OSError:
logging.error(
"There was a problem creating the file with the request response."
)
except Exception:
logging.error(traceback.format_exc())
def addRecord(self, newRecord):
self.record.append(newRecord)
index = len(self.record) - 1
recordAction = QAction(datetime.datetime.now().strftime('%H:%M:%S'),
self)
recordAction.triggered.connect(lambda: self.changeMap(index))
self.recordMenu.addAction(recordAction)
def playTableRow(self):
try:
self.mapRenderer.setPage(self.queryUI.updateMapFromRow())
except (OverpassRequestException, OsmnxException) as e:
logging.error(str(e))
logging.warning(
"Before open NETEDIT you must run a query with the row filters applied."
)
except ox.EmptyOverpassResponse:
logging.error("There are no elements with the given row.")
except OSError:
logging.error(
"There was a problem creating the file with the row selection."
)
except RuntimeError as e:
logging.error(str(e))
except Exception:
logging.error(traceback.format_exc())
logging.debug("LINE")
# EVENTS
def closeEvent(self, event):
for f in os.listdir(tempDir):
os.remove(os.path.join(tempDir, f))
QMainWindow.closeEvent(self, event)
def setHtml(self, contents):
# print("web page setting html to:", contents)
QWebEnginePage.setHtml(self, contents, QtCore.QUrl("file://start"))
