Debian Codegraph @

tests/android/webview/platforms/qt.py

raw
1 import json
2 import logging
3 import os
4 import platform
5 import signal
6 import socket
7 import sys
8 import webbrowser
9 from copy import copy, deepcopy
10 from functools import partial
11 from threading import Event, Semaphore, Thread
12 from uuid import uuid1
13
14 from qtpy import PYQT6, PYSIDE6, QtCore
15 from qtpy.QtCore import QByteArray, QJsonValue
16 from qtpy.QtGui import QColor, QIcon, QScreen
17 from qtpy.QtWidgets import QAction, QApplication, QFileDialog, QMainWindow, QMenuBar, QMessageBox
18
19 from webview import FileDialog, _state, settings, windows
20 from webview.dom import _dnd_state
21 from webview.menu import Menu, MenuAction, MenuSeparator
22 from webview.models import Request
23 from webview.screen import Screen
24 from webview.util import (
25 DEFAULT_HTML,
26 create_cookie,
27 environ_append,
28 inject_pywebview,
29 js_bridge_call,
30 )
31 from webview.window import FixPoint, Window
32
33 try:
34 from qtpy.QtNetwork import QSslCertificate, QSslConfiguration
35 from qtpy.QtWebChannel import QWebChannel
36 from qtpy.QtWebEngineCore import QWebEngineUrlRequestInterceptor
37 from qtpy.QtWebEngineWidgets import QWebEnginePage as QWebPage
38 from qtpy.QtWebEngineWidgets import QWebEngineProfile, QWebEngineSettings
39 from qtpy.QtWebEngineWidgets import QWebEngineView as QWebView
40
41 renderer = 'qtwebengine'
42 is_webengine = True
43 except ImportError:
44 from PyQt5.QtNetwork import QSslCertificate, QSslConfiguration
45 from PyQt5.QtWebKitWidgets import QWebPage, QWebView
46
47 is_webengine = False
48 renderer = 'qtwebkit'
49
50 logger = logging.getLogger('pywebview')
51 logger.debug(f'Using Qt {QtCore.__version__}')
52
53 if is_webengine and QtCore.QSysInfo.productType() in ['arch', 'manjaro', 'nixos', 'rhel', 'pop']:
54 # I don't know why, but it's a common solution for #890 (White screen displayed)
55 # such as:
56 # - https://github.com/LCA-ActivityBrowser/activity-browser/pull/954/files
57 # - https://bugs.archlinux.org/task/73957
58 # - https://www.google.com/search?q=arch+rstudio+no+sandbox
59 # And sometimes it needs two "--no-sandbox" flags
60
61 environ_append('QTWEBENGINE_CHROMIUM_FLAGS', '--no-sandbox', '--no-sandbox')
62 logger.debug('Enable --no-sandbox flag for arch/manjaro/nixos')
63
64 _app_menu = None
65 _main_window_created = Event()
66 _main_window_created.clear()
67
68 # suppress invalid style override error message on some Linux distros
69 os.environ['QT_STYLE_OVERRIDE'] = ''
70 _qt6 = True if PYQT6 or PYSIDE6 else False
71 _profile_storage_path = _state['storage_path'] or os.path.join(
72 os.path.expanduser('~'), '.pywebview'
73 )
74
75
76 def _sigint_handler(signum, frame):
77 """
78 Handler for SIGINT signal (Ctrl+C).
79
80 Qt applications don't handle SIGINT by default because Python signal handlers
81 can only be called when the Python interpreter is running. Since the Qt event
82 loop runs in C++, signals are noted but handlers aren't called until Python
83 code executes. The timer in create_window() ensures the Python interpreter
84 runs periodically to process pending signals.
85
86 See: https://stackoverflow.com/a/4939113
87 """
88 global _app
89 if _app:
90 _app.quit()
91
92
93 class BrowserView(QMainWindow):
94 instances = {}
95 inspector_port = None # The localhost port at which the Remote debugger listens
96
97 global_menubar_other_objects = []
98 global_menubar_top_menus = []
99
100 create_window_trigger = QtCore.Signal(object)
101 set_title_trigger = QtCore.Signal(str)
102 load_url_trigger = QtCore.Signal(str)
103 html_trigger = QtCore.Signal(str, str)
104 confirmation_dialog_trigger = QtCore.Signal(str, str, str)
105 file_dialog_trigger = QtCore.Signal(int, str, bool, str, str)
106 destroy_trigger = QtCore.Signal()
107 hide_trigger = QtCore.Signal()
108 show_trigger = QtCore.Signal()
109 fullscreen_trigger = QtCore.Signal()
110 window_size_trigger = QtCore.Signal(int, int, FixPoint)
111 window_move_trigger = QtCore.Signal(int, int)
112 window_maximize_trigger = QtCore.Signal()
113 window_minimize_trigger = QtCore.Signal()
114 window_restore_trigger = QtCore.Signal()
115 current_url_trigger = QtCore.Signal()
116 evaluate_js_trigger = QtCore.Signal(str, str)
117 on_top_trigger = QtCore.Signal(bool)
118
119 class JSBridge(QtCore.QObject):
120 qtype = QtCore.QJsonValue if is_webengine else str
121
122 def __init__(self, parent):
123 super(BrowserView.JSBridge, self).__init__()
124 self._parent = parent
125 self.window = parent.pywebview_window
126
127 @QtCore.Slot(str, qtype, str, result=str)
128 def call(self, func_name, param, value_id):
129 func_name = BrowserView._convert_string(func_name)
130 param = BrowserView._convert_string(param)
131
132 if func_name == '_pywebviewAlert':
133 QMessageBox.information(self._parent, 'Message', str(param))
134 else:
135 return js_bridge_call(self.window, func_name, json.loads(param), value_id)
136
137 class WebView(QWebView):
138 def __init__(self, parent=None):
139 super(BrowserView.WebView, self).__init__(parent)
140
141 if parent.frameless and parent.easy_drag:
142 QApplication.instance().installEventFilter(self)
143 self.setMouseTracking(True)
144
145 self.transparent = parent.transparent
146 if parent.transparent:
147 self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
148 self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent, False)
149 self.setStyleSheet('background: transparent;')
150
151 def contextMenuEvent(self, event):
152 if _qt6:
153 menu = self.createStandardContextMenu()
154 else:
155 menu = self.page().createStandardContextMenu()
156
157 # If 'Inspect Element' is present in the default context menu, it
158 # means the inspector is already up and running.
159 for i in menu.actions():
160 if i.text() == 'Inspect Element':
161 break
162 else:
163 # Inspector is not up yet, so create a pseudo 'Inspect Element'
164 # menu that will fire it up.
165 inspect_element = QAction('Inspect Element', menu)
166 inspect_element.triggered.connect(self.show_inspector)
167 menu.addAction(inspect_element)
168
169 menu.exec_(event.globalPos())
170
171 def dragEnterEvent(self, e):
172 if e.mimeData().hasUrls and _dnd_state['num_listeners'] > 0:
173 e.acceptProposedAction()
174
175 return super().dragEnterEvent(e)
176
177 def dragMoveEvent(self, e):
178 if e.mimeData().hasUrls and _dnd_state['num_listeners'] > 0:
179 e.acceptProposedAction()
180
181 return super().dragMoveEvent(e)
182
183 def dropEvent(self, e):
184 if e.mimeData().hasUrls and _dnd_state['num_listeners'] > 0:
185 files = [
186 (os.path.basename(value.toString()), value.toString().replace('file://', ''))
187 for value in e.mimeData().urls()
188 if value.toString().startswith('file://')
189 ]
190 _dnd_state['paths'] += files
191
192 return super().dropEvent(e)
193
194 # Create a new webview window pointing at the Remote debugger server
195 def show_inspector(self):
196 uid = self.parent().uid + '-inspector'
197 try:
198 # If inspector already exists, bring it to the front
199 BrowserView.instances[uid].raise_()
200 BrowserView.instances[uid].activateWindow()
201 except KeyError:
202 title = f'Web Inspector - {self.parent().title}'
203 url = f'http://localhost:{BrowserView.inspector_port}'
204 window = Window('web_inspector', title, url, '', 700, 500)
205 window.localization = self.parent().localization
206
207 inspector = BrowserView(window)
208 inspector.show()
209
210 def mousePressEvent(self, event):
211 if event.button() == QtCore.Qt.LeftButton:
212 self.drag_pos = event.globalPos() - self.parent().frameGeometry().topLeft()
213
214 event.accept()
215
216 def mouseMoveEvent(self, event):
217 parent = self.parent()
218 if (
219 parent.frameless and parent.easy_drag and event.buttons() & QtCore.Qt.LeftButton
220 ): # left button is pressed
221 parent.move(event.globalPos() - self.drag_pos)
222
223 def eventFilter(self, object, event):
224 if object.parent() == self:
225 if event.type() == QtCore.QEvent.MouseMove:
226 self.mouseMoveEvent(event)
227 elif event.type() == QtCore.QEvent.MouseButtonPress:
228 self.mousePressEvent(event)
229
230 return False
231
232 class RequestInterceptor(QWebEngineUrlRequestInterceptor):
233 def __init__(self, window):
234 super().__init__()
235 self.window = window
236
237 def interceptRequest(self, info):
238 if len(self.window.events.request_sent) == 0:
239 return
240
241 url = info.requestUrl().toString()
242 method = info.requestMethod()
243
244 if 'httpHeaders' in dir(info):
245 headers = {
246 k.data().decode('utf-8'): k.data().decode('utf-8')
247 for k, v in info.httpHeaders().items()
248 }
249 else:
250 headers = {}
251
252 request = Request(url, method, headers)
253 self.window.events.request_sent.set(request)
254
255 if request.headers != headers:
256 for key, value in request.headers.items():
257 info.setHttpHeader(
258 QByteArray(key.encode('utf-8')), QByteArray(value.encode('utf-8'))
259 )
260
261 # New-window-requests handler for Qt 5.5+ only
262 class NavigationHandler(QWebPage):
263 def __init__(self, page):
264 super().__init__(page.profile())
265 self._parent = page.parent
266
267 def acceptNavigationRequest(self, url, type, is_main_frame):
268 if settings['OPEN_EXTERNAL_LINKS_IN_BROWSER']:
269 webbrowser.open(url.toString(), 2, True)
270 return False
271 else:
272 self._parent.load_url(url.toString())
273 return True
274
275 class WebPage(QWebPage):
276 def __init__(self, parent=None, profile=None):
277 if is_webengine and profile:
278 super(BrowserView.WebPage, self).__init__(profile, parent.webview)
279 else:
280 super(BrowserView.WebPage, self).__init__(parent.webview)
281
282 if is_webengine:
283 self.featurePermissionRequested.connect(self.onFeaturePermissionRequested)
284 self.nav_handler = BrowserView.NavigationHandler(self)
285 else:
286 self.nav_handler = None
287
288 if parent.transparent:
289 self.setBackgroundColor(QtCore.Qt.transparent)
290
291 if is_webengine:
292
293 def onFeaturePermissionRequested(self, url, feature):
294 if feature in (
295 QWebPage.Feature.MediaAudioCapture,
296 QWebPage.Feature.MediaVideoCapture,
297 QWebPage.Feature.MediaAudioVideoCapture,
298 ):
299 self.setFeaturePermission(url, feature, 1) # QWebPage.PermissionGrantedByUser
300 else:
301 self.setFeaturePermission(url, feature, 2) # QWebPage.PermissionDeniedByUser
302 else:
303
304 def acceptNavigationRequest(self, frame, request, type):
305 if frame is None:
306 webbrowser.open(request.url().toString(), 2, True)
307 return False
308 return True
309
310 def userAgentForUrl(self, url):
311 user_agent = _state['user_agent']
312 if user_agent:
313 return user_agent
314 else:
315 return super().userAgentForUrl(url)
316
317 def createWindow(self, type):
318 return self.nav_handler
319
320 def __init__(self, window):
321 super().__init__()
322 BrowserView.instances[window.uid] = self
323 self.uid = window.uid
324 self.pywebview_window = window
325 self.pywebview_window.native = self
326
327 self.js_bridge = BrowserView.JSBridge(self)
328
329 self.is_fullscreen = False
330
331 self._file_name_semaphore = Semaphore(0)
332 self._current_url_semaphore = Semaphore(0)
333
334 self.localization = window.localization
335
336 if window.screen:
337 if _qt6:
338 self.screen = QScreen.geometry(window.screen.frame)
339 else:
340 self.screen = window.screen.frame.geometry()
341 else:
342 if _qt6:
343 self.screen = QScreen.geometry(QApplication.primaryScreen())
344 else:
345 self.screen = QApplication.primaryScreen().geometry()
346
347 self._js_results = {}
348 self._current_url = None
349 self._file_name = None
350 self._confirmation_dialog_results = {}
351
352 self.resize(window.initial_width, window.initial_height)
353 self.title = window.title
354 self.setWindowTitle(window.title)
355
356 # Set window background color
357 self.background_color = QColor()
358 self.background_color.setNamedColor(window.background_color)
359 palette = self.palette()
360 palette.setColor(self.backgroundRole(), self.background_color)
361 self.setPalette(palette)
362
363 if not window.resizable:
364 self.setFixedSize(window.initial_width, window.initial_height)
365
366 self.setMinimumSize(window.min_size[0], window.min_size[1])
367
368 self.frameless = window.frameless
369 self.easy_drag = window.easy_drag
370 flags = self.windowFlags()
371 if self.frameless:
372 flags = flags | QtCore.Qt.FramelessWindowHint
373
374 if window.on_top:
375 flags = flags | QtCore.Qt.WindowStaysOnTopHint
376
377 if not window.focus:
378 self.setAttribute(QtCore.Qt.WA_ShowWithoutActivating)
379 flags = flags | QtCore.Qt.WindowDoesNotAcceptFocus
380
381 self.setWindowFlags(flags)
382 self.setAcceptDrops(True)
383
384 self.transparent = window.transparent
385 if self.transparent:
386 # Override the background color
387 self.background_color = QColor('transparent')
388 palette = self.palette()
389 palette.setColor(self.backgroundRole(), self.background_color)
390 self.setPalette(palette)
391 # Enable the transparency hint
392 self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
393
394 self.webview = BrowserView.WebView(self)
395
396 if is_webengine:
397 environ_append(
398 'QTWEBENGINE_CHROMIUM_FLAGS',
399 '--use-fake-ui-for-media-stream',
400 '--enable-features=AutoplayIgnoreWebAudio',
401 )
402
403 if _state['debug'] and is_webengine:
404 # Initialise Remote debugging (need to be done only once)
405 if not BrowserView.inspector_port:
406 BrowserView.inspector_port = BrowserView._get_debug_port()
407 os.environ['QTWEBENGINE_REMOTE_DEBUGGING'] = BrowserView.inspector_port
408 else:
409 self.webview.setContextMenuPolicy(
410 QtCore.Qt.NoContextMenu
411 ) # disable right click context menu
412
413 self.cookies = {}
414
415 if is_webengine:
416 self.request_interceptor = BrowserView.RequestInterceptor(self.pywebview_window)
417
418 if _state['private_mode']:
419 self.profile = QWebEngineProfile()
420 else:
421 self.profile = QWebEngineProfile('pywebview')
422 self.profile.setPersistentStoragePath(_profile_storage_path)
423
424 user_agent = _state['user_agent']
425 if user_agent:
426 self.profile.setHttpUserAgent(user_agent)
427
428 cookie_store = self.profile.cookieStore()
429 cookie_store.cookieAdded.connect(self.on_cookie_added)
430 cookie_store.cookieRemoved.connect(self.on_cookie_removed)
431
432 self.profile.setUrlRequestInterceptor(self.request_interceptor)
433 self.webview.setPage(BrowserView.WebPage(self, profile=self.profile))
434 elif not is_webengine and not _state['private_mode']:
435 logger.warning('qtwebkit does not support private_mode')
436
437 user_agent = _state['user_agent']
438 # if user_agent and is_webengine:
439 # self.profile.setHttpUserAgent(user_agent)
440
441 if is_webengine:
442 self.profile.settings().setAttribute(
443 QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls,
444 settings['ALLOW_FILE_URLS'],
445 )
446
447 self.webview.page().loadFinished.connect(self.on_load_finished)
448
449 if settings['ALLOW_DOWNLOADS']:
450 self.webview.page().profile().downloadRequested.connect(self.on_download_requested)
451
452 self.setCentralWidget(self.webview)
453
454 self.create_window_trigger.connect(BrowserView.on_create_window)
455 self.load_url_trigger.connect(self.on_load_url)
456 self.html_trigger.connect(self.on_load_html)
457 self.confirmation_dialog_trigger.connect(self.on_confirmation_dialog)
458 self.file_dialog_trigger.connect(self.on_file_dialog)
459 self.destroy_trigger.connect(self.on_destroy_window)
460 self.show_trigger.connect(self.on_show_window)
461 self.hide_trigger.connect(self.on_hide_window)
462 self.fullscreen_trigger.connect(self.on_fullscreen)
463 self.window_size_trigger.connect(self.on_window_size)
464 self.window_move_trigger.connect(self.on_window_move)
465 self.window_maximize_trigger.connect(self.on_window_maximize)
466 self.window_minimize_trigger.connect(self.on_window_minimize)
467 self.window_restore_trigger.connect(self.on_window_restore)
468 self.current_url_trigger.connect(self.on_current_url)
469 self.evaluate_js_trigger.connect(self.on_evaluate_js)
470 self.set_title_trigger.connect(self.on_set_title)
471 self.on_top_trigger.connect(self.on_set_on_top)
472
473 if is_webengine and platform.system() != 'OpenBSD':
474 self.channel = QWebChannel(self.webview.page())
475 self.webview.page().setWebChannel(self.channel)
476
477 if window.fullscreen:
478 self.toggle_fullscreen()
479
480 if window.real_url is not None:
481 self.webview.setUrl(QtCore.QUrl(window.real_url))
482 elif window.uid == 'web_inspector':
483 self.webview.setUrl(QtCore.QUrl(window.original_url))
484 elif window.html:
485 self.webview.setHtml(window.html, QtCore.QUrl(''))
486 else:
487 self.webview.setHtml(DEFAULT_HTML, QtCore.QUrl(''))
488
489 if window.initial_x is not None and window.initial_y is not None:
490 self.move(self.screen.x() + window.initial_x, self.screen.y() + window.initial_y)
491 else:
492 offset = -16 if _qt6 else 0
493 center = self.screen.center() - self.rect().center()
494 self.move(center.x(), center.y() + offset)
495
496 if not window.minimized:
497 self.activateWindow()
498 self.raise_()
499
500 if _state['icon']:
501 icon = QIcon(_state['icon'])
502 self.setWindowIcon(icon)
503
504 self.pywebview_window.events.before_show.set()
505
506 def on_set_title(self, title):
507 self.setWindowTitle(title)
508
509 def on_confirmation_dialog(self, title, message, uuid):
510 uuid_ = BrowserView._convert_string(uuid)
511 reply = QMessageBox.question(self, title, message, QMessageBox.Cancel, QMessageBox.Ok)
512
513 confirmation_dialog_result = self._confirmation_dialog_results[uuid_]
514
515 result = False
516 if reply == QMessageBox.Ok:
517 result = True
518 confirmation_dialog_result['result'] = result
519 confirmation_dialog_result['semaphore'].release()
520
521 def on_file_dialog(self, dialog_type, directory, allow_multiple, save_filename, file_filter):
522 if dialog_type == FileDialog.FOLDER:
523 self._file_name = QFileDialog.getExistingDirectory(
524 self,
525 self.localization['linux.openFolder'],
526 directory,
527 options=QFileDialog.ShowDirsOnly,
528 )
529 elif dialog_type == FileDialog.OPEN:
530 if allow_multiple:
531 self._file_name = QFileDialog.getOpenFileNames(
532 self, self.localization['linux.openFiles'], directory, file_filter
533 )
534 else:
535 self._file_name = QFileDialog.getOpenFileName(
536 self, self.localization['linux.openFile'], directory, file_filter
537 )
538 elif dialog_type == FileDialog.SAVE:
539 if directory:
540 save_filename = os.path.join(str(directory), str(save_filename))
541
542 self._file_name = QFileDialog.getSaveFileName(
543 self, self.localization['global.saveFile'], save_filename
544 )
545
546 self._file_name_semaphore.release()
547
548 def on_cookie_added(self, cookie):
549 raw = str(cookie.toRawForm(), 'utf-8')
550 cookie = create_cookie(raw)
551
552 if raw not in self.cookies:
553 self.cookies[raw] = cookie
554
555 def on_cookie_removed(self, cookie):
556 raw = str(cookie.toRawForm(), 'utf-8')
557
558 if raw in self.cookies:
559 del self.cookies[raw]
560
561 def on_current_url(self):
562 url = BrowserView._convert_string(self.webview.url().toString())
563 self._current_url = None if url == '' or url.startswith('data:text/html') else url
564 self._current_url_semaphore.release()
565
566 def on_load_url(self, url):
567 self.webview.setUrl(QtCore.QUrl(url))
568
569 def on_load_html(self, content, base_uri):
570 self.webview.setHtml(content, QtCore.QUrl(base_uri))
571
572 def on_set_on_top(self, top):
573 flags = self.windowFlags()
574 if top:
575 self.setWindowFlags(flags | QtCore.Qt.WindowStaysOnTopHint)
576 else:
577 self.setWindowFlags(flags & ~QtCore.Qt.WindowStaysOnTopHint)
578
579 self.show()
580
581 def showEvent(self, event):
582 self.pywebview_window.events.shown.set()
583
584 def closeEvent(self, event):
585 should_cancel = self.pywebview_window.events.closing.set()
586
587 if should_cancel:
588 event.ignore()
589 return
590
591 if self.pywebview_window.confirm_close:
592 reply = QMessageBox.question(
593 self,
594 self.title,
595 self.localization['global.quitConfirmation'],
596 QMessageBox.Yes,
597 QMessageBox.No,
598 )
599
600 if reply == QMessageBox.No:
601 event.ignore()
602 return
603
604 event.accept()
605
606 del BrowserView.instances[self.uid]
607 self.close()
608
609 if self.pywebview_window in windows:
610 windows.remove(self.pywebview_window)
611
612 self.pywebview_window.events.closed.set()
613
614 if self.webview.page():
615 self.webview.page().deleteLater()
616
617 if len(BrowserView.instances) == 0:
618 self.hide()
619 _app.exit()
620
621 def changeEvent(self, e):
622 if e.type() != QtCore.QEvent.WindowStateChange:
623 return
624
625 if self.windowState() == QtCore.Qt.WindowMinimized:
626 self.pywebview_window.events.minimized.set()
627
628 if self.windowState() == QtCore.Qt.WindowMaximized:
629 self.pywebview_window.events.maximized.set()
630
631 if self.windowState() == QtCore.Qt.WindowNoState and e.oldState() in (
632 QtCore.Qt.WindowMinimized,
633 QtCore.Qt.WindowMaximized,
634 ):
635 self.pywebview_window.events.restored.set()
636
637 def resizeEvent(self, e):
638 if (
639 self.pywebview_window.initial_width != self.width()
640 or self.pywebview_window.initial_height != self.height()
641 ):
642 self.pywebview_window.events.resized.set(self.width(), self.height())
643
644 def eventFilter(self, object, event):
645 if event.type() == QtCore.QEvent.Move:
646 self.pywebview_window.events.moved.set(self.x(), self.y())
647
648 return super().eventFilter(object, event)
649
650 def on_show_window(self):
651 self.show()
652
653 def on_hide_window(self):
654 self.hide()
655
656 def on_destroy_window(self):
657 self.close()
658
659 def on_fullscreen(self):
660 if self.is_fullscreen:
661 self.showNormal()
662 else:
663 self.showFullScreen()
664
665 self.is_fullscreen = not self.is_fullscreen
666
667 def on_window_size(self, width, height, fix_point):
668 geo = self.geometry()
669
670 if fix_point & FixPoint.EAST:
671 # Keep the right of the window in the same place
672 geo.setX(geo.x() + geo.width() - width)
673
674 if fix_point & FixPoint.SOUTH:
675 # Keep the top of the window in the same place
676 geo.setY(geo.y() + geo.height() - height)
677
678 geo.setWidth(width)
679 geo.setHeight(height)
680 self.setGeometry(geo)
681
682 if not self.pywebview_window.resizable:
683 self.setFixedSize(width, height)
684
685 def on_window_move(self, x, y):
686 self.move(x, y)
687
688 def on_window_maximize(self):
689 self.setWindowState(QtCore.Qt.WindowMaximized)
690
691 def on_window_minimize(self):
692 self.setWindowState(QtCore.Qt.WindowMinimized)
693
694 def on_window_restore(self):
695 self.setWindowState(QtCore.Qt.WindowNoState)
696 self.raise_()
697 self.activateWindow()
698
699 def on_evaluate_js(self, script, uuid):
700 def return_result(result_):
701 result = BrowserView._convert_string(result_)
702 uuid_ = BrowserView._convert_string(uuid)
703
704 js_result = self._js_results[uuid_]
705
706 if js_result['parse_json'] and result:
707 try:
708 js_result['result'] = json.loads(result)
709 except Exception:
710 logger.exception('Failed to parse JSON: %s', result)
711 js_result['result'] = result
712 else:
713 js_result['result'] = result
714
715 js_result['semaphore'].release()
716
717 try: # < Qt5.6
718 if _qt6:
719 self.webview.page().runJavaScript(script, 0, return_result)
720 else:
721 self.webview.page().runJavaScript(script, return_result)
722 except TypeError:
723 self.webview.page().runJavaScript(script) # PySide2 & PySide6
724 except AttributeError:
725 result = self.webview.page().mainFrame().evaluateJavaScript(script)
726 return_result(result)
727 except Exception as e:
728 logger.exception(e)
729
730 def on_load_finished(self):
731 if self.uid == 'web_inspector':
732 return
733
734 self._set_js_api()
735
736 if _state['debug'] and settings['OPEN_DEVTOOLS_IN_DEBUG']:
737 self.webview.show_inspector()
738
739 def on_download_requested(self, download):
740 old_path = download.url().path()
741 suffix = QtCore.QFileInfo(old_path).suffix()
742 path, _ = QFileDialog.getSaveFileName(
743 self, self.localization['global.saveFile'], old_path, '*.' + suffix
744 )
745 if path:
746 download.setPath(path)
747 download.accept()
748
749 def set_title(self, title):
750 self.set_title_trigger.emit(title)
751
752 def get_cookies(self):
753 return list(self.cookies.values())
754
755 def clear_cookies(self):
756 self.cookies = {}
757 self.profile.cookieStore().deleteAllCookies()
758
759 def get_current_url(self):
760 self.current_url_trigger.emit()
761 self._current_url_semaphore.acquire()
762
763 return self._current_url
764
765 def load_url(self, url):
766 self.load_url_trigger.emit(url)
767
768 def load_html(self, content, base_uri):
769 self.html_trigger.emit(content, base_uri)
770
771 def create_confirmation_dialog(self, title, message):
772 result_semaphore = Semaphore(0)
773 unique_id = uuid1().hex
774 self._confirmation_dialog_results[unique_id] = {
775 'semaphore': result_semaphore,
776 'result': None,
777 }
778
779 self.confirmation_dialog_trigger.emit(title, message, unique_id)
780 result_semaphore.acquire()
781
782 result = self._confirmation_dialog_results[unique_id]['result']
783 del self._confirmation_dialog_results[unique_id]
784
785 return result
786
787 def create_file_dialog(
788 self, dialog_type, directory, allow_multiple, save_filename, file_filter
789 ):
790 self.file_dialog_trigger.emit(
791 dialog_type, directory, allow_multiple, save_filename, file_filter
792 )
793 self._file_name_semaphore.acquire()
794
795 if dialog_type == FileDialog.FOLDER:
796 file_names = (self._file_name,)
797 elif dialog_type == FileDialog.SAVE or not allow_multiple:
798 file_names = (self._file_name[0],)
799 else:
800 file_names = tuple(self._file_name[0])
801
802 # Check if we got an empty tuple, or a tuple with empty string
803 if len(file_names) == 0 or len(file_names[0]) == 0:
804 return None
805 else:
806 return file_names
807
808 def hide_(self):
809 self.hide_trigger.emit()
810
811 def show_(self):
812 self.show_trigger.emit()
813
814 def destroy_(self):
815 self.destroy_trigger.emit()
816
817 def toggle_fullscreen(self):
818 self.fullscreen_trigger.emit()
819
820 def resize_(self, width, height, fix_point):
821 self.window_size_trigger.emit(width, height, fix_point)
822
823 def move_window(self, x, y):
824 self.window_move_trigger.emit(x, y)
825
826 def maximize(self):
827 self.window_maximize_trigger.emit()
828
829 def minimize(self):
830 self.window_minimize_trigger.emit()
831
832 def restore(self):
833 self.window_restore_trigger.emit()
834
835 def set_on_top(self, top):
836 self.on_top_trigger.emit(top)
837
838 def evaluate_js(self, script, parse_json):
839 result_semaphore = Semaphore(0)
840 unique_id = uuid1().hex
841 self._js_results[unique_id] = {
842 'semaphore': result_semaphore,
843 'result': '',
844 'parse_json': parse_json,
845 }
846
847 self.evaluate_js_trigger.emit(script, unique_id)
848 result_semaphore.acquire()
849
850 result = deepcopy(self._js_results[unique_id]['result'])
851 del self._js_results[unique_id]
852
853 return result
854
855 def _set_js_api(self):
856 def _register_window_object():
857 frame.addToJavaScriptWindowObject('external', self.js_bridge)
858
859 if is_webengine:
860 qwebchannel_js = QtCore.QFile('://qtwebchannel/qwebchannel.js')
861 if qwebchannel_js.open(QtCore.QFile.ReadOnly):
862 source = bytes(qwebchannel_js.readAll()).decode('utf-8')
863 self.webview.page().runJavaScript(source)
864 self.channel.registerObject('external', self.js_bridge)
865 qwebchannel_js.close()
866 else:
867 frame = self.webview.page().mainFrame()
868 _register_window_object()
869
870 inject_pywebview(renderer, self.js_bridge.window)
871
872 @staticmethod
873 def _convert_string(result):
874 if isinstance(result, QJsonValue):
875 return None if result.isNull() else result.toString()
876 else:
877 return result
878
879 @staticmethod
880 def _get_debug_port():
881 """
882 Check if default debug port 8228 is available,
883 increment it by 1 until a port is available.
884 :return: port: str
885 """
886 port_available = False
887 port = 8228
888
889 while not port_available:
890 try:
891 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
892 sock.bind(('localhost', port))
893 port_available = True
894 except Exception as e:
895 port_available = False
896 logger.warning(f'Port {port} is in use: {e}')
897 port += 1
898 finally:
899 sock.close()
900
901 return str(port)
902
903 @staticmethod
904 # Receive func from subthread and execute it on the main thread
905 def on_create_window(func):
906 func()
907
908
909 def setup_app():
910 global _app
911 if settings['IGNORE_SSL_ERRORS']:
912 environ_append('QTWEBENGINE_CHROMIUM_FLAGS', '--ignore-certificate-errors')
913 if settings['REMOTE_DEBUGGING_PORT']:
914 environ_append(
915 'QTWEBENGINE_CHROMIUM_FLAGS',
916 f'--remote-debugging-port={settings["REMOTE_DEBUGGING_PORT"]}',
917 )
918 _app = QApplication.instance() or QApplication(sys.argv)
919
920
921 def create_window(window):
922 def _create():
923 browser = BrowserView(window)
924 browser.installEventFilter(browser)
925
926 if window.menu or _app_menu:
927 menu = window.menu or _state['menu']
928 window_menubar = browser.menuBar()
929 create_menu(menu, window_menubar)
930
931 _main_window_created.set()
932
933 if window.maximized:
934 browser.showMaximized()
935 elif window.minimized:
936 # showMinimized does not work on start without showNormal first
937 # looks like a bug in QT
938 browser.showNormal()
939 browser.showMinimized()
940 elif not window.hidden:
941 browser.show()
942 elif window.hidden:
943 browser.pywebview_window.events.shown.set()
944
945 if window.uid == 'master':
946 global _app, _app_menu
947 if _state['menu']:
948 _app_menu = QMenuBar()
949 _app_menu.setNativeMenuBar(False)
950 create_menu(_state['menu'], _app_menu)
951 else:
952 _app_menu = None
953
954 _app = QApplication.instance() or QApplication(sys.argv)
955
956 signal.signal(signal.SIGINT, _sigint_handler)
957
958 # Create a timer to periodically allow the Python interpreter to run
959 # This enables the signal handler to be called even when the Qt event loop is running
960 # The timer just calls a no-op function to trigger Python execution
961 timer = QtCore.QTimer()
962 timer.start(500)
963 timer.timeout.connect(lambda: None)
964
965 _create()
966 _app.exec_()
967 else:
968 _main_window_created.wait()
969 i = list(BrowserView.instances.values())[0] # arbitrary instance
970 i.create_window_trigger.emit(_create)
971
972
973 def set_title(title, uid):
974 i = BrowserView.instances.get(uid)
975 if i:
976 i.set_title(title)
977
978
979 def clear_cookies(uid):
980 i = BrowserView.instances.get(uid)
981 if i:
982 i.clear_cookies()
983
984
985 def get_cookies(uid):
986 i = BrowserView.instances.get(uid)
987 if i:
988 return i.get_cookies()
989
990
991 def get_current_url(uid):
992 i = BrowserView.instances.get(uid)
993 if i:
994 return i.get_current_url()
995
996
997 def load_url(url, uid):
998 i = BrowserView.instances.get(uid)
999 if i:
1000 i.load_url(url)
1001
1002
1003 def load_html(content, base_uri, uid):
1004 i = BrowserView.instances.get(uid)
1005 if i:
1006 i.load_html(content, base_uri)
1007
1008
1009 def create_menu(app_menu_list, menubar):
1010 """
1011 Create the menu bar for the application for the provided QMenuBar object. Menu can be either a global
1012 application menu or a window-specific menu.
1013
1014 Args:
1015 app_menu_list ([webview.menu.Menu])
1016 menubar (QMenuBar)
1017 """
1018
1019 def run_action(func):
1020 Thread(target=func).start()
1021
1022 def create_submenu(title, line_items, supermenu):
1023 m = supermenu.addMenu(title)
1024 BrowserView.global_menubar_other_objects.append(m)
1025 for menu_line_item in line_items:
1026 if isinstance(menu_line_item, MenuSeparator):
1027 m.addSeparator()
1028 elif isinstance(menu_line_item, MenuAction):
1029 new_action = QAction(menu_line_item.title)
1030 func = copy(menu_line_item.function)
1031 new_action.triggered.connect(partial(run_action, func))
1032 m.addAction(new_action)
1033 BrowserView.global_menubar_other_objects.append(new_action)
1034 elif isinstance(menu_line_item, Menu):
1035 create_submenu(menu_line_item.title, menu_line_item.items, m)
1036
1037 return m
1038
1039 for app_menu in app_menu_list:
1040 # Ignore '__app__' menus (macOS-only feature)
1041 if app_menu.title == '__app__':
1042 continue
1043 menu = create_submenu(app_menu.title, app_menu.items, menubar)
1044 menubar.addMenu(menu)
1045
1046
1047 def get_active_window():
1048 active_window = None
1049 try:
1050 active_window = _app.activeWindow()
1051 except Exception as e:
1052 logger.warning(f'Failed to get active window: {e}')
1053 return None
1054
1055 if active_window:
1056 return active_window.pywebview_window
1057
1058 return None
1059
1060
1061 def destroy_window(uid):
1062 i = BrowserView.instances.get(uid)
1063 if i:
1064 i.destroy_()
1065
1066
1067 def hide(uid):
1068 i = BrowserView.instances.get(uid)
1069 if i:
1070 i.hide_()
1071
1072
1073 def show(uid):
1074 i = BrowserView.instances.get(uid)
1075 if i:
1076 i.show_()
1077
1078
1079 def maximize(uid):
1080 i = BrowserView.instances.get(uid)
1081 if i:
1082 i.maximize()
1083
1084
1085 def minimize(uid):
1086 i = BrowserView.instances.get(uid)
1087 if i:
1088 i.minimize()
1089
1090
1091 def restore(uid):
1092 i = BrowserView.instances.get(uid)
1093 if i:
1094 i.restore()
1095
1096
1097 def toggle_fullscreen(uid):
1098 i = BrowserView.instances.get(uid)
1099 if i:
1100 i.toggle_fullscreen()
1101
1102
1103 def set_on_top(uid, top):
1104 i = BrowserView.instances.get(uid)
1105 if i:
1106 i.set_on_top(top)
1107
1108
1109 def resize(width, height, uid, fix_point):
1110 i = BrowserView.instances.get(uid)
1111 if i:
1112 i.resize_(width, height, fix_point)
1113
1114
1115 def move(x, y, uid):
1116 i = BrowserView.instances.get(uid)
1117 if i:
1118 i.move_window(x, y)
1119
1120
1121 def create_confirmation_dialog(title, message, uid):
1122 i = BrowserView.instances.get(uid)
1123 if i:
1124 return i.create_confirmation_dialog(title, message)
1125
1126
1127 def create_file_dialog(dialog_type, directory, allow_multiple, save_filename, file_types, uid):
1128 # Create a file filter by parsing allowed file types
1129 file_types = [s.replace(';', ' ') for s in file_types]
1130 file_filter = ';;'.join(file_types)
1131
1132 i = BrowserView.instances.get(uid)
1133 if i:
1134 return i.create_file_dialog(
1135 dialog_type, directory, allow_multiple, save_filename, file_filter
1136 )
1137
1138
1139 def evaluate_js(script, uid, parse_json=True):
1140 i = BrowserView.instances.get(uid)
1141 if i:
1142 return i.evaluate_js(script, parse_json)
1143
1144
1145 def get_position(uid):
1146 i = BrowserView.instances.get(uid)
1147 if i:
1148 position = i.geometry()
1149 return position.x(), position.y()
1150 else:
1151 return None, None
1152
1153
1154 def get_size(uid):
1155 i = BrowserView.instances.get(uid)
1156 if i:
1157 return i.width(), i.height()
1158 else:
1159 return None, None
1160
1161
1162 def get_screens():
1163 global _app
1164 _app = QApplication.instance() or QApplication(sys.argv)
1165 screens = [
1166 Screen(
1167 s.geometry().x(),
1168 s.geometry().y(),
1169 s.geometry().width(),
1170 s.geometry().height(),
1171 s,
1172 s.devicePixelRatio(),
1173 )
1174 for s in _app.screens()
1175 ]
1176
1177 return screens
1178
1179
1180 def add_tls_cert(certfile):
1181 config = QSslConfiguration.defaultConfiguration()
1182 certs = config.caCertificates()
1183 cert = QSslCertificate.fromPath(certfile)[0]
1184 certs.append(cert)
1185 config.setCaCertificates(certs)
1186 QSslConfiguration.setDefaultConfiguration(config)