Qt 5

I am a strong proponent of quick references or "cheat sheets" as an aid for recalling often-used information. In my career, I have created many work-related reference cards for colleagues and for my own personal use as well as for hobbies such as electronics and retro computing.

After a long and hard migration, the Qt Forums are up at http://forum.qt.io This is a quick introduction to what is new on the Qt Forum. I urge you to go and test the site yourself, that is the best way to learn. Logging in As with the Qt Wiki, the ... [More] Qt Forum uses Qt Account for logging in. In practice this means that you need a Qt Account. To create a Qt Account, you can go to the Qt Forum login page, click on the Qt Account check mark and get directed to the Qt Account login page. There at the bottom of the page, you will find a ‘Create new account’ link. Your username from qt-project.org has been reserved for your email, so when creating a Qt Account, please use the same email as you did on qt-project.org. This way you will get your own username and have your posting history and reputation intact as you move to Qt Forum. After creating your Qt Account, you can login to Qt Forum with it and start posting and replying to posts. On first login the new posts box will show that everything on the site is new. Technically that is true, as everything was just migrated over. You can safely go and mark all topics as read and start your experience fresh. Reputation and how it works The Qt Forum replaces the points in the old qt-project.org forums with reputation. You gain reputation when someone votes your post or reply up. There is a voting element under the title of the post with the tools for being notified of posts, favouriting a post and voting it up or down. The votes on a post can be used to search for  the most popular answers to a question. The points from qt-project.org were transferred to the Qt Forum with an adjustment (division by ten) to account for the different mechanism that reputation works with. At this point, we have set the system so that points only bring you fame and at reputation 500 thread moderation rights. The exact level needs to be checked as we move along, we don’t really know if 500 is a lot or little. Going forward the points can be used to earn badges and other fun stuff. Marking posts as solved and other tags The ‘thread tools’ at the bottom of a thread let the poster or moderators ‘mark a thread as solved’. This will add a ‘Solved’ tag to the post in the category view to help people find solved posts easily. When you start a new post, you can add tags to it. The tags will help people find the posts that they are interested in. They also help when searching the site. What the future holds We just went live after a marathon migration, but already we have some things that need fixing. First all the badges and groups from the old site need to be brought over. This takes a bit of work, but should be done by next week. The layout of the Qt Forum needs tweaks, the top level categories should provide more hints on what they contain. And we need to work out what to do with really long category names, now the ends just fade away. Also the login page needs some text editing, as the Qt Account is our only means of logging in. In terms of functionality, I would like for all us users to first get used to how the Qt Forum works and then start thinking on how to improve the experience. When you get an idea about what we should really have on the forums, please come over there and post a new topic to Qt.io website category. I’ll be there and we can talk how to improve the Qt Forum. The post New Qt Forum now open appeared first on Qt Blog. [Less]

We are happy to announce the release of Qt Creator 3.4 beta1! This release focuses more on bug fixing, polishing and under the hood changes, but nevertheless comes also with a range of new features. We added auto-completion for the signal and slot ... [More] parts in Qt 5 style connects, so you usually no longer need to look for the type manually. Just type the “&” and let auto-completion figure it out. Locator has a new filter, All Included C/C++ Files. It finds all files that are used in your projects by including them, even if they are not explicitly mentioned in your project. The filter is part of the default that is used when you just type in the Locator input field, and shares the shortcut string with Files in Any Project. Android integration now also supports 64 bit tool chains, and bare metal development can now also be done with generic projects. There have been many more enhancements, please see our change log for a more complete list. Users of the Professional or Enterprise edition will be happy to hear that we added experimental integration for Qt Test based auto tests and Qt Quick tests. You get another navigation pane Tests, which lists the tests defined in your project, provides ways to run individual or sets of tests, and nicely shows test results in a new Test Results output pane. To try it, open Help > About Plugins (Qt Creator > About Plugins, on OS X), turn on Utilities > AutoTest, and restart Qt Creator. We also moved the Clang static analyzer integration out of experimental state, and added support for using it in combination with MSVC (you need at least Clang 3.6 for this), and MinGW. You can also suppress individual diagnostics for a file in your project now. You find the opensource version on the Qt Project download page, and Enterprise packages on the Qt Account Portal. Please post issues in our bug tracker. You also can find us on IRC on #qt-creator on irc.freenode.net, and on the Qt Creator mailing list. The post Qt Creator 3.4 beta1 released appeared first on Qt Blog. [Less]

Qt Creator 3.3.2 is a small patch release that only fixes: deployment of the Clang code model plugin on OS X (QTCREATORBUG-14038) a crash with Qt Quick emulation layer when using fallback emulation (QTCREATORBUG-14031) Download here The post Qt Creator 3.3.2 released appeared first on Qt Blog.

NVIDIA’s Jetson TK1 is a powerful development board based on the Tegra K1 chip. It comes with a GPU capable of OpenGL 4.4, OpenGL ES 3.1 and CUDA 6.5. From Qt’s perspective this is a somewhat unorthodox embedded device because its customized Linux ... [More] system is based on Ubuntu 14.04 and runs the regular X11 environment. Therefore the approach that is typical for low and medium-end embedded hardware, running OpenGL-accelerated Qt apps directly on the framebuffer using the eglfs platform plugin, will not be suitable. In addition, the ability to do hardware-accelerated computing using CUDA is very interesting, especially when it comes to interoperating with OpenGL. Let’s take a look at how CUDA code can be integrated with a Qt-based application. The board Building Qt This board is powerful enough to build everything on its own without any cross-compilation. Configuring and building Qt is no different than in any desktop Linux environment. One option that needs special consideration however is -opengl es2 because Qt can be built either in a GLX OpenGL or EGL OpenGL ES configuration. For example, the following configures Qt to use GLX and OpenGL: configure -release -nomake examples -nomake tests while adding -opengl es2 requests the usage of EGL and OpenGL ES: configure -release -opengl es2 -nomake examples -nomake tests If you are planning to run applications relying on modern, non-ES OpenGL features, or use CUDA, then go for the first. If you however have some existing code from the mobile or embedded world relying on EGL or OpenGL ES then it may be useful to go for #2. The default platform plugin will be xcb, so running Qt apps without specifying the platform plugin will work just fine. This is the exact same plugin that is used on any ordinary X11-based Linux desktop system. Vsync gotchas Once the build is done, you will most likely run some OpenGL-based Qt apps. And then comes the first surprise: applications are not synchronized to the vertical refresh rate of the screen. When running for instance the example from qtbase/examples/opengl/qopenglwindow, we expect a nice and smooth 60 FPS animation with the rendering thread throttled appropriately. This unfortunately isn’t the case. Unless the application is fullscreen. Therefore many apps will want to replace calls like show() or showMaximized() with showFullScreen(). This way the thread is throttled as expected. A further surprise may come in QWidget-based applications when opening a popup or a dialog. Unfortunately this also disables synchronization, even though the main window still covers the entire screen. In general we can conclude that the standard embedded recommendation of sticking to a single fullscreen window is very valid for this board too, even when using xcb, although for completely different reasons. CUDA After installing CUDA, the first and in fact the only challenge is to tackle the integration of nvcc with our Qt projects. Unsurprisingly, this has been tackled by others before. Building on this excellent article, the most basic integration in our .pro file could look like this: ... # QT, SOURCES, HEADERS, the usual stuff CUDA_SOURCES = cuda_stuff.cu CUDA_DIR = /usr/local/cuda CUDA_ARCH = sm_32 # as supported by the Tegra K1 INCLUDEPATH = $$CUDA_DIR/include LIBS = -L $$CUDA_DIR/lib -lcudart -lcuda osx: LIBS = -F/Library/Frameworks -framework CUDA cuda.commands = $$CUDA_DIR/bin/nvcc -c -arch=$$CUDA_ARCH -o ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME} cuda.dependency_type = TYPE_C cuda.depend_command = $$CUDA_DIR/bin/nvcc -M ${QMAKE_FILE_NAME} cuda.input = CUDA_SOURCES cuda.output = ${QMAKE_FILE_BASE}_cuda.o QMAKE_EXTRA_COMPILERS = cuda In addition to Linux this will also work out of the box on OS X. Adapting it to Windows should be easy. For advanced features like reformatting nvcc’s error messages to be more of Creator’s liking, see the article mentioned above. A QOpenGLWindow-based application that updates an image via CUDA on every frame could now look something like the following. The approach is the same regardless of the OpenGL enabler in use: QOpenGLWidget or a custom Qt Quick item would operate along the same principles: call cudaGLSetGLDevice when the OpenGL context is available, register the OpenGL resources to CUDA, and then do map – invoke CUDA kernel – unmap – draw on every frame. Note that in this example we are using a single pixel buffer object. There are other ways to do interop, for example we could have registered the GL texture, got a CUDA array out of it and bound that either to a CUDA texture or surface. ... // functions from cuda_stuff.cu extern void CUDA_init(); extern void *CUDA_registerBuffer(GLuint buf); extern void CUDA_unregisterBuffer(void *res); extern void *CUDA_map(void *res); extern void CUDA_unmap(void *res); extern void CUDA_do_something(void *devPtr, int w, int h); class Window : public QOpenGLWindow, protected QOpenGLFunctions { public: ... void initializeGL(); void paintGL(); private: QSize m_imgSize; GLuint m_buf; GLuint m_texture; void *m_cudaBufHandle; }; ... void Window::initializeGL() { initializeOpenGLFunctions(); CUDA_init(); QImage img("some_image.png"); m_imgSize = img.size(); img = img.convertToFormat(QImage::Format_RGB32); // BGRA on little endian glGenBuffers(1, &m_buf); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, m_buf); glBufferData(GL_PIXEL_UNPACK_BUFFER, m_imgSize.width() * m_imgSize.height() * 4, img.constBits(), GL_DYNAMIC_COPY); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); m_cudaBufHandle = CUDA_registerBuffer(m_buf); glGenTextures(1, &m_texture); glBindTexture(GL_TEXTURE_2D, m_texture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_imgSize.width(), m_imgSize.height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } void Window::paintGL() { glClear(GL_COLOR_BUFFER_BIT); void *devPtr = CUDA_map(m_cudaBufHandle); CUDA_do_something(devPtr, m_imgSize.width(), m_imgSize.height()); CUDA_unmap(m_cudaBufHandle); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, m_buf); glBindTexture(GL_TEXTURE_2D, m_texture); // Fast path due to BGRA glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_imgSize.width(), m_imgSize.height(), GL_BGRA, GL_UNSIGNED_BYTE, 0); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); ... // do something with the texture update(); // request the next frame } ... The corresponding cuda_stuff.cu: #include #ifdef Q_OS_MAC #include #else #include #endif #include #include void CUDA_init() { cudaDeviceProp prop; int dev; memset(&prop, 0, sizeof(cudaDeviceProp)); prop.major = 3; prop.minor = 2; if (cudaChooseDevice(&dev, &prop) != cudaSuccess) puts("failed to choose device"); if (cudaGLSetGLDevice(dev) != cudaSuccess) puts("failed to set gl device"); } void *CUDA_registerBuffer(GLuint buf) { cudaGraphicsResource *res = 0; if (cudaGraphicsGLRegisterBuffer(&res, buf, cudaGraphicsRegisterFlagsNone) != cudaSuccess) printf("Failed to register buffer %u\n", buf); return res; } void CUDA_unregisterBuffer(void *res) { if (cudaGraphicsUnregisterResource((cudaGraphicsResource *) res) != cudaSuccess) puts("Failed to unregister resource for buffer"); } void *CUDA_map(void *res) { if (cudaGraphicsMapResources(1, (cudaGraphicsResource **) &res) != cudaSuccess) { puts("Failed to map resource"); return 0; } void *devPtr = 0; size_t size; if (cudaGraphicsResourceGetMappedPointer(&devPtr, &size, (cudaGraphicsResource *) res) != cudaSuccess) { puts("Failed to get device pointer"); return 0; } return devPtr; } void CUDA_unmap(void *res) { if (cudaGraphicsUnmapResources(1,(cudaGraphicsResource **) &res) != cudaSuccess) puts("Failed to unmap resource"); } __global__ void run(uchar4 *ptr) { int x = threadIdx.x blockIdx.x * blockDim.x; int y = threadIdx.y blockIdx.y * blockDim.y; int offset = x y * blockDim.x * gridDim.x; ... } void CUDA_do_something(void *devPtr, int w, int h) { const int blockSize = 16; // 256 threads per block run<<>>((uchar4 *) devPtr); } This is all that’s needed to integrate the power of Qt, OpenGL and CUDA. Happy hacking! The post Qt Weekly #28: Qt and CUDA on the Jetson TK1 appeared first on Qt Blog. [Less]

Heads up everyone, Qt Forum migration approaching. We will be doing the Qt Forum migration tomorrow, 4th March 2015. The timeline for the migration is set so that around 9 o’clock CET we’ll be taking the forums to a read-only state and then start ... [More] migrating the content. The migration has taken over five hours in the test runs that have been done, so you can count on a full day of no new posts or replies. During the migration the old forums will be visible and searchable, you just won’t be able to post to them. This is to have a clean migration, with no loose threads left on the old system. Once the content has been migrated, the old forums will be left in a read-only state, and redirects will be set up from the category and thread level to point to the new forum. The redirects are essential for search engines, quite a lot of the viewer traffic to the forums comes from different search engines. In the new forums, the login system will be Qt Account. We had an issue in the Qt Account registration page, where all the fields were marked as mandatory, that was an error, and now the fields have been set as optional, as they should be. Sorry about that. The new forums will be in the style of qt.io. Functionally the forum will be more modern, with voting on replies and topics coming right out of the box. Also topic tagging will be there right away. The new forum is based on NodeBB, is a modern actively developed platform, that has a good plugin system in place. There are many plugins available and if we really need something specific for the Qt Forums, there is the possibility to write a new one. The platform itself is being developed all the time, so we can also expect new features when new versions are released. Of course the basics will all be like they were, posting new threads, replying to threads and the familiar structure of sub-forums. I’m really looking forward to seeing the new Qt Forum in action. But first we need to do the migration tomorrow. The post Qt Forum migration coming up appeared first on Qt Blog. [Less]

When designing a user experience, we usually assume we are engaging a user’s center of attention, albeit short. We design an experience that will be a user’s primary focus or foreground activity for the duration of their engagement with a device, whether it be on a desktop, laptop, phone or tablet.

Apparently I haven’t blogged in nearly 5 years, wow! Most of my coding for fun in the last few years ended up being on internal systems to my previous company. Well all that’s in the past now, I’m about to start an adventure of traveling for 6 months ... [More] around Central/South America and South-east Asia. But just before that, had a couple days downtime so thought I would learn a little javascript and D3. You can see the result on: http://francis.giannaros.org/fb-graph/ (works in Chrome/Firefox, you have to click ‘Accept’ on the Facebook popup) Basically it will give you a graph visualisation of who you are tagged with on Facebook, and how your friend tags relate — at least all the ones available from the Facebook graph UI. You can use the date slider at the top to restrict the timeline — it’s interesting to see how people come and go in your life, at least as far as Facebook photos are concerned. Looking forward to future fun coding, maybe more directly in an established free software project again!       [Less]

Yesterday, we ended a great 3 days at Embedded World 2015 (Feb 24-26)  in Nuremberg, Germany. Considered the largest embedded development trade show, the event organizers estimated 30,000 exhibition visitors, over 1,500 congress participants and ... [More] around 900 exhibitors from over 35 countries. Personally, this is my 7th Embedded World with Qt and I have to say that this one has been our best one yet. I know, I say that every year, but the good thing is that we keep getting better every year; larger booth, more demos, more visitors, more companies sold on the fact that Qt is the best solution for embedded software development. We showcased Qt’s strength in embedded software development with a combination of demos and customer projects focused on Qt in Automotive, Qt in Automation, Qt in IoT, all telling/showing the story of how Qt is used in a real-life reference project or product. Qt’s role in embedded software development was further told by our “Under the Hood” demos highlighting several specific features and functions such as: Qt and OpenCV: Demonstrating how to easily & efficiently integrate computer vision or other computation or image processing algorithms with Qt Quick 2 and Qt Multimedia. Qt Creator in Action – Debugging and profiling: Demonstrating the power of Qt Creator IDE for one-click embedded deployment, and on-device debugging and profiling, Qt Quick Designer Qt UI capabilities, Qt WebEngine, Virtual Keyboard, multimedia capabilities, etc. Qt for QNX: Qt 5 applications and UIs on QNX Neutrino Qt for VxWorks: Qt 5 applications and UIs on VxWorks 7 This year, we had, like in the past 3 years, the live coding theater running daily on the hour from 10:00-16:00. We mixed it up this year with 3 different sessions: Introduction to Device Creation with Qt, Functionality Meets Productivity – Qt Developer Tools and Qt Features Overview. Thanks to our fearless and dedicated presenters. Well done! I was the most happiest to have a large portion of our booth demos come from our Qt Partners. They had an abundance of industry-specific demos in automotive, automation and IoT. Qt’s story was made stronger with our partners demonstrating the power of Qt and its many uses in the embedded space. Thanks to e-Gits, basysKom, Froglogic, KDAB, Adeneo Embedded and ICS for being with us. Without more hoopla, below are a few pictures from our booth and demos. If you came by our booth, thanks for visiting us! I would also like to say Thank You to The Qt Company staff onsite and again to our partners. Until next year.     The post Qt @ Embedded World 2015 appeared first on Qt Blog. [Less]

We are continuing our site unification to qt.io and we have now migrated the content from qt-project.org and today opened up the new Qt Wiki under qt.io. We invite all of you to start editing the new Qt Wiki under qt.io using the new MediaWiki ... [More] implementation. This is the first phase launch of the wiki under its new home, and therefore, you may find some things currently missing or not quite like they were before under qt-project.org. There are a variety of reasons for the latter. One main one is that our goal has been to make things easier than they have been before, providing wiki users a better editing experience, as well as more flexibility. MediaWiki is is one of the standard wiki formats, which is a more familiar format to use for many than the wiki that has been used under qt-project.org. MediaWiki benefits: Open source platform Active development of the platform A wide range of plugins to extend the wiki functionality Version control Better tools to follow and automate working on the wiki What you will find different In this new wiki, we will all be able to keep track of active editors directly in MediaWiki where it will be easier to follow who has edited what and when, as well have better control of versions.. Unfortunately, in this first phase, you will notice that the edit history of past articles has not been migrated over. As the old wiki system (Expression Engine) and MediaWiki are very different it has proven very difficult for the migration team to combine history from the old system into the new one. Our team will continue to look at this as we move along to see how we can best manage this. However, we do feel that manage wiki posts and edits from now and in the future will be much better, which outweighs in part the possible loss of past article history. Using Qt Account for editing The biggest change that the wiki introduction brings to you as a user, is that we are moving to using Qt Account as the identity and login service for the wiki. Qt Account is in essence the gateway to what we are building as a new Qt developer portal. We have already started using it for commercial evaluators and customers in the past year. Currently, the Qt Account web portal provides users with license information, account and payment options. It is also provides access to The Qt Company Support Center where commercial users can submit support issues. This is just the beginning, however. Our goal is to add valuable Qt information and resources, early access benefits, programs and the like into the Qt Account developer portal, making it your one-stop-shop for up-to-date Qt info and goodies. I’ll say something in big bold letters here: When you start to edit, you will need to create a Qt Account. Please make sure to use the same email as you had on qt-project.org, that way you will get your nickname to come along with you. Previously you logged into the wiki with your qt-project.org account details. Now you will be directed to the Qt Account login page. If you do not yet have a Qt Account, you can create an account from the login page. If you have been active on qt-project.org, your username has been reserved for you, if you use the same e-mail address as on qt-project.org. Our next item to migrate over is the Forums. When they move, they will also use Qt Account for login services. This is also the reason to use the same email on Qt Account as you did in qt-project.org. When the forums migrate under qt.io, your nickname and posts will move with you. However, please note that if you use a different email, we can’t connect your nickname automatically. Migrated content The old wiki contained over 3000 pages, which were processed and migrated to the new wiki. Some of the pages are quite old, but we know people work on old platforms and with old software releases, so we didn’t intentionally delete pages. Some old pages were not migrated, but that decision was based on browsing data. If the page had very low, or no, visitors in the past year, it was deemed to be of low value and sadly left behind. As with any migration there are some few issues. We are aware of challenges in at least the following: Image links are broken. Code blocks have been split into parts Special characters have been encoded as HTML character codes The way Category pages used to work is not the way MediaWiki works, so some Category pages contain double information Therefore, we would be grateful if you could help us with the following: Cleaning up the content If you maintain or edit a page(s), please have a look next time when you edit to see whether there are issues on the page. Open the same page on the old wiki and take a look if something is missing or if it looks wrong, and please fix it. We opened a wiki page where you can mark your page updated. Once you have looked at a page and edited it to an up-to-date state, please take a minute to add it tothe page list here. (I will be looking at the page edits and updating the page, but I do appreciate if you help me out there) A helpful page that the wiki itself provides is the list of pages with broken links. If you can help out, you can go through the pages listed there and grab the content/links from the old wiki and upload it to the new wiki. We now have proper image uploading in the new wiki, a great new benefit. Also if you do not wish to upload images to the Qt Wiki, we enabled linking to external images, by just pasting the direct image link to the wiki text, this should be practical for logos and images which may change. Also, if your favourite page did not make it to the new wiki due to very low visitor count in the past year, we encourage you to re-create the page on the new wiki. Old wiki still available The old wiki will stay open for reading until the end of March. That means that you have a month to make sure your favourite pages have not lost content in the move. After that, the old wiki will be retired and redirects will be set in place. We really appreciate your help in cleaning up the content and also welcome your feedback. It is lots of content, so we can’t do it alone. Thanks for your help and support! The post New Qt Wiki Now Available appeared first on Qt Blog. [Less]