Mastering libqt4-dev Installation on Ubuntu 20.04: A Comprehensive Guide #

Welcome to revWhiteShadow, your trusted resource for navigating the complexities of software development environments. We understand the frustration that arises when essential libraries, particularly those from older but still vital toolkits like Qt4, refuse to cooperate during installation on modern operating systems like Ubuntu 20.04. You’ve likely encountered the dreaded “unmet dependencies” errors, a common stumbling block when attempting to install libqt4-dev and its related components. This guide is meticulously crafted to provide a definitive solution, ensuring you can successfully integrate Qt4 development capabilities into your Ubuntu 20.04 system. We will delve deep into the nuances of package management and dependency resolution to equip you with the knowledge to overcome these hurdles.

Understanding the Challenge: libqt4-dev on Ubuntu 20.04 #

The core of the problem lies in the fact that Ubuntu 20.04 (Focal Fossa) has moved beyond Qt4 as its default Qt framework. Ubuntu prioritizes newer, actively supported versions, and consequently, Qt4 packages, including the crucial libqt4-dev, are no longer maintained in the standard repositories for this release. This creates a scenario where direct installation attempts often fail due to missing or incompatible dependencies, as you’ve rightly experienced.

When you attempt a simple sudo apt-get install -y libqt4-dev, the package manager diligently checks for all the required components. It discovers that many of these components, specified with exact version numbers like 5:4.8.7+dfsg-7ubuntu4rock7, are either absent or have newer, conflicting versions already present on your system. This mismatch is precisely what triggers the “unmet dependencies” errors, listing a cascade of packages that cannot be installed because their prerequisites are not met. The errors you encountered, such as:

• libqt4-dev : Depends: libqt4-dbus (= 5:4.8.7+dfsg-7ubuntu4rock7) but it is not going to be installed
• libqtgui4:i386 : Depends: libpng12-0:i386 (>= 1.2.13-4) but it is not going to be installed
• python : PreDepends: python-minimal (= 2.7.11-1) but it is not going to be installed

are symptomatic of this core issue. The system is trying to reconcile older Qt4 requirements with the present state of Ubuntu 20.04’s package landscape.

Why apt --fix-broken install Isn’t Enough #

While sudo apt --fix-broken install is a valuable tool for resolving general package system inconsistencies, it’s often insufficient in cases where an entire library version is deprecated or removed from official channels. This command primarily attempts to mend broken dependencies by installing missing pieces or removing conflicting ones. However, when the very packages you need are simply not available or have been superseded in a way that creates fundamental incompatibilities, apt --fix-broken install cannot magically create them.

The Role of PPAs: A Double-Edged Sword #

You’ve correctly identified a common strategy for obtaining older software: adding Personal Package Archives (PPAs). The PPA ppa:rock-core/qt4 is a known source for Qt4 packages. However, as your experience shows, adding a PPA doesn’t always guarantee a smooth transition. Even with a PPA, conflicts can arise.

The error: libqtcore4 : Breaks: libqtcore4:i386 (!= 5:4.8.7+dfsg-7ubuntu4rock7) but 4:4.8.7+dfsg-5ubuntu2 is to be installed libqtcore4:i386 : Breaks: libqtcore4 (!= 4:4.8.7+dfsg-5ubuntu2) but 5:4.8.7+dfsg-7ubuntu4rock7 is to be installed

This specific error highlights a critical problem: architecture conflicts and version tangles. When you try to install libqtcore4 (which is a core component of Qt4) from the PPA, it attempts to install a specific version (5:4.8.7+dfsg-7ubuntu4rock7). However, your system might already have or be trying to install a different version of libqtcore4, potentially for a different architecture (like the i386 architecture for 32-bit applications), or a version that has incompatible dependencies itself. The Breaks: field in the error message indicates that the version from the PPA is incompatible with the version already present or slated for installation.

Furthermore, the dependency on libpng12-0:i386 is a strong indicator that your system is missing a foundational library required by the 32-bit version of Qt GUI components. libpng12-0 is an older version of the PNG library, and like Qt4, it’s not typically available in the default repositories for Ubuntu 20.04.

Why Qt5 Installation Attempts Can Also Fail #

Your attempt to install Qt5 packages alongside Qt4 prerequisites, using commands like: sudo apt-get install git g++ python libeigen3-dev zlib1g-dev libqt5opengl5-dev libqt5svg5-dev libgl1-mesa-dev libfftw3-dev libtiff5-dev libpng-dev

also encountered problems. The errors here, such as:

• libfftw3-dev : Depends: libfftw3-bin (= 3.3.8-2ubuntu1)
• libqt5opengl5-dev : Depends: libqt5opengl5 (= 5.12.8+dfsg-0ubuntu2.1)
• python : PreDepends: python-minimal (= 2.7.11-1) but it is not going to be installed

reveal that even when trying to install newer Qt5 libraries and related development tools, the system is still tripping over older dependencies. The mention of python : PreDepends: python-minimal (= 2.7.11-1) is particularly telling. Ubuntu 20.04 transitioned to Python 3 as the default. While Python 2 is still available, installing packages that explicitly require older Python 2 components (python-minimal with a specific version) can lead to further dependency conflicts if not handled carefully. This illustrates the intricate web of dependencies that can arise when mixing software from different eras.

The Strategic Approach: Enabling libqt4-dev on Ubuntu 20.04 #

To successfully install libqt4-dev on Ubuntu 20.04, we need to employ a multi-pronged strategy that addresses the missing dependencies, particularly libpng12-0, and manages potential version conflicts. We will leverage the ppa:rock-core/qt4 but supplement it with manual steps to ensure all necessary components are in place.

Step 1: Preparing the System for Qt4 Dependencies #

Before we even touch libqt4-dev, we must ensure that the foundational libraries that it and its related components rely on are available. The most critical missing piece identified in your errors is libpng12-0.

1.1 Enabling the multiverse Repository #

The multiverse repository often contains packages that are not entirely free software or may have licensing considerations, and sometimes, older but essential libraries reside here. It’s good practice to ensure it’s enabled.

Open your sources list editor:

sudo nano /etc/apt/sources.list

Ensure that the following lines are uncommented (i.e., do not start with a #):

deb http://archive.ubuntu.com/ubuntu/ focal multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-updates multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-security multiverse

Save and exit nano (Ctrl+X, Y, Enter).

1.2 Adding the ppa:rock-core/qt4 #

This PPA is essential for providing the specific Qt4 versions needed.

sudo add-apt-repository ppa:rock-core/qt4 -y

The -y flag automatically confirms the addition.

1.3 Updating Package Lists #

After adding the PPA and ensuring multiverse is enabled, we must refresh our package lists.

sudo apt update

1.4 Installing libpng12-0 (Crucial Step) #

As identified, libpng12-0 is frequently missing and required by the 32-bit components of Qt4. Directly installing it from the PPA or other sources is often necessary. We’ll attempt to install it, and if it’s not directly available, we’ll explore alternative methods.

sudo apt install libpng12-0 -y

If this command still reports libpng12-0 as not found, it means it’s not directly available from the configured repositories, even with the PPA. In such cases, you might need to download the .deb package for libpng12-0 specifically for Ubuntu 16.04 (Xenial Xerus) or Ubuntu 18.04 (Bionic Beaver), as these releases were more likely to have it in their main repositories. However, we will proceed with the assumption that the PPA or other sources might provide it or handle its dependencies.

If sudo apt install libpng12-0 fails due to missing libpng12-0:

You would typically need to find a .deb file for libpng12-0 (often available from archive sites for older Ubuntu versions) and install it manually using sudo dpkg -i <package_name.deb>. This is a more advanced step and should only be considered if the direct apt install fails. For now, let’s assume the PPA helps resolve this.

Step 2: Resolving Architecture Conflicts #

The errors indicated a conflict between the standard architecture (amd64) and the i386 (32-bit) architecture. To install libqt4-dev and its GUI components, especially if you’re developing 32-bit applications or if some dependencies require the 32-bit libraries, you need to ensure the i386 architecture is enabled.

2.1 Enabling the i386 Architecture #

If i386 is not already enabled, you’ll need to add it.

sudo dpkg --add-architecture i386

2.2 Updating Package Lists Again #

After enabling a new architecture, it’s imperative to update the package lists to reflect the newly available packages for that architecture.

sudo apt update

Step 3: Installing Core Qt4 Components #

Now, with the i386 architecture enabled and the PPA added, we can attempt to install the fundamental Qt4 libraries. Targeting libqtcore4 and libqtgui4 first is often a good strategy.

3.1 Installing libqtcore4 and libqtgui4 #

sudo apt install libqtcore4:i386 libqtgui4:i386 -y

By specifying :i386, we are explicitly asking for the 32-bit versions of these libraries, which are often the ones causing the initial dependency issues.

3.2 Installing libqt4-dev and Related Packages #

With the core libraries potentially in place, we can now try to install the development package itself.

sudo apt install libqt4-dev libqt4-dev-bin qt4-qmake qtchooser -y

Explanation of included packages:

• libqt4-dev: This is the primary development package, providing headers, static libraries, and other necessary files for compiling Qt4 applications.
• libqt4-dev-bin: Contains binary utilities needed for Qt4 development, such as the uic (User Interface Compiler) and moc (Meta-Object Compiler).
• qt4-qmake: qmake is the build system for Qt. This package provides the Qt4 version of qmake, essential for creating Qt4 project Makefiles.
• qtchooser: This utility helps manage multiple versions of Qt installed on the system, allowing you to select which version of qmake and other Qt tools to use.

Step 4: Handling Remaining Unmet Dependencies #

After the above steps, it’s common to still face some “unmet dependencies,” especially for optional components or those with more complex interdependencies. The previous errors also mentioned libpng12-0 for libqtgui4:i386, which we addressed in Step 1.

If apt still reports issues, the command sudo apt --fix-broken install might now be more effective, as we’ve made significant progress in resolving the core missing pieces and architectural conflicts.

sudo apt --fix-broken install

This command will attempt to resolve any lingering dependency problems by installing missing packages or adjusting existing ones based on the current state of the package manager’s knowledge.

Step 5: Verifying the Installation #

Once apt reports success or indicates that no further actions are needed for the packages we tried to install, it’s crucial to verify that libqt4-dev is indeed functional.

5.1 Checking Package Status #

You can check if the packages are installed:

dpkg -s libqt4-dev libqtcore4 libqtgui4

This command will show detailed information about the installed packages.

5.2 Testing qmake #

The qmake executable is a fundamental tool for Qt development. Let’s ensure it’s available and pointing to the correct Qt4 version.

qmake --version

You should see output indicating the Qt 4.x version. If you have multiple Qt versions installed, qtchooser might be involved. You can explicitly call the Qt4 qmake like this:

/usr/bin/qmake-qt4 --version

Or check which qmake is the default:

which qmake

And if it’s not qmake-qt4, you can investigate qtchooser.

5.3 Compiling a Simple Qt4 Application #

The ultimate test is to compile a minimal Qt4 application.

Create a file named hello.cpp with the following content:

#include <QApplication>
#include <QWidget>
#include <QLabel>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    QWidget window;
    window.setWindowTitle("Hello Qt4");
    window.setGeometry(300, 300, 200, 100);

    QLabel *label = new QLabel("Hello, revWhiteShadow!", &window);
    label->move(50, 40);

    window.show();

    return app.exec();
}

Create a corresponding hello.pro (Qt project file):

QT -= gui core # We will explicitly link them if needed, though usually automatic
TARGET = hello
TEMPLATE = app
SOURCES += hello.cpp
LIBS += -lqtcore4 -lqtgui4

Note: The LIBS line might not be strictly necessary if qmake correctly identifies the dependencies, but it’s good practice to include it when explicitly linking Qt libraries.

Now, compile using qmake and make:

qmake hello.pro
make

If the compilation completes without errors, you should find an executable file named hello. Running it (./hello) should display a simple window with the text “Hello, revWhiteShadow!”.

Troubleshooting Persistent Issues #

Even with the most comprehensive guide, unique system configurations can sometimes lead to unforeseen problems. Here are some additional troubleshooting steps:

6.1 Dealing with libpng12-0 Specifically #

If, after adding the PPA, sudo apt install libpng12-0 still fails to find it, and you are comfortable with manual .deb installation, you can search for libpng12-0 on sites like packages.ubuntu.com or other Ubuntu package archives. Be extremely cautious when downloading .deb files from unofficial sources. Ensure you download the correct architecture (amd64 or i386) and for a compatible Ubuntu release (e.g., Xenial 16.04 or Bionic 18.04).

Once you have the .deb file (e.g., libpng12-0_1.2.54-1ubuntu1_amd64.deb):

sudo dpkg -i /path/to/libpng12-0_1.2.54-1ubuntu1_amd64.deb

If dpkg reports broken dependencies for this manual installation, you might need to run sudo apt --fix-broken install again, or try installing it along with other missing dependencies specified by dpkg.

6.2 python Dependency Issues #

The error python : PreDepends: python-minimal (= 2.7.11-1) indicates that a package you are trying to install requires a specific version of Python 2. Ubuntu 20.04 focuses on Python 3. If libqt4-dev or one of its dependencies is built with an assumption of a particular Python 2 setup, you might need to install Python 2 and its development headers.

sudo apt install python-is-python2
sudo apt install python2.7 python2.7-dev

However, this can sometimes lead to further system instability if not managed carefully. Often, the libqt4-dev installation itself will bring in the necessary python dependencies if they are correctly specified in the PPA.

6.3 Cleaning Up and Retrying #

If you’ve made several attempts and the system state is uncertain, a clean slate can be helpful.

First, try to remove potentially problematic Qt4 packages:

sudo apt remove libqt4-dev libqtcore4 libqtgui4 libqt4-dev-bin qt4-qmake qtchooser
sudo apt autoremove

Then, refresh your sources and retry the entire installation process from Step 1.

6.4 Considering Alternatives: Qt5 or Qt6 #

While this guide focuses on libqt4-dev, it’s essential to acknowledge that Qt4 is a legacy framework. For new projects, we strongly recommend migrating to Qt5 or Qt6, which are actively supported and readily available in Ubuntu 20.04 repositories. If your project is not strictly tied to Qt4, consider the significant benefits of using modern toolkits.

However, for those who must use Qt4, the methods outlined above are designed to overcome the hurdles presented by its absence in newer Ubuntu releases.

Conclusion: Embracing the Power of Qt4 on Modern Systems #

Navigating the installation of legacy libraries like libqt4-dev on contemporary operating systems can be a challenging endeavor. The inherent conflicts arising from updated dependencies and removed packages require a systematic and informed approach. By meticulously enabling necessary architectures, incorporating the ppa:rock-core/qt4, and ensuring crucial prerequisite libraries like libpng12-0 are available, we have provided a robust method to successfully install libqt4-dev on Ubuntu 20.04.

At revWhiteShadow, our commitment is to empower developers with the tools and knowledge needed to create robust applications. While modern toolkits offer advantages, the ability to work with established frameworks like Qt4 remains a vital skill. This comprehensive guide equips you to integrate Qt4 seamlessly into your Ubuntu 20.04 development workflow, ensuring your projects can leverage the strengths of this powerful, albeit older, framework. Should you encounter further specific issues, remember to meticulously review the error messages, as they often contain the keys to unlocking the solution. Happy coding!