Qt 5

So I get a message regarding changes needed to Sensor Framework and QtSensors to add heart rate sensor support for AsteroidOS. AsteroidOS is an open source operating system for watches. It uses OpenEmbedded and Yocto to build the system image and ... [More] kernel that you can flash to a small group of Android watches. The UI is based on Qt and Qml. I thought about it for approximately 30 seconds and I bought a used LG Urbane watch. Which is listed on the Install documentation for the OS, as one of the watches that can run AsteroidOS. I choose LG, as I am partial to their Smart TV's, which happen to run Qt and QML. First issue I ran into was that adb did not see the watch on WearOS, even in developer mode, but once I changed the usb cable to a good, solid cable (actually is an old Nokia cable that still works like new!), I was then able to flash the pre-built AsteroidOS 'nightly' build image on it. You might want to backup the image on the watch before you do, unlike what I did. First flash resulted in a boot loop, so I flashed the image again, and this one booted! In order to test new sensors code, I need to build the thing. Essentially, it was simply to git clone the repo, run a script, and build the image. Too easy! Luckily I have a fast development machine and it did not take too long to complete. Again I had to flash it two times. As long as I can get into the fastboot screen, everything is ok. WearOS has a wrist gesture sensor, which in WearOS, turns on the display when the user flicks their wrist. iOS does this as well. AsteroidOS does not yet have support for utilizing this, so that is one of the first things I would like to fix. Neither QtSensors or Sensor Framework has support for this sensor yet. Since it is open source and I am familiar with sensor API's that run on it, I can fix this on my own! You can read more about Qt development for Mobile and Embedded devices in the book Hands-On Mobile and Embedded Development with Qt 5 You can learn more about Yocto and embedded programming with Qt in my book Hands-on Mobile and Embedded Programming with Qt 5 [Less]

Today we announce the launch of Qt for MCUs – a comprehensive toolkit to deliver smartphone-like user experience on displays powered by microcontrollers. What started as a research project is now in the final leg of its journey to being released as a ... [More] product. Connected devices found in vehicles, wearables, smart home, industrial and healthcare often have requirements that include real-time processing capabilities, low power consumption, instant boot time and low bill of materials. These requirements can be fulfilled by a microcontroller architecture. However, as devices get smarter and offer more features and capabilities, users expect an enhanced and intuitive experience on par with today’s smartphones. Qt for MCUs delivers an immersive and enriching user interface by utilizing a new runtime specifically developed for ARM Cortex-M microcontrollers and leveraging on-chip 2D graphics accelerators such as PxP on NXP’s i.MX RT series, Chrom-Art Accelerator on STM32 series and RGL on Renesas RH850. Qt for MCUs makes use of Qt Quick for creating user interfaces with QML and C++ APIs for extending the user interface with C++ code. As Qt Quick applications follow the model-view architecture, you can easily integrate your C/C++ based backend. This speeds up porting of an existing application to Qt for MCUs, with more time to focus on enriching the user interface. An application on Qt for MCUs is rendered using the new runtime that delivers high performance with low memory consumption. This is achieved by a new translation of QML to C++, combined with a new declarative property binding engine. In addition, the new runtime allows applications to run directly on the processor without an operating system, commonly known as ‘running on bare metal’. Applications can also be deployed on more powerful devices running operating systems such as Linux, Windows, etc. using the standard Qt libraries. Along with examples and technical documentation, a set of Qt Quick Controls is provided with Qt for MCUs to jumpstart your development. Designing and developing applications is fairly straight-forward with Qt’s design and development tools – Qt Design Studio and Qt Creator. Current users of Qt can continue using their existing workflows to develop applications for microcontrollers. With over a million users of Qt, there is always a Qt developer nearby and so is our services team with local offices around the world. Curious? Download Qt for MCUs demo binaries and try them out. Want to evaluate Qt for MCUs? Sign up for the evaluation package for an early preview. Have questions? Register for the webinar and ask us during the live Q&A session. For more info, visit Qt for MCUs. The post Announcing Qt for MCUs appeared first on Qt Blog. [Less]

Today we announce the launch of Qt for MCUs - a comprehensive toolkit to deliver smartphone-like user experience on displays powered by microcontrollers. What started as a research project is now in the final leg of its journey to being released as a product.

We have released Qt Visual Studio Tools 2.4 RC (version 2.4.0); the installation package is available in the Qt download page. This version features an improved integration of Qt tools with the Visual Studio project system, addressing some ... [More] limitations of the current integration methods, most notably the inability to have different Qt settings for each project configuration, and lack of support for importing those settings from shared property sheets. Using Qt with the Visual Studio Project System The Visual Studio Project System is widely used as the build system of choice for C++ projects in VS. Under the hood, MSBuild provides the project file format and build framework. The Qt VS Tools make use of the extensibility of MSBuild to provide design-time and build-time integration of Qt in VS projects — toward the end of the post we have a closer look at how that integration works and what changed in the new release. Up to this point, the Qt VS Tools extension managed its own project settings in an isolated manner. This approach prevented the integration of Qt in Visual Studio to fully benefit from the features of VS projects and MSBuild. Significantly, it was not possible to have Qt settings vary according to the build configuration (e.g. having a different list of selected Qt modules for different configurations), including Qt itself: only one version/build of Qt could be selected and would apply to all configurations, a significant drawback in the case of multi-platform projects. Another important limitation that users of the Qt VS Tools have reported is the lack of support for importing Qt-related settings from shared property sheet files. This feature allows settings in VS projects to be shared within a team or organization, thus providing a single source for that information. Up to now, this was not possible to do with settings managed by the Qt VS Tools. To overcome these and other related limitations, all Qt settings — such as the version of Qt, which modules are to be used or the path to the generated sources — will now be stored as fully fledged project properties. The current Qt Settings dialog will be removed and replaced by a Qt Settings property page. It will thus be possible to set the values of all Qt settings according to configuration, as well as import those values from property sheet files.   A closer look An oversimplified primer might describe MSBuild as follows: An MSBuild project consists of references to source files and descriptions of actions to take in order to process those source files — these descriptions are called targets. The build process runs in the context of a project configuration (e.g. Debug, Release, etc.) A project may contain any number of configurations. Data associated to source files and the project itself is accessible through properties. MSBuild properties are name-value definitions, specified per configuration (i.e. each configuration has its own set of property definitions). Properties may apply to the project itself or to a specific file in the project, and can be defined globally or locally: Project scope properties are always global (e.g. the project’s output directory or target file name). Properties applying to source files can be defined globally, in which case the same value will apply to all files (e.g. default compiler warning level is defined globally at level 3). Such a global, file-scope definition may be overridden for a specific file by a locally defined property with the same name (e.g. one of the source files needs to be compiled with warning level 4). Global definitions are stored in the project file or imported from property sheet files. Local property definitions are stored in the project file, within the associated source file references. The Qt Visual Studio Tools extension integrates with the MSBuild project system by providing a set of Qt-specific targets that describe how to process files (e.g. a moc header) with the appropriate Qt tools. The current integration has some limitations, with respect to the capabilities of the MSBuild project system: User-managed Qt build settings are copied to project properties on change. Given this one-way synchronization, project properties may become out-of-sync with the corresponding Qt settings. The value of the Qt build settings is the same for all configurations, e.g. the same Qt build and modules will be used, regardless of the selected configuration. It is not possible to override properties in generated files like the meta-object source code output of moc. Qt settings can only be stored in the project file. As such, it is not possible to import Qt definitions from shared property sheets, e.g. a common Qt build shared across several projects. As discussed above, the solution for these limitations has been to make Qt settings fully fledged project properties. In this way, Qt settings will be guaranteed in-sync with all other properties in the project, and have the possibility of being defined differently for each build configuration. It will be possible to import Qt settings from property sheets, and the property page of Qt tools that generate C++ code, like moc, will now allow overriding compiler properties in generated files. The post Qt Visual Studio Tools 2.4 RC Released appeared first on Qt Blog. [Less]

We have released Qt Visual Studio Tools 2.4 RC (version 2.4.0); the installation package is available in the Qt download page. This version features an improved integration of Qt tools with the Visual Studio project system, addressing some ... [More] limitations of the current integration methods, most notably the inability to have different Qt settings for each project configuration, and lack of support for importing those settings from shared property sheets. [Less]

After our previous post related to the vision of the next major release of Qt, we felt that a paragraph to describe the Qt for Python story was not enough to share all the features and changes we have been considering for future releases.

After our previous post related to the vision of the next major release of Qt, we felt that a paragraph to describe the Qt for Python story was not enough to share all the features and changes we have been considering for future releases. Transition ... [More] to Qt 6 Exposing a huge framework such as Qt to another language is not an easy task and this was the main reason for the slow porting from the old PySide version in Qt 4 to Qt 5. Many developers hours were spent in adapting to new Qt 5 APIs, and more importantly, the binding generator tool such that everything can be handled properly. Now with Qt 6 things will be different, because the development of Qt for Python is progressing side-by-side to the C++ and QML stories in Qt 6. Hopefully, there will be a lot fewer surprises this time around. In fact, this effect can be seen with current 5.x releases, PySide2 is available almost at the same time as the Qt release, having in some cases a few days delays. Since the official release in Qt 5.12.0, the downloads of Qt for Python has been increasing day-by-day, which translates on the community adopting and enjoying the project. PyPi Downloads since the release of the first stable version 5.12.0 Why we are developing Qt for Python? The first lines of code which later evolved into the first Qt release date back to the early 90s, which coincidentally are roughly the same dates for the birth of Python. Both projects started out with the mindset, among other things, to make the developer’s life easier. The combination of both projects was always a good idea, and we have been seeing a great evolution of the Qt for Python community since the official release of PySide. We cannot fool ourselves and not take into account the other set of Qt bindings for Python out there, PyQt. Since the beginning of PySide, we have been trying to keep source compatibility with PyQt code. The PyQt users have also been supporting PySide, claiming that the main difference is mostly changing the import name. This makes the people behind the Qt for Python project really grateful. Both sets of bindings are quite mature, but we want to move one step further. Indeed we have taken some deviating decisions already like not exposing QVariant and other things. At the moment we have the following highlights for the two types of developers who use Qt for Python: C++ developers Fast prototyping: considering the requirements of certain projects, it is really handy to have a quick way of prototyping an idea without setting up too many things. Often they are just one pip install pyside2  call away. If after some iterations the application really needs a more performant behavior or a strongly typed language, the transition of the code to C++ will be straightforward. Writing an example application with PySide2 Embedding Python: an existing application could be extended by using Python, maybe via an add-ons/plug-in system, or even by having an embedded interpreter to manipulate other aspects of the application. Qt/C++ Application that has an embedded Python interpreter that execute the code written on the text field, being able to modify the Qt/C++ application itself. Python developers A robust framework for GUI development: there are many options to create graphical user interfaces with Python, but Qt provides a complete and robust framework that has been proven to fulfill most requirements for a nice GUI. We have been keeping track of other modules to contribute and also to get good ideas what we could include in the next releases. PySide2 installation process Binding generation: creating Python modules could be a difficult task, and at the moment many projects are trying to provide a simple interface to achieve this. Shiboken is getting more and more momentum to be able to handle any C++ project. Due to the experience of many costumers and users, our tool is sufficient to provide Python bindings for existing C++ projects. See for example what Gamry Instruments already did. Creating an example “Hello World” module with Shiboken. The future of Qt for Python We have been gathering many ideas since we made the first official Qt for Python/Pyside2 release. A couple of highlights are: Naming, many times the versioning of the module generated confusion for our users since it was an independent numbering compared to Python and Qt. Therefore we have decided to follow the Qt versioning from Qt6 onwards. The name itself will remain, hence the release will be PySide 6. Python2 support, from the beginning of 2020 Python2 will be no longer maintained, we decided to do the same and once PySide6 is released we will be dropping support for it. Internally this will solve many issues we currently have handling Python2 and Python3 at the same time. Pythonization, exposing a C++ API to a Python module can cause programmers to get a strange feeling while writing an application. We would like to go one step further and try to eliminate boilerplate code and provide a complementary python alike API. Tooling, having a separate set of tools for uic and rcc made little sense because we needed to keep track of all the changes in the official tools and port them to our variants. It appears to be better to integrate Python into the official tools. Hopefully, starting with PySide2 5.14 we will be directly able to use Qt’s uic and rcc, instead of the python wrappers. Meta Widgets and utilities, in favor of a quick-development we are trying to write a set of utilities and widgets which would make the life of Python developers easier. Out-of-the-box integration with modules like NumPy, Pandas, and others, are in our priority list too. Shiboken, adapting all the new features which Qt6 will include will be our main focus. Luckily we have been getting more contributors submitting bug fixes and new features. Subsequently, it is just a matter of time getting a even more mature Shiboken release. You can read about the more complete list on JIRA (PYSIDE-904), which we will love to have available in Qt 6 (we will do our best, we promise ☺). We truly thank the Qt for Python community. Most of the features we are currently working on came from them. With that in mind, we would like to encourage you to communicate your concerns and ideas on our IRC channel #qt-pyside. We would love to hear what you think, and how we can make Qt for Python better. The post Technical vision for Qt for Python appeared first on Qt Blog. [Less]

We are happy to announce the beta release of Qt Design Studio 1.3. Qt Design Studio is a UI design and development tool that enables designers and developers to rapidly prototype and develop complex UIs. Both designers and developers use Qt Design ... [More] Studio and this makes collaboration between the two a lot simpler and more streamlined. To get an impression, you should watch this video. Qt Design Studio 1.3 comes with a new advanced curve editor for animations. The new graphical animation curve editor The new curve editor allows adjusting the interpolation curves for multiple keyframes in a single view. This allows fine-tuning of very complex animations and full control over the slope of animations on keyframes. The Sketch Bridge is vastly improved and now supports Symbol Overrides. Symbol overrides in Sketch are now supported Symbol Overrides match perfectly with the concept of components and properties in QML. Using Symbol Overrides different instances of a Button can have different text properties for example. Those Symbol Overrides are now exported to QML. Another nice addition to the Sketch Bridge is the ability to exports SVGs instead of bitmap graphics. This way vector graphics are still scalable in QML after they have been exported. The controls of the property editor are now based on Qt Quick Controls 2 instead of Qt Quick Controls 1. The property editor now uses Qt Quick Controls 2 While implementing the controls using Qt Quick Controls 2 we also changed the design and cleaned up the property editor. The property editor now looks a lot cleaner and the usability of controls like the spin box has been improved a lot. The new spin box, for example, supports dragging and has an optional integrated slider. Last but not least many bugs were fixed and we improved the usability in many areas. For example, the property editor finally supports multi-selection. This allows setting properties on multiple items at once. Another addition really worth mentioning is the improved binding editor. The new binding editor is now based directly on the code editor widget and the usability, especially the code completion, has been vastly improved. This makes editing your bindings a lot more convenient. The binding editor is now based on the code editor With Qt Design Studio 1.3 there is also a free community version available, which lacks the Photoshop and Sketch bridges, though. The Beta of the Qt Design Studio 1.3 Community Edition can be found here. Getting Started You can find the latest online documentation for Qt Design Studio 1.3 here. The documentation is also available from inside Qt Design Studio. For Qt Design Studio we created tutorials as part of the documentation. The welcome page of Qt Design Studio contains examples and links to video tutorials to help you get started. Please post issues you find or suggestions you have in our bug tracker. The post Qt Design Studio 1.3 Beta released appeared first on Qt Blog. [Less]

We are happy to announce the beta release of Qt Design Studio 1.3.