Our company ships 2 Qt applications, for now, using Qt5.6 but in some time there will be more (using newer Qt versions). So the problem is, how to make them work all together with different Qt versions? We won't be able to rebuild all Qt apps shipped before, especially if there will be plenty of them. I don't think it's a good idea to place all necessary Qt libraries with each app because the repository size will grow fast. And I think it's just not wise to have many Qt dlls of the same version at one place. As long as I know, .NET solve such problem of different versions with assemblies installer, but I don't think it can help me with Qt. So any ideas of how can I solve it would be highly appreciated. Thanks
UPD: The system is Windows
Actually an answer is quite straightforward, you can ship one Qt version (binaries) as long as they are binary compatible. With each release Qt announce binary compatibility or non-compatibility, so if for whatever reasons you need to switch to newer version and ship new applications with newer not compatible version you might want to ship a new Qt DLL chain.. This can be achived differently (depends on how you layout you install), for example you can have a common lib dir with sub directories based on Qt version which you will extend. (of course you will need appropriate PATHS set then running different applications) :
app\
app\app01
app\app02
...
lib\
lib\Qt5.6.1
lib\Qt5.7.0
etc, then you will have (for example) to wrap your exe files to .bat like:
run.bat
SET PATH=....\lib\Qt5.6.1\
app01.exe
etc..
it's all depends on your install layout and goals
Related
Having some issues with the online installers, I would like to use the offline installers to create an installation with multiple Kits and versions. I would like to be able to switch between MinGW, Visual Studio and mobile targets just by switching between the Kits, and I would like to have the latest two Qt versions (5.4 and 5.5) available for choosing.
However, there are some issues with this:
The offline installers are only available with a single Kit. Installing the same version twice with different Kits to the same directory seems to mix up Qt Creator's available Kits, and the installation seems to replace the previous one in Windows' list of installed software.
Every single setup comes with its own Qt creator instance, and only there the Kits are available as desired. So when installing in seperate directories, a lot of duplicate stuff is installed.
I tried copying together kits from a few installations, but running a big installation, copying part of it and then patching the kit with the installer again seems to be a bit weird ...
Isn't there an easier way to get a consistent installation on Windows with the offline installers?
First of all, I believe this issue is not as big as I thought: Even the multiple Qt Creator installations that come with every offline installer do not create any bigger conflicts. The only thing that might happen with these: When starting different versions of Creator after each other, one might see conflicts with the settings files of QtCreator which are always stored in %APPDATA%/QtProject: Using an older version can corrupt the newer one.
That said, I believe the simplest way to work with different Qt Versions is to use a new installation folder for every Qt version, and to use a separate installation of QtCreator. Then one of course has to set up debuggers, Qt Versions and Kits manually for each new installation. The benefit of this is that one can also simply remove any version one doesn't need anymore - without risking to remove the used Qt Creator.
Qt creator automatically seems to detect and select appropriate help files + examples from the installed Qt versions.
Compared to using the online installer, the installation needs more space for the multiple Qt Creators, however installations are really separate from each other, so there is no risk in messing up anything by using the online installers again when a new version comes: the online installer only gives the latest two major versions with their latest minor version, and when changing from one minor version to another, one might want to compare results between these.
Recently we moved to QT 5.0.2 from QT4.8. Our project now needs more DLL files than the earlier. It requires qml, opengl, printer modules. However we did not use any of these modules in our application. The size of exe file increased due to additional DLLs.
QT-= qml opengl -> did not exclude this module from our application.
Are these additional DLLs are compulsory for Qt 5.0.2 ? Is there any way to come out from this? We need to exclude these dlls to reduce exe size.
Some of the modules you use may be dependent on those you don't, which means your project depends on them indirectly. For example, by default, some modules (QtWebKit, QtMultimedia) utilize ANGLE which uses OpenGL. You can try to trace those dependencies by using a program named Dependency Walker (available here). The Qt GUI has changed a lot since 4.8, and there are now separate modules for printing and other functions (see here).
Sources:
Qt 5 on Windows ANGLE and OpenGL
Qt 5 Deployment on Windows
By the way, someone has (had) a similar problem: http://www.qtcentre.org/archive/index.php/t-52102.html. (Unfortunately, there is no solution in that link.)
It turned out that this is actually a bug in Qt.
I have multiple installations of Qt4 on my Windows XP SP2 machine and have installed Qt Creator 2.1 today. However, running the project (.pro) files spawns the oldest version of Qt Designer installed (the one installed in 2009 together with the rest of the framework).
Since
I would not like to remove any previous installations of Qt
and for some obscure reason even if I explicitly ask Windows Explorer to always use the version I need it does not
I would like to give up a bit and just sript the needed behaviour in a .bat file like:
e:\path\to\qtcreator.exe %1
This opens Qt Creator, but something seems to prevent it from treating the .pro file properly (in short, the project does not "open" as it should).
Qt documents have a page on the matter at Qt Creator: Using Command Line Options, but it seems to ignore the topic in question.
Since Qt (being as excellent framework as it is) is also known to have its quirks (like that of qmake), I wonder, may be there is an undocumented way to solve my problem?
(Another way to fix the thing would of course be to make the correct version of Qt Designer run, but frankly I'd prefer the "hard-wired" solution since the mechanisms provided by Qt itself are still a bit unreliable.)
The libraries and tools used for a particular project (and a configuration in it) is set in the Projects panel in Qt Creator:
http://doc.qt.io/qtcreator/creator-build-settings.html
Selecting the Qt version to use with a project should force it to run the Designer that's part of the version. If it doesn't, then you should report it as a bug.
Whats the best way to deploy a QT app? I've read the documentation hosted at trolltech but is it better to link with a static library or the dynamic libraries and have the user install the framework? I don't really want anyone using my app to have to download a 160mb framework just to run a simple gui frontend.
On OS X it's a good way to do a dynamic build and post-process the resulting ".app" with the macdeployqt tool which comes with Qt starting with 4.5.
This will copy the Qt frameworks used by your application into the application bundle, which results in a larger package than building a static version of your application.
Here is what you can do to make sure you get the smallest file size possibly in a dynamic build:
First off, make sure you only include the stuff you need (in the project.pro file's QT += core gui network xml lines).
Open the application bundle and remove any unneeded "Qt Plugins" from the bundle. macdeployqt automatically compies all the Qt plugins in there, which can be kind of bulky.
Make sure you are building your application in release mode. Otherwise your application might be linked against the debug libraries of the Qt4 framework, and they are really big (for instance, well over 90 MB for the debug library vs. 16 MB of a release variant without debugging symbols). This might be what happened in your case.
If you have a large application binary, you can use UPX to compress your executable file by 40-50%.
Other than that, you should use compressed disk images to deploy your application.
One of my projects uses QtGui, QtNetwork, QtCore and QtXml and the resulting bundle is about 16 MB in size.
Hope that helps.
Unfortunately you will have to include the Qt libraries you need into your own bundle, as you cannot expect your users to have Qt installed on Mac (whereas on Linux packaging systems allow you to require at least a given version of Qt.
There is a nice tool to help you with that, which is called macdeployqt. You just need to invoke it on your bundle application and it will pack the required libraries, changing the linkage of your binary to refer to them. Without it, making bundles for Mac is a real pain (it still is, but considerably less though).
http://doc.trolltech.com/4.6/deployment-mac.html#the-mac-deployment-tool
Afterwards, you can make a .dmg image as you would do with any other app. There is an option in macdeployqt that builds a basic one.
On Linux, it's better to rely on the OS's copy of Qt, as it's almost certainly installed - for OS X, almost all apps use a statically compiled library.
Is there a quick, straightforward way to make a Qt application into an executable? I attempted to follow the instructions at http://doc.qt.digia.com/4.1/deployment-windows.html but have been unsuccesfull thus far; I'm unable to Any help would be much appreciated. Thanks!
I always use CMake to build Qt projects, it's easy, free and cross platform. Guide : Compiling Qt4 apps with CMake. CMake also come with CPack to easly make installer for Windows, Mac and Linux.
I agree with chmod700 about the Qt Creator suggestion, it's not my favorite IDE but it's still really nice and easy.
Do you mean an installer package? I assume you are able to compile, link, and run your app and you mean how do you package it up for others.
http://installbuilder.bitrock.com/ <-- special handling of Qt based projects but costs $
http://www.jrsoftware.org/isinfo.php <-- my personal favorite and it's free (can be rough to learn advanced features though)
Though if you mean how do you build your app, you may want to try the new Qt Creator (http://www.qtsoftware.com/products/appdev/developer-tools/developer-tools#qt-tools-at-a) which will setup build targets for you and really makes desktop Qt dev a snap. Also if you're still using 4.1, you can now use 4.5 under the LGPL on all platforms making it almost a no-brainer to upgrade.
I'm not sure if I understand your problem. Assuming you're using MinGW, it's really easy and quite straightforward:
get the Qt sources and unpack them to some folder (f.e. c:\Qt\4.5.0-static)
install MinGW. Make sure the MinGW executable folder is in the %PATH% variable.
open a cmd windows, go to the Qt sources and run configure -static. You can add other config options if you like to, but usually you don't need that.
when building Qt finished, go to your application sources, open a cmd window and run the qmake of your built Qt installation -- i.e. c:\Qt\4.5.0-static\bin\qmake in the example given above.
run make
you get a statically linked binary in the end (you might want to check it with Dependency Walker).
Doing the same using Visual Studio is pretty similar.
Or do you want to build dynamically and create an installer package?