def __init__(self, argv):
self.plumbing_bridge = PlumbingBridge()
self.procedures_bridge = ProceduresBridge(self.plumbing_bridge)
self.daq_bridge = DAQBridge(self.plumbing_bridge)
self.app = QApplication(argv)
# ALL custom built QQuickItems have to be registered as QML objects in this way:
qmlRegisterType(QMLVisualizationArea, 'VisualizationArea', 1, 0,
'VisualizationArea')
self.app.setWindowIcon(QIcon(find_resource('icon.ico')))
self.app.setOrganizationName('Waterloo Rocketry')
self.app.setOrganizationDomain('waterloorocketry.com')
self.app.setApplicationName('Topside')
self.qml_engine = QQmlEngine()
context = self.qml_engine.rootContext()
context.setContextProperty('plumbingBridge', self.plumbing_bridge)
context.setContextProperty('proceduresBridge', self.procedures_bridge)
self.main_window = self._make_main_window()
# TODO(jacob): Currently we load these example files at startup
# to make testing turnaround a bit faster. Figure out how to
# make the application remember the last file opened, and open
# that instead.
self.plumbing_bridge.load_from_files([find_resource('example.pdl')])
self.procedures_bridge.load_from_file(find_resource('example.proc'))
def _qmlLoad( self, qmlfile ):
engine = QQmlEngine()
main_qml = Path(ATHENA_SRC_DIR) / 'qml' / qmlfile
component = QQmlComponent(engine, main_qml.as_uri() )
if ( component.status() != QQmlComponent.Ready ):
print ("Error loading QML:")
print(component.errorString())
result = component.create()
# Need to hold a reference in python to the QQmlComponent, or else
# PySide2 will helpfully delete the material object along with it
# after this function ends.
self._qtrefs.append(component)
return result
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 3 as published by the Free Software
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-3.0.html.
##
## $QT_END_LICENSE$
##
#############################################################################
import sys
from helper import adjust_filename
from PySide2.QtCore import QUrl
from PySide2.QtGui import QGuiApplication
from PySide2.QtQml import QQmlEngine, QQmlComponent
app = QGuiApplication(sys.argv)
engine = QQmlEngine()
component = QQmlComponent(engine)
# This should segfault if the QDeclarativeComponent has not QQmlEngine
component.loadUrl(QUrl.fromLocalFile(adjust_filename('foo.qml', __file__)))
def __init__(self):
super().__init__()
self.engine = QQmlEngine()
self.incubation = IncubationController()
self.engine.setIncubationController(self.incubation)
def initialize(self, size: QSize, shareContext: QOpenGLContext) -> None:
"""
Initialize offscreen renderer.
Args:
size: The size of the area available for rendering.
shareContext: OpenGL context used as a share context.
Raises:
RuntimeError: If the renderer has already been initialized.
"""
print(f'QmlOffscreenRenderer.initialize: {size}')
if self.initialized:
raise RuntimeError('Already initialized')
format = QSurfaceFormat()
format.setDepthBufferSize(16)
format.setStencilBufferSize(8)
context = QOpenGLContext()
context.setFormat(format)
context.setShareContext(shareContext)
context.create()
self.size = size
self.context = context
# Create offscreen surface with initialized format
self._surface = surface = QOffscreenSurface()
surface.setFormat(context.format())
surface.create()
# Set up quick rendering
self._control = control = QQuickRenderControl()
self._window = window = QQuickWindow(control)
self._engine = engine = QQmlEngine()
if not engine.incubationController():
engine.setIncubationController(window.incubationController())
# Don't polish/sync/render immediately for better performance, use a timer
self._renderTimer = renderTimer = QTimer()
renderTimer.setSingleShot(True)
renderTimer.setInterval(5)
renderTimer.timeout.connect(self._onRenderTimer)
self._syncTimer = syncTimer = QTimer()
syncTimer.setSingleShot(True)
syncTimer.setInterval(5)
syncTimer.timeout.connect(self._onSyncTimer)
syncTimer.destroyed.connect(self._onSyncTimerDestroyed)
# Request to create frame buffer
window.sceneGraphInitialized.connect(self._onSceneGraphInitialized)
# Request to release frame buffer
window.sceneGraphInvalidated.connect(self._onSceneGraphInvalidated)
# Only render is needed
control.renderRequested.connect(self._onRenderRequested)
# Polish, sync & render
control.sceneChanged.connect(self._onSceneChanged)
self.initialized = True
# Load QML component
self._component = component = QQmlComponent(self._engine, self.qmlUrl)
if component.isLoading():
component.statusChanged.connect(self._onComponentStatusChanged)
else:
self._attachRootItem()