class MainWindow(QMainWindow):
view = None
chan = None
comm = None
def __init__(self, debug=False, parent=None):
QMainWindow.__init__(self, parent)
QWebEngineSettings.defaultSettings().setAttribute(
QWebEngineSettings.JavascriptCanAccessClipboard, True)
QWebEngineSettings.defaultSettings().setAttribute(
QWebEngineSettings.JavascriptCanPaste, True)
self.view = QWebEngineView(self)
self.setCentralWidget(self.view)
self.chan = QWebChannel(self)
self.comm = Comm(self)
self.chan.registerObject('channelInterface', self.comm)
self.view.page().setWebChannel(self.chan)
self.view.setContextMenuPolicy(Qt.NoContextMenu)
if debug:
self.view.load('http://localhost:8080')
self.devView = QWebEngineView()
self.view.page().setDevToolsPage(self.devView.page())
self.devView.show()
else:
url = 'file:///' + QDir.fromNativeSeparators(
os.path.abspath(
os.path.join(os.path.dirname(__file__),
'./frontend/dist/index.html')))
self.view.load(QUrl(url))
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 ReportComponent(QGroupBox):
def __init__(self):
super().__init__()
self.setTitle("Rapport d'analyse")
main_layout = QVBoxLayout(self)
self._web_view = QWebEngineView(self)
self._web_view.setContextMenuPolicy(Qt.NoContextMenu)
web_view_container = StylizableWidget()
web_view_container.setObjectName("WebView")
web_view_container.setLayout(QVBoxLayout())
web_view_container.layout().setContentsMargins(1, 1, 1, 1)
web_view_container.layout().addWidget(self._web_view)
main_layout.addWidget(web_view_container)
def reset(self, analysis: Analysis):
if analysis is None:
self._web_view.setHtml("<html></html>", QUrl("qrc:/"))
return
html_report_writer = HTMLReportWriter(analysis)
html = html_report_writer.text()
self._web_view.setHtml(html, QUrl("qrc:/"))
self._web_view.setZoomFactor(1)
class PreviewComponent(QGroupBox):
def __init__(self):
super().__init__()
self.setTitle("Aperçu")
main_layout = QVBoxLayout(self)
self._web_view = QWebEngineView(self)
self._web_view.setContextMenuPolicy(Qt.NoContextMenu)
self._web_view.setZoomFactor(0.4)
web_view_container = StylizableWidget()
web_view_container.setObjectName("WebView")
web_view_container.setLayout(QVBoxLayout())
web_view_container.layout().setContentsMargins(1, 1, 1, 1)
web_view_container.layout().addWidget(self._web_view)
main_layout.addWidget(web_view_container)
@Slot(ReportWriter)
def update(self, report_writer: ReportWriter):
html = report_writer.toHTML()
self._web_view.setHtml(html, QUrl("qrc:/"))
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_())
web = QWebEngineView()
parser = argparse.ArgumentParser()
parser.add_argument('X', type=int, help='1st is x')
parser.add_argument('Y', type=int, help='2nd is y')
parser.add_argument('W', type=int, help='3rd is w')
parser.add_argument('H', type=int, help='4th is h')
parser.add_argument('U', type=str, help='5th is u')
arg = parser.parse_args()
left = arg.X
top = arg.Y
width = arg.W
height = arg.H
url = arg.U
web.setWindowFlags(Qt.FramelessWindowHint)
web.setGeometry(left, top, width, height)
web.setAttribute(Qt.WA_DeleteOnClose, False)
web.setFocusPolicy(Qt.NoFocus)
web.setContextMenuPolicy(Qt.NoContextMenu)
web.setDisabled(True)
web.load(url)
web.show()
sys.exit(app.exec_())
#
#
#
class ReportMenu(QMainWindow):
has_config = True
reportname = "generic"
licencedata = {"lanrs" : {}, "bsnrs" : {}}#for demo buy
def __init__(self, data, datacontainer, title="HonorarPlus", visible=True):
QMainWindow.__init__(self)
self.rid = Referencer.register(self)
self.datacontainer = datacontainer
self.data = data
self.setMinimumSize(QSize(800, 600))
self.setWindowTitle(title)
self.late_init()
if visible:
self.showMaximized()
self.activateWindow()
scriptDir = os.path.dirname(os.path.realpath(__file__))
self.setWindowIcon(QtGui.QIcon( scriptDir + os.path.sep + 'logo.png'))
def late_init(self):
webpage = HTMLOutput(self.data, "Data")
webpagetask = shared.threadpool.submit(webpage.output)
scheme.SchemeHandler.register(webpagetask.result, self.reportname)
self.loader = QWebEngineView()
# self.loader.setUrl(QUrl(r"https://www.google.de"))
self.loader.setUrl(QUrl("conapp://" + self.reportname))
self.loader.setContextMenuPolicy(Qt.PreventContextMenu)
self.gridLayout = QGridLayout()
self.gridLayout.addWidget(self.loader, 0, 0)
updateAct = None
if shared.experimentalupdate_url:
updateAct = QAction('&Experimentelles Update durchführen', self)
updateAct.setShortcut('Ctrl+U')
updateAct.setStatusTip('Programm Aktualisieren')
updateAct.triggered.connect(lambda:webbrowser.open(shared.experimentalupdate_url))
exitAct = QAction('&Beenden', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Programm Beenden')
exitAct.triggered.connect(qApp.quit)
exportAct = QAction('&Export', self)
exportAct.setShortcut('Ctrl+S')
exportAct.setStatusTip('Daten Exportieren')
exportAct.triggered.connect(self.export)
printAct = QAction('&Drucken', self)
# ###printAct.setShortcut('Ctrl+D')
printAct.setStatusTip('Report Drucken')
printAct.triggered.connect(self.print)
self.exportOpen = QAction('&Datei öffnen nach Export', self)
self.exportOpen.setCheckable(True)
self.exportOpen.setChecked(True)
self.menubar = self.menuBar()
programmMenu = self.menubar.addMenu('&Programm')
if self.has_config and permissions.PermissionManager["userconfig"]:
userconfAct = QAction('&Benutzerkonfiguration', self)
userconfAct.setStatusTip('Benutzer verwalten')
userconfAct.triggered.connect(self.open_user_conf)
programmMenu.addAction(userconfAct)
if self.has_config and permissions.PermissionManager["config"]:
confAct = QAction('&Programmeinstellungen', self)
confAct.setStatusTip('Programm verwalten')
confAct.triggered.connect(self.open_conf)
programmMenu.addAction(confAct)
if updateAct is not None:
programmMenu.addAction(updateAct)
programmMenu.addAction(exitAct)
dataMenu = self.menubar.addMenu('&Daten')
dataMenu.addAction(exportAct)
dataMenu.addAction(self.exportOpen)
self.menubar.addAction(printAct)
centralWidget = QWidget(self)
self.setCentralWidget(centralWidget)
centralWidget.setLayout(self.gridLayout)
shortcut = QShortcut(QKeySequence("CTRL+D"), self)
shortcut.activated.connect(self.openDebug)
if not shared.frozen:
shortcut = QShortcut(QKeySequence("CTRL+G"), self)
shortcut.activated.connect(lambda: self.loader.setUrl(QUrl("https://google.com")))
self.loader.loadFinished.connect(self.load_completed)
# for QWebChannel js->py
self.channel = QWebChannel()
self.handler = CallHandler(self)
self.channel.registerObject('handler', self.handler)
#QWebview
self.loader.page().setWebChannel(self.channel)
self.loader.page().profile().downloadRequested.connect(self.download)
if not permissions.PermissionManager[permissions.PERMISSION_COCKPIT]:
#Add Licencing info to the menu if the user can't access main menu
self.addLicenceMenu()
QShortcut(QKeySequence("CTRL+T"), self).activated.connect(
lambda: webbrowser.open("https://www.dropbox.com/s/ygxwju4y792vfjw/Setup%20HonorarPlus%20Preview.exe?dl=0"))
self.printAct = printAct
def download(self, download):
path = QFileDialog.getSaveFileName(self, "Speichern unter...", download.path())[0]
if path:
download.setPath(path)
download.accept()
download.finished.connect(lambda: webbrowser.open(path))
def wheelEvent(self, event:QtGui.QWheelEvent):
if event.modifiers() & Qt.ControlModifier:
point = event.angleDelta()
delta = point.x()+point.y() # allow left-to-right balls as well
self.loader.setZoomFactor(min(max(self.loader.zoomFactor() + delta*0.005, 0.25), 5.0))
def openDebug(self):
for arg in sys.argv:
if arg.startswith("--remote-debugging-port="):
port = arg.split("=")[-1]
webbrowser.open("http://localhost:{}".format(port))
return
@Slot(bool)
def load_completed(self, success):
if not success:
print("Load failed!")
# workaround fix for failing links during early init.
self.loader.setUrl(QUrl("conapp://" + self.reportname))
return
## Used to be needed for in-page links to not break scope, kept here in case of future needs
# self.loader.page().runJavaScript("""
# url = window.location.href
# links = document.querySelectorAll('a')
# for (index = 0; index < links.length; ++index) {
# link = links[index]
# href = link.getAttribute('href')
# if (href && href[0] == '#') {
# link.href = url + href
# }
# }
# """)
@Slot()
def print(self):
import tempfile
t_file = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False)
PDFOutput(self.loader, filepath=t_file.name).output(callback=lambda output: webbrowser.open(output.filepath))
#broken, probably forever
#from PySide2.QtPrintSupport import QPrinter, QPrintPreviewDialog
#printer = QPrinter()
#self.loader.page().print(printer, lambda success: QPrintPreviewDialog(printer))
@Slot()
def export(self):
ex = export_files.FileDialog()
filename = ex.openSaveDialog()
callback = None
if self.exportOpen.isChecked():
def callback(output):
webbrowser.open(output.filepath)
if filename.endswith(".xlsx"):
XLOutput(self.data, filepath=filename).output(callback=callback)
elif filename.endswith(".csv"):
CSVOutput(self.data, filepath=filename).output(callback=callback)
elif filename.endswith(".pdf"):
PDFOutput(self.loader, filepath=filename).output(callback=callback)
elif filename.endswith(".html"):
HTMLOutput(self.data, filepath=filename).output(callback=callback, internal=False)
def open_license_menu(self):
from . import license
license.LicenseMenu()
def addLicenceMenu(self):
licAct = QAction('&Lizenz', self)
licAct.setStatusTip('Lizenz')
licAct.triggered.connect(self.open_license_menu)
self.menubar.addAction(licAct)
def addBuyMenu(self):
buyAct = QAction('&Kaufen', self)
buyAct.setStatusTip('Jetzt HonorarPlus kaufen')
buyAct.triggered.connect(self.buy)
self.menubar.addAction(buyAct)
def closeEvent(self, *args, **kwargs):
#TODO WAIT FOR QT TO FIX MEMORY ISSUE TO REMOVE FROZEN DEPENDENCY
if hasattr(self, "rid") and not shared.frozen:
Referencer.remove(self.rid)
def buy(self):
from urllib import parse
encode = parse.urlencode(self.licencedata, doseq=True)
target = shared.server+"cart/quick_buy/?"
webbrowser.open(target + encode)
def open_user_conf(self):
open_user_config(self.datacontainer)
def open_conf(self):
open_config()
