def __init__(self,
container_id: str,
i18n_catalog: i18nCatalog = None,
parent: QObject = None,
*args,
**kwargs) -> None:
"""Constructor
:param container_id: A unique, machine readable/writable ID for this container.
"""
super().__init__()
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {
"id": container_id,
"name": container_id,
"container_type": DefinitionContainer,
"version": self.Version
} # type: Dict[str, Any]
self._definitions = [] # type: List[SettingDefinition]
self._inherited_files = [] # type: List[str]
self._i18n_catalog = i18n_catalog # type: Optional[i18nCatalog]
self._definition_cache = {} # type: Dict[str, SettingDefinition]
self._path = ""
def __init__(self, stack_id: str) -> None:
"""Constructor
:param stack_id: A unique, machine readable/writable ID.
"""
super().__init__()
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {
"id": stack_id,
"name": stack_id,
"version": self.Version,
"container_type": ContainerStack
} #type: Dict[str, Any]
self._containers = [] # type: List[ContainerInterface]
self._next_stack = None # type: Optional[ContainerStack]
self._read_only = False # type: bool
self._dirty = False # type: bool
self._path = "" # type: str
self._postponed_emits = [
] # type: List[Tuple[Signal, ContainerInterface]] # gets filled with 2-tuples: signal, signal_argument(s)
self._property_changes = {} # type: Dict[str, Set[str]]
self._emit_property_changed_queued = False # type: bool
def __init__(self,
container_id: str,
parent: QObject = None,
*args: Any,
**kwargs: Any) -> None:
"""Constructor
:param container_id: A unique, machine readable/writable ID for this container.
"""
super().__init__()
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {
"id": container_id,
"name": container_id,
"version": self.Version,
"container_type": InstanceContainer
} # type: Dict[str, Any]
self._instances = {} # type: Dict[str, SettingInstance]
self._read_only = False # type: bool
self._dirty = False # type: bool
self._path = "" # type: str
self._postponed_emits = [
] # type: List[Tuple[Signal, Tuple[str, str]]]
self._definition = None # type: Optional[DefinitionContainerInterface]
self._cached_values = None # type: Optional[Dict[str, Any]]
def setupEngine(self):
ipfsCtx = self.app.ipfsCtx
filesModel = ipfsCtx.currentProfile.filesModel
# stores = services.getByDotName('ld.rdf.graphs')
self.engine = QQmlEngine(self)
ctx = self.engine.rootContext()
# XML graph exports paths
# ctx.setContextProperty('graphGXmlPath',
# stores.graphG.xmlExportUrl)
ctx.setContextProperty('g', self.gInterface)
ctx.setContextProperty('ld', self.ldInterface)
ctx.setContextProperty('sparql', self.sparqlInterface)
ctx.setContextProperty('iContainer', self.iInterface)
ctx.setContextProperty('ipid', self.ipidInterface)
# Pass the web profile
ctx.setContextProperty('ipfsWebProfile', self.webProfile)
ctx.setContextProperty('modelArticles', self.models['Articles'])
ctx.setContextProperty('modelMultiChannels', self.models['Channels'])
ctx.setContextProperty('modelShouts', self.models['Shouts'])
ctx.setContextProperty('modelMfs', filesModel)
def __init__(self, parent = None):
super().__init__(parent)
# Ensure that this model doesn't get garbage collected (Now the bound object is destroyed when the wrapper is)
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._device_manager = Application.getInstance().getOutputDeviceManager() # type: OutputDeviceManager
self.addRoleName(self.IdRole, "id")
self.addRoleName(self.NameRole, "name")
self.addRoleName(self.PriorityRole, "priority")
self.addRoleName(self.ShortcutRole, "shortcut")
self._device_manager.projectOutputDevicesChanged.connect(self._update)
self._update()
def __init__(self, container_id: str, i18n_catalog: i18nCatalog = None, parent: QObject = None, *args, **kwargs) -> None:
super().__init__()
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {"id": container_id,
"name": container_id,
"container_type": DefinitionContainer,
"version": self.Version} # type: Dict[str, Any]
self._definitions = [] # type: List[SettingDefinition]
self._inherited_files = [] # type: List[str]
self._i18n_catalog = i18n_catalog
self._definition_cache = {} # type: Dict[str, SettingDefinition]
self._path = ""
def _initialise_qml_engine(self):
self._qml_engine = QQmlEngine(self)
qml_path = str(ConfigInstall.Path.qml_path)
self._qml_engine.addImportPath(qml_path)
context = self.qml_context
self._application_style = ApplicationStyle()
context.setContextProperty('application_style',
self._application_style)
self._icon_provider = IconProvider()
self._qml_engine.addImageProvider('icon_provider', self._icon_provider)
def __init__(self, container_id: str, i18n_catalog: i18nCatalog = None, parent: QObject = None, *args, **kwargs) -> None:
super().__init__()
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {"id": container_id,
"name": container_id,
"container_type": DefinitionContainer,
"version": self.Version} # type: Dict[str, Any]
self._definitions = [] # type: List[SettingDefinition]
self._inherited_files = [] # type: List[str]
self._i18n_catalog = i18n_catalog # type: Optional[i18nCatalog]
self._definition_cache = {} # type: Dict[str, SettingDefinition]
self._path = ""
def prepareAlgorithm(self, parameters, context, feedback):
"""
Prepares the algorithm
"""
self.engine = QJSEngine()
js_feedback = self.engine.newQObject(feedback)
QQmlEngine.setObjectOwnership(feedback, QQmlEngine.CppOwnership)
self.engine.globalObject().setProperty("feedback", js_feedback)
js = """
function process(feature)
{
res = func(JSON.parse(feature))
if ( res && res.stack && res.message )
return res;
return JSON.stringify(res);
}
"""
for param in self.parameterDefinitions():
if param.isDestination():
continue
if param.name() not in parameters or parameters[param.name()] is None:
js += '{}=None;\n'.format(param.name())
continue
if isinstance(param,
(QgsProcessingParameterField, QgsProcessingParameterString, QgsProcessingParameterFile)):
value = self.parameterAsString(parameters, param.name(), context)
js += '{}="{}";'.format(param.name(), value)
elif isinstance(param, QgsProcessingParameterNumber):
value = self.parameterAsDouble(parameters, param.name(), context)
js += '{}={};'.format(param.name(), value)
js += self.js_script
result = self.engine.evaluate(js)
user_func = self.engine.globalObject().property("func")
if not user_func:
raise QgsProcessingException('No \'func\' function detected in script')
if not user_func.isCallable():
raise QgsProcessingException('Object \'func\' is not a callable function')
self.process_js_function = self.engine.globalObject().property("process")
self.json_exporter = QgsJsonExporter()
self.codec = QTextCodec.codecForName("System")
return True
def __init__(self) :
QObject.__init__( self )
self.app = QApplication( sys.argv )
self.app.setApplicationName( 'Waterfall' )
engine = QQmlEngine()
appDirPath = os.path.dirname( os.path.abspath( __file__ ) )
rootContext = engine.rootContext()
rootContext.setContextProperty( 'controller', self )
rootContext.setContextProperty( 'appPath', appDirPath.replace( "\\", "/" ) + "/" )
windowComp = QQmlComponent( engine, QUrl( 'qml/Main.qml' ) )
self.window = windowComp.create()
self.window.show()
self.app.exec()
def __init__(self, parent = None):
super().__init__(parent)
# Ensure that this model doesn't get garbage collected (Now the bound object is destroyed when the wrapper is)
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._device_manager = Application.getInstance().getOutputDeviceManager()
self.addRoleName(self.IdRole, "id")
self.addRoleName(self.NameRole, "name")
self.addRoleName(self.ShortDescriptionRole, "short_description")
self.addRoleName(self.DescriptionRole, "description")
self.addRoleName(self.IconNameRole, "icon_name")
self.addRoleName(self.PriorityRole, "priority")
self._device_manager.outputDevicesChanged.connect(self._update)
self._update()
def reloadProject(self, filename):
engine = QQmlEngine()
component = QQmlComponent(engine)
component.loadUrl(QUrl(filename))
self.site = component.create()
if self.site is not None:
self.site.setFilename(filename)
self.site.setWindow(self)
else:
for error in component.errors():
print(error.toString())
return False
self.site.loadMenus()
self.site.loadPages()
self.site.loadPosts()
self.theme_settings_button.setVisible(False)
Plugins.setActualThemeEditorPlugin("")
for key in Plugins.themePluginNames():
tei = Plugins.getThemePlugin(key)
if tei:
if tei.theme_name == self.site.theme:
Plugins.setActualThemeEditorPlugin(tei.class_name)
self.theme_settings_button.setVisible(True)
break
#if not self.site.publisher:
# if len(Plugins.publishPluginNames()) > 0:
# self.site.publisher = Plugins.publishPluginNames[0]
Plugins.setActualPublishPlugin(self.site.publisher)
self.siteLoaded.emit(self.site)
return True
def __init__(self, title, frame_rate, run_time):
"""
Create a new Animation.
Arguments:
title: str, the window title
frame_rate: float, the number of frames to display per second
run_time: float, the number of seconds to run the animation
"""
self.title = title
assert 0 < frame_rate < 1000
self.frame_rate = frame_rate
assert run_time > 0
self.run_time = run_time
self.frame = 0
self.prev_update_time = None
# import OpenGL so Qt can use it for rendering
from OpenGL import GL
# create the 3D window
self.view = Qt3DWindow()
self.view.setX(100)
self.view.setY(100)
self.view.setTitle(self.title)
self.qml_engine = QQmlEngine(self.view)
def init_country_names_from_code(locale):
'''Init the country description as found in GCompris geography/resource/board/board*.qml'''
'''in the global descriptions hash'''
po = None
try:
po = polib.pofile(gcompris_qt + '/po/gcompris_' + locale + '.po')
except:
print("**ERROR: Failed to load po file %s**" %
('/po/gcompris_' + locale + '.po'))
print('')
app = QCoreApplication(sys.argv)
engine = QQmlEngine()
component = QQmlComponent(engine)
for qml in glob.glob(gcompris_qt +
'/src/activities/geography/resource/board/*.qml'):
component.loadUrl(QUrl(qml))
board = component.create()
levels = board.property('levels')
for level in levels.toVariant():
if 'soundFile' in level and 'toolTipText' in level:
sound = level['soundFile'].split('/')[-1].replace('$CA', 'ogg')
tooltip = level['toolTipText']
if po:
tooltip = po.find(tooltip).msgstr if po.find(
tooltip) else tooltip
descriptions[sound] = tooltip
def main(argv, app):
engine = QQmlEngine(app)
engine.quit.connect(app.quit)
component = QQmlComponent(engine)
component.loadUrl(QUrl('Wizard/Wizard.qml'))
if component.isReady():
mainWindow = component.create()
file = FileInfo()
context = engine.rootContext()
context.setContextProperty('FileInfo', file)
else:
print(component.errorString())
sys.exit(app.exec_())
def loadBook(self, filename):
self.last_book = filename
self.filename = ""
engine = QQmlEngine()
self.component = QQmlComponent(engine)
self.component.statusChanged.connect(self.loadStatusChanged)
self.component.loadUrl(QUrl.fromLocalFile(filename))
def main(): # Set up correct Ctrl-C behavior. signal.signal(signal.SIGINT, signal.SIG_DFL) app = QGuiApplication( sys.argv ) engine = QQmlEngine() engine.addImportPath( path.join( path.dirname( __file__ ), 'ui', 'qml' ) ) core.register_types() component = QQmlComponent( engine ) component.loadUrl( QUrl( '/home/feoh3/.config/nube/hud.qml' ) ) if component.isError(): print( "\n".join( error.toString() for error in component.errors() ) ) else: window = component.create() app.exec_()
def __init__(self, stack_id: str) -> None:
super().__init__()
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {
"id": stack_id,
"name": stack_id,
"version": self.Version,
"container_type": ContainerStack
} #type: Dict[str, Any]
self._containers = [] # type: List[ContainerInterface]
self._next_stack = None # type: Optional[ContainerStack]
self._read_only = False # type: bool
self._dirty = True # type: bool
self._path = "" # type: str
self._postponed_emits = [] #type: List[Tuple[Signal, ContainerInterface]] # gets filled with 2-tuples: signal, signal_argument(s)
self._property_changes = {} #type: Dict[str, Set[str]]
self._emit_property_changed_queued = False # type: bool
def loadMenus(self):
engine = QQmlEngine()
component = QQmlComponent(engine)
component.loadUrl(QUrl(os.path.join(self.source_path, "Menus.qml")))
self.menus = component.create()
if self.menus is not None:
self.win.statusBar().showMessage("Menus have been loaded")
else:
for error in component.errors():
print(error.toString())
del engine
def pytest_qml_qmlEngineAvailable(engine: QQmlEngine):
global db
global fk
global th
from mycartable.main import (
add_database_to_types,
)
add_database_to_types(db)
ctx = engine.rootContext()
ctx.setContextProperty("fk", fk)
ctx.setContextProperty("th", th)
def __init__(self, stack_id: str, *args, **kwargs):
# Note that we explicitly pass None as QObject parent here. This is to be able
# to support pickling.
super().__init__(parent=None, *args, **kwargs)
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._metadata = {
"id": stack_id,
"name": stack_id,
"version": self.Version,
"container_type": ContainerStack
}
self._containers = [] # type: List[ContainerInterface]
self._next_stack = None # type: Optional[ContainerStack]
self._read_only = False # type: bool
self._dirty = True # type: bool
self._path = "" # type: str
self._postponed_emits = [
] # gets filled with 2-tuples: signal, signal_argument(s)
self._property_changes = {}
self._emit_property_changed_queued = False # type: bool
def _initialise_qml_engine(self):
self._qml_engine = QQmlEngine(self)
qml_path = str(ConfigInstall.Path.qml_path)
self._qml_engine.addImportPath(qml_path)
context = self.qml_context
self._application_style = ApplicationStyle()
context.setContextProperty('application_style', self._application_style)
self._icon_provider = IconProvider()
self._qml_engine.addImageProvider('icon_provider', self._icon_provider)
def loadProject(self, filename):
self.last_project = filename
self.filename = ""
engine = QQmlEngine()
component = QQmlComponent(engine)
component.loadUrl(QUrl(filename))
self.project = component.create()
if self.project is not None:
self.project.setFilename(filename)
self.project.setWindow(self)
else:
for error in component.errors():
print(error.toString())
return
def loadContent(self, source, type):
if type == ContentType.PAGE:
sub = "pages"
else:
sub = "posts"
engine = QQmlEngine()
component = QQmlComponent(engine)
component.loadUrl(QUrl(os.path.join(self.source_path, sub, source)))
content = component.create()
if content is not None:
content.source = source
content.content_type = type
else:
for error in component.errors():
print(error.toString())
return content
def get_geography_on_letter_from_code():
'''Return all the countries in geography/resource/board/board-x.json'''
words = set()
app = QCoreApplication(sys.argv)
engine = QQmlEngine()
component = QQmlComponent(engine)
for qml in glob.glob(gcompris_qt +
'/src/activities/geography/resource/board/*.qml'):
component.loadUrl(QUrl(qml))
board = component.create()
levels = board.property('levels')
for level in levels.toVariant():
if 'soundFile' in level and (not 'type' in level or
level['type'] != "SHAPE_BACKGROUND"):
sound = level['soundFile'].split('/')[-1].replace('$CA', 'ogg')
words.add(sound)
return words
def loadMenus(self):
engine = QQmlEngine()
component = QQmlComponent(engine)
component.loadUrl(QUrl.fromLocalFile(os.path.join(self.source_path, "Menus.qml")))
self.menus = component.create()
if self.menus is not None:
self.win.statusBar().showMessage(QCoreApplication.translate("Site", "Menus have been loaded"))
else:
for error in component.errors():
print(error.toString())
del engine
# we have to loop through the menu items to set the parent for subitems
for i in range(0, len(self.menus._menus)):
menu = self.menus._menus[i]
for j in range(0, len(menu._items)):
item = menu._items[j]
for k in range(len(item._items)):
subItem = item._items[k]
subItem.setParentItem(item)
def main(arguments):
'Main logic'
app = QCoreApplication([__file__] + arguments)
# Register the Python type. Its URI is 'People', it's v1.0, and the type
# will be called 'Person' in QML.
qmlRegisterType(Person, 'People', 1, 0, 'Person')
# Now we can load Person.qml, since it uses our registered python class
engine = QQmlEngine()
component = QQmlComponent(engine)
component.loadUrl(QUrl('Person.qml'))
person = component.create()
if person is not None:
print("The person's name is {0}.".format(person.name))
print('They wear a size {0} shoe.'.format(person.shoe_size))
else:
for error in component.errors():
print(error.toString())
app = QCoreApplication(sys.argv)
qmlRegisterType(BirthdayPartyAttached)
qmlRegisterType(BirthdayParty,
"People",
1,
0,
"BirthdayParty",
attachedProperties=BirthdayPartyAttached)
qmlRegisterType(ShoeDescription)
qmlRegisterType(Person)
qmlRegisterType(Boy, "People", 1, 0, "Boy")
qmlRegisterType(Girl, "People", 1, 0, "Girl")
engine = QQmlEngine()
component = QQmlComponent(engine)
component.setData(QML, QUrl())
party = component.create()
if party is not None and party.host is not None:
print("\"%s\" is having a birthday!" % party.host.name)
if isinstance(party.host, Boy):
print("He is inviting:")
else:
print("She is inviting:")
for guest in party.guests:
def ros_qml_main():
try:
rospy.init_node('ros_qml', sys.argv)
my_argv = rospy.myargv(sys.argv)
signal.signal(signal.SIGINT, sigint_handler)
app = QApplication(my_argv)
engine = QQmlEngine()
engine.quit.connect(app.quit)
plugins_dir = QLibraryInfo.location(QLibraryInfo.PluginsPath)
# ## Add QML extension modules and plugins to the path, including ourselves
plugins_paths = rospack.get_manifest(THIS_PACKAGE).get_export(THIS_PACKAGE, 'plugins')
for idx, p in enumerate(plugins_paths):
# If a relative path provided, treat it as relative to Qt plugins dir
if not os.path.isabs(p):
plugins_paths[idx] = plugins_dir + '/' + p
qml_paths = rospack.get_manifest(THIS_PACKAGE).get_export(THIS_PACKAGE, 'imports')
deps = rospack.get_depends_on(THIS_PACKAGE)
for d in deps:
pp = rospack.get_manifest(d).get_export(THIS_PACKAGE, 'plugins')
for idx, p in enumerate(pp):
# If a relative path provided, treat it as relative to Qt plugins dir
if not os.path.isabs(p):
pp[idx] = plugins_dir + '/' + p
plugins_paths += pp
qp = rospack.get_manifest(d).get_export(THIS_PACKAGE, 'imports')
qml_paths += qp
for p in plugins_paths:
engine.addPluginPath(p)
for p in qml_paths:
engine.addImportPath(p)
qml_sys_path = QLibraryInfo.location(QLibraryInfo.ImportsPath)
engine.addImportPath(qml_sys_path)
# Somehow we need to set the path both with QQmlEngine and with environment,
# commenting any of the two will lead to 'module not installed' error
os.environ['QML2_IMPORT_PATH'] = ':'.join(qml_paths) + ':' + qml_sys_path
comp = QQmlComponent(engine)
if len(my_argv) > 1 and my_argv[1]:
qml_url = my_argv[1]
comp.loadUrl(QUrl(qml_url))
elif rospy.has_param('qml_url'):
qml_url = rospy.get_param('qml_url')
comp.loadUrl(QUrl(qml_url))
elif rospy.has_param('qml_description'): # experimental
qml_description = rospy.get_param('qml_description')
# FIXME that hangs for unknown reason
comp.setData(QByteArray(qml_description), QUrl())
else:
rospy.logfatal('Neither /qml_url nor /qml_description (experimental) parameter is present')
sys.exit(1)
if not comp.isReady():
sys.stderr.write(comp.errorString())
sys.exit(1)
win = comp.create()
if not win:
rospy.logfatal('Your root item has to be a Window')
sys.exit(1)
engine.setIncubationController(win.incubationController())
if win:
win.show()
# Poll Python interpreter every 500ms
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
sys.exit(app.exec_())
except KeyboardInterrupt:
pass
except rospy.ROSInterruptException:
pass
class GuiApplicationBase(ApplicationBase, QApplication):
_logger = logging.getLogger(__name__)
has_gui = True
##############################################
def __init__(self, args, **kwargs):
super(GuiApplicationBase, self).__init__(args=args, **kwargs)
# Fixme: Why ?
self._logger.debug("QApplication " + str(sys.argv))
QApplication.__init__(self, sys.argv)
self._logger.debug('GuiApplicationBase ' + str(args) + ' ' +
str(kwargs))
self.setAttribute(Qt.AA_EnableHighDpiScaling)
# from . import BabelRessource
rcc_path = ConfigInstall.Path.join_share_directory('babel.rcc')
self._logger.debug('Load ressource {}'.format(rcc_path))
if not QResource.registerResource(str(rcc_path)):
self._logger.debug('Failed to load ressource {}'.format(rcc_path))
# self._display_splash_screen()
self._main_window = None
self._initialise_qml_engine()
self._init_actions()
##############################################
@property
def main_window(self):
return self._main_window
@property
def qml_engine(self):
return self._qml_engine
@property
def qml_context(self):
return self._qml_engine.rootContext()
##############################################
def _exception_hook(self, exception_type, exception_value,
exception_traceback):
traceback.print_exception(exception_type, exception_value,
exception_traceback)
dialog = CriticalErrorDialog(exception_type,
exception_value,
exception_traceback,
qml_engine=self._qml_engine)
rc = dialog.exec_()
if rc == -1:
self.exit()
# return sys.__excepthook__(exception_type, exception_value, exception_traceback)
##############################################
def _display_splash_screen(self):
pixmap = QPixmap(':/splash screen/images/splash_screen.png')
self._splash = QSplashScreen(pixmap)
self._splash.show()
self._splash.showMessage('<h2>Babel %(version)s</h2>' %
{'version': str(Version.babel)})
self.processEvents()
##############################################
def _initialise_qml_engine(self):
self._qml_engine = QQmlEngine(self)
qml_path = str(ConfigInstall.Path.qml_path)
self._qml_engine.addImportPath(qml_path)
context = self.qml_context
self._application_style = ApplicationStyle()
context.setContextProperty('application_style',
self._application_style)
self._icon_provider = IconProvider()
self._qml_engine.addImageProvider('icon_provider', self._icon_provider)
##############################################
def _init_actions(self):
self.about_action = QAction(
'About Babel',
self,
triggered=self.about,
)
self.exit_action = QAction(
'Exit',
self,
triggered=self.exit,
)
self.help_action = QAction(
'Help',
self,
triggered=self.open_help,
)
self.show_system_information_action = QAction(
'System Information',
self,
triggered=self.show_system_information,
)
##############################################
def post_init(self):
# self._splash.finish(self._main_window)
# self.processEvents()
# del self._splash
QTimer.singleShot(0, self.execute_given_user_script)
self.show_message('Welcome to Babel')
# return to main and then enter to event loop
##############################################
def show_message(self, message=None, echo=False, timeout=0):
# Fixme: cf. PdfBrowserApplication
if self._main_window is not None:
self._main_window.show_message(message, echo, timeout)
##############################################
# def critical_error(self, title='Babel Critical Error', message=''):
#
# # Fixme: CriticalErrorForm vs critical_error
#
# QMessageBox.critical(None, title, message)
#
# # Fixme: qt close?
# sys.exit(1)
##############################################
def open_help(self):
url = QUrl()
url.setScheme(DefaultConfig.Help.url_scheme)
url.setHost(DefaultConfig.Help.host)
url.setPath(
DefaultConfig.Help.url_path_pattern) # % str(Version.babel))
QDesktopServices.openUrl(url)
##############################################
def about(self):
message = Messages.about_babel % {'version': str(Version.babel)}
QMessageBox.about(self.main_window, 'About Babel', message)
##############################################
def show_system_information(self):
fields = dict(self._platform.__dict__)
fields.update({
'babel_version': str(Version.babel),
})
message = Messages.system_information_message_pattern % fields
QMessageBox.about(self.main_window, 'System Information', message)
class QMLApplicationWidget(QWidget):
def __init__(self, fileUrl, parent=None):
super(QMLApplicationWidget, self).__init__(parent=parent)
self.setLayout(QVBoxLayout())
self.app = runningApp()
self.epFileUrl = fileUrl
self.fsw = FileWatcher(parent=self)
self.fsw.pathChanged.connect(self.onReloadApp)
self.fsw.watch(self.epFileUrl)
self.stack = QStackedWidget()
self.layout().addWidget(self.stack)
self.gInterface = GHandler(self)
self.iInterface = IHandler(self)
self.ldInterface = LDHandler(self)
self.sparqlInterface = SparQLHandler(self)
self.ipidInterface = IPIDHandler(self)
self.currentComponent = None
# Clone the IPFS profile
self.webProfile = self.app.webProfiles['ipfs'].quickClone()
# TODO: move this in global place
self.models = {
'Articles': ArticlesModel(),
'Channels': MultimediaChannelsModel(),
'Shouts': ShoutsModel()
}
self.setupEngine()
@property
def comp(self):
return self.currentComponent
def onReloadApp(self, chPath):
print(chPath, 'changed')
self.engine.clearComponentCache()
self.load()
def setupEngine(self):
ipfsCtx = self.app.ipfsCtx
filesModel = ipfsCtx.currentProfile.filesModel
# stores = services.getByDotName('ld.rdf.graphs')
self.engine = QQmlEngine(self)
ctx = self.engine.rootContext()
# XML graph exports paths
# ctx.setContextProperty('graphGXmlPath',
# stores.graphG.xmlExportUrl)
ctx.setContextProperty('g', self.gInterface)
ctx.setContextProperty('ld', self.ldInterface)
ctx.setContextProperty('sparql', self.sparqlInterface)
ctx.setContextProperty('iContainer', self.iInterface)
ctx.setContextProperty('ipid', self.ipidInterface)
# Pass the web profile
ctx.setContextProperty('ipfsWebProfile', self.webProfile)
ctx.setContextProperty('modelArticles', self.models['Articles'])
ctx.setContextProperty('modelMultiChannels', self.models['Channels'])
ctx.setContextProperty('modelShouts', self.models['Shouts'])
ctx.setContextProperty('modelMfs', filesModel)
def resizeEvent(self, event):
super().resizeEvent(event)
if self.comp:
self.iInterface.size = event.size()
self.iInterface.sizeChanged.emit(event.size().width(),
event.size().height())
def importComponent(self, path):
self.engine.addImportPath(path)
self.fsw.watchWalk(Path(path))
def load(self):
# stores = services.getByDotName('ld.rdf.graphs')
qcomp = quickEnginedWidget(self.engine,
QUrl.fromLocalFile(self.epFileUrl),
parent=self.stack)
if not qcomp:
return
self.stack.addWidget(qcomp)
self.stack.setCurrentWidget(qcomp)
self.stack.setFocus(Qt.OtherFocusReason)
qcomp.setFocus(Qt.OtherFocusReason)
self.currentComponent = qcomp
class GuiApplicationBase(ApplicationBase, QApplication):
_logger = logging.getLogger(__name__)
has_gui = True
##############################################
def __init__(self, args, **kwargs):
super(GuiApplicationBase, self).__init__(args=args, **kwargs)
# Fixme: Why ?
self._logger.debug("QApplication " + str(sys.argv))
QApplication.__init__(self, sys.argv)
self._logger.debug('GuiApplicationBase ' + str(args) + ' ' + str(kwargs))
self.setAttribute(Qt.AA_EnableHighDpiScaling)
# from . import BabelRessource
rcc_path = ConfigInstall.Path.join_share_directory('babel.rcc')
self._logger.debug('Load ressource {}'.format(rcc_path))
if not QResource.registerResource(str(rcc_path)):
self._logger.debug('Failed to load ressource {}'.format(rcc_path))
# self._display_splash_screen()
self._main_window = None
self._initialise_qml_engine()
self._init_actions()
##############################################
@property
def main_window(self):
return self._main_window
@property
def qml_engine(self):
return self._qml_engine
@property
def qml_context(self):
return self._qml_engine.rootContext()
##############################################
def _exception_hook(self, exception_type, exception_value, exception_traceback):
traceback.print_exception(exception_type, exception_value, exception_traceback)
dialog = CriticalErrorDialog(
exception_type, exception_value, exception_traceback,
qml_engine=self._qml_engine
)
rc = dialog.exec_()
if rc == -1:
self.exit()
# return sys.__excepthook__(exception_type, exception_value, exception_traceback)
##############################################
def _display_splash_screen(self):
pixmap = QPixmap(':/splash screen/images/splash_screen.png')
self._splash = QSplashScreen(pixmap)
self._splash.show()
self._splash.showMessage('<h2>Babel %(version)s</h2>' % {'version':str(Version.babel)})
self.processEvents()
##############################################
def _initialise_qml_engine(self):
self._qml_engine = QQmlEngine(self)
qml_path = str(ConfigInstall.Path.qml_path)
self._qml_engine.addImportPath(qml_path)
context = self.qml_context
self._application_style = ApplicationStyle()
context.setContextProperty('application_style', self._application_style)
self._icon_provider = IconProvider()
self._qml_engine.addImageProvider('icon_provider', self._icon_provider)
##############################################
def _init_actions(self):
self.about_action = QAction(
'About Babel',
self,
triggered=self.about,
)
self.exit_action = QAction(
'Exit',
self,
triggered=self.exit,
)
self.help_action = QAction(
'Help',
self,
triggered=self.open_help,
)
self.show_system_information_action = QAction(
'System Information',
self,
triggered=self.show_system_information,
)
##############################################
def post_init(self):
# self._splash.finish(self._main_window)
# self.processEvents()
# del self._splash
QTimer.singleShot(0, self.execute_given_user_script)
self.show_message('Welcome to Babel')
# return to main and then enter to event loop
##############################################
def show_message(self, message=None, echo=False, timeout=0):
# Fixme: cf. PdfBrowserApplication
if self._main_window is not None:
self._main_window.show_message(message, echo, timeout)
##############################################
# def critical_error(self, title='Babel Critical Error', message=''):
#
# # Fixme: CriticalErrorForm vs critical_error
#
# QMessageBox.critical(None, title, message)
#
# # Fixme: qt close?
# sys.exit(1)
##############################################
def open_help(self):
url = QUrl()
url.setScheme(DefaultConfig.Help.url_scheme)
url.setHost(DefaultConfig.Help.host)
url.setPath(DefaultConfig.Help.url_path_pattern) # % str(Version.babel))
QDesktopServices.openUrl(url)
##############################################
def about(self):
message = Messages.about_babel % {'version':str(Version.babel)}
QMessageBox.about(self.main_window, 'About Babel', message)
##############################################
def show_system_information(self):
fields = dict(self._platform.__dict__)
fields.update({
'babel_version': str(Version.babel),
})
message = Messages.system_information_message_pattern % fields
QMessageBox.about(self.main_window, 'System Information', message)
def __init__(self,
package_data: Dict[str, Any],
section_title: Optional[str] = None,
parent: Optional[QObject] = None) -> None:
"""
Constructs a new model for a single package.
:param package_data: The data received from the Marketplace API about the package to create.
:param section_title: If the packages are to be categorized per section provide the section_title
:param parent: The parent QML object that controls the lifetime of this model (normally a PackageList).
"""
super().__init__(parent)
QQmlEngine.setObjectOwnership(self, QQmlEngine.CppOwnership)
self._package_manager: CuraPackageManager = cast(
CuraPackageManager,
CuraApplication.getInstance().getPackageManager())
self._plugin_registry: PluginRegistry = CuraApplication.getInstance(
).getPluginRegistry()
self._package_id = package_data.get("package_id", "UnknownPackageId")
self._package_type = package_data.get("package_type", "")
self._is_bundled = package_data.get("is_bundled", False)
self._icon_url = package_data.get("icon_url", "")
self._marketplace_url = package_data.get("marketplace_url", "")
self._display_name = package_data.get(
"display_name", catalog.i18nc("@label:property",
"Unknown Package"))
tags = package_data.get("tags", [])
self._is_checked_by_ultimaker = (self._package_type == "plugin"
and "verified" in tags) or (
self._package_type == "material"
and "certified" in tags)
self._package_version = package_data.get(
"package_version",
"") # Display purpose, no need for 'UM.Version'.
self._package_info_url = package_data.get(
"website", "") # Not to be confused with 'download_url'.
self._download_count = package_data.get("download_count", 0)
self._description = package_data.get("description", "")
self._formatted_description = self._format(self._description)
self._download_url = package_data.get("download_url", "")
self._release_notes = package_data.get(
"release_notes",
"") # Not used yet, propose to add to description?
subdata = package_data.get("data", {})
self._technical_data_sheet = self._findLink(subdata,
"technical_data_sheet")
self._safety_data_sheet = self._findLink(subdata, "safety_data_sheet")
self._where_to_buy = self._findLink(subdata, "where_to_buy")
self._compatible_printers = self._getCompatiblePrinters(subdata)
self._compatible_support_materials = self._getCompatibleSupportMaterials(
subdata)
self._is_compatible_material_station = self._isCompatibleMaterialStation(
subdata)
self._is_compatible_air_manager = self._isCompatibleAirManager(subdata)
author_data = package_data.get("author", {})
self._author_name = author_data.get(
"display_name", catalog.i18nc("@label:property", "Unknown Author"))
self._author_info_url = author_data.get("website", "")
if not self._icon_url or self._icon_url == "":
self._icon_url = author_data.get("icon_url", "")
self._can_update = False
self._section_title = section_title
self.sdk_version = package_data.get("sdk_version_semver", "")
# Note that there's a lot more info in the package_data than just these specified here.
self.enablePackageTriggered.connect(self._plugin_registry.enablePlugin)
self.disablePackageTriggered.connect(
self._plugin_registry.disablePlugin)
self._plugin_registry.pluginsEnabledOrDisabledChanged.connect(
self.stateManageButtonChanged)
self._package_manager.packageInstalled.connect(
lambda pkg_id: self._packageInstalled(pkg_id))
self._package_manager.packageUninstalled.connect(
lambda pkg_id: self._packageInstalled(pkg_id))
self._package_manager.packageInstallingFailed.connect(
lambda pkg_id: self._packageInstalled(pkg_id))
self._package_manager.packagesWithUpdateChanged.connect(
self._processUpdatedPackages)
self._is_busy = False
def __init__(self):
self.engine = QQmlEngine()
def ros_qml_main():
try:
rospy.init_node('ros_qml', sys.argv)
my_argv = rospy.myargv(sys.argv)
signal.signal(signal.SIGINT, sigint_handler)
app = QApplication(my_argv)
engine = QQmlEngine()
engine.quit.connect(app.quit)
plugins_dir = QLibraryInfo.location(QLibraryInfo.PluginsPath)
# ## Add QML extension modules and plugins to the path, including ourselves
plugins_paths = rospack.get_manifest(THIS_PACKAGE).get_export(
THIS_PACKAGE, 'plugins')
for idx, p in enumerate(plugins_paths):
# If a relative path provided, treat it as relative to Qt plugins dir
if not os.path.isabs(p):
plugins_paths[idx] = plugins_dir + '/' + p
qml_paths = rospack.get_manifest(THIS_PACKAGE).get_export(
THIS_PACKAGE, 'imports')
deps = rospack.get_depends_on(THIS_PACKAGE)
for d in deps:
pp = rospack.get_manifest(d).get_export(THIS_PACKAGE, 'plugins')
for idx, p in enumerate(pp):
# If a relative path provided, treat it as relative to Qt plugins dir
if not os.path.isabs(p):
pp[idx] = plugins_dir + '/' + p
plugins_paths += pp
qp = rospack.get_manifest(d).get_export(THIS_PACKAGE, 'imports')
qml_paths += qp
for p in plugins_paths:
engine.addPluginPath(p)
for p in qml_paths:
engine.addImportPath(p)
qml_sys_path = QLibraryInfo.location(QLibraryInfo.ImportsPath)
engine.addImportPath(qml_sys_path)
# Somehow we need to set the path both with QQmlEngine and with environment,
# commenting any of the two will lead to 'module not installed' error
os.environ['QML2_IMPORT_PATH'] = ':'.join(
qml_paths) + ':' + qml_sys_path
comp = QQmlComponent(engine)
if len(my_argv) > 1 and my_argv[1]:
qml_url = my_argv[1]
comp.loadUrl(QUrl(qml_url))
elif rospy.has_param('qml_url'):
qml_url = rospy.get_param('qml_url')
comp.loadUrl(QUrl(qml_url))
elif rospy.has_param('qml_description'): # experimental
qml_description = rospy.get_param('qml_description')
# FIXME that hangs for unknown reason
comp.setData(QByteArray(qml_description), QUrl())
else:
rospy.logfatal(
'Neither /qml_url nor /qml_description (experimental) parameter is present'
)
sys.exit(1)
if not comp.isReady():
sys.stderr.write(comp.errorString())
sys.exit(1)
win = comp.create()
if not win:
rospy.logfatal('Your root item has to be a Window')
sys.exit(1)
engine.setIncubationController(win.incubationController())
if win:
win.show()
# Poll Python interpreter every 500ms
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
sys.exit(app.exec_())
except KeyboardInterrupt:
pass
except rospy.ROSInterruptException:
pass
# fileMenu.addAction(exitAction)
toolbar = self.addToolBar('Exit')
# toolbar.setObjectName('ToolBar')
# toolbar.addAction(exitAction)
# toolbar.addAction(processUrlAction)
self.restoreState()
self.show()
if __name__ == '__main__':
app = QApplication(sys.argv)
qmlRegisterType(JiraMain, 'JiraTree', 1, 0, 'MainWindow')
engine = QQmlEngine()
# Create a component factory and load the QML script.
component = QQmlComponent(engine)
component.loadUrl(QUrl.fromLocalFile('main.qml'))
jm = component.create()
[print(e.toString()) for e in component.errors()]
engine.rootContext().setContextProperty("mainWindow", jm)
if jm is None:
print("JM is none")
print({e.toString() for e in component.errors()})
# ex = JiraMain(None)
print("Run")
app.exec()
print("Exit")
sys.exit()
