def load(self):
self.component = component = QQmlComponent(
self.engine.engine, self.qmlUrl, QQmlComponent.PreferSynchronous)
assert not component.isLoading()
if component.isError():
for err in component.errors():
print("Error:", err.url(), err.line(), err)
def __init__(self, engine):
super().__init__(engine)
self.component = QQmlComponent(self.engine)
self.component.loadUrl('src/views/qml/components/PreviewCard.qml')
self.projects_list = self.root.findChild(QQuickItem, 'projects')
self.project_to_remove = None
self.load_projects()
def __init__(self, engine):
super().__init__(engine)
self.component = QQmlComponent(self.engine)
self.component.loadUrl('src/views/qml/components/TemplateListItem.qml')
self.templates_list = self.root.findChild(QQuickItem,
'templatesListColumn')
self.load_templates()
self.current = None
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(ComponentChanger, self).__init__(None)
self._current_component = QQmlComponent()
self._changes = []
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()