qt5: remove makeQtWrapper

pkgs/applications/audio/audacious/qt-5.nix

···
 {
-  stdenv, lib, fetchurl,
-  gettext, makeQtWrapper, pkgconfig,
+  mkDerivation, lib, fetchurl,
+  gettext, pkgconfig,
   qtbase,
   alsaLib, curl, faad2, ffmpeg, flac, fluidsynth, gdk_pixbuf, lame, libbs2b,
   libcddb, libcdio082, libcue, libjack2, libmad, libmcs, libmms, libmodplug,
···
   };
 in
 
-stdenv.mkDerivation {
+mkDerivation {
   inherit version;
   name = "audacious-qt5-${version}";
 
   sourceFiles = lib.attrValues sources;
   sourceRoots = lib.attrNames sources;
 
-  nativeBuildInputs = [
-    gettext makeQtWrapper pkgconfig
-  ];
+  nativeBuildInputs = [ gettext pkgconfig ];
 
   buildInputs = [
     # Core dependencies
···
       fi
 
     done
-
-    source $stdenv/setup
-    wrapQtProgram $out/bin/audacious
-    wrapQtProgram $out/bin/audtool
   '';
 
-  enableParallelBuilding = true;
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Audio player";
     homepage = http://audacious-media-player.org/;
     maintainers = with maintainers; [ ttuegel ];

pkgs/applications/audio/cantata/default.nix

···
 { stdenv, fetchFromGitHub, cmake, vlc
 , withQt4 ? false, qt4
-, withQt5 ? true, qtbase, qtsvg, qttools, makeQtWrapper
+, withQt5 ? true, qtbase, qtsvg, qttools
 
 # Cantata doesn't build with cdparanoia enabled so we disable that
 # default for now until I (or someone else) figure it out.
···
     ++ stdenv.lib.optional withMusicbrainz libmusicbrainz5
     ++ stdenv.lib.optional (withTaglib && withDevices) udisks2;
 
-  nativeBuildInputs = stdenv.lib.optional withQt5 makeQtWrapper;
-
   cmakeFlags = stdenv.lib.flatten [
     (fstat withQt5 "QT5")
     (fstats withTaglib [ "TAGLIB" "TAGLIB_EXTRAS" ])
···
   # This is already fixed upstream but not released yet. Maybe in version 2.
   preConfigure = ''
     sed -i -e 's/STRLESS/VERSION_LESS/g' cmake/FindTaglib.cmake
-  '';
-
-  postInstall = stdenv.lib.optionalString withQt5 ''
-    wrapQtProgram "$out/bin/cantata"
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/audio/dfasma/default.nix

···
-{ stdenv, fetchFromGitHub, fftw, libsndfile, qtbase, qtmultimedia, qmake, makeQtWrapper }:
+{ stdenv, fetchFromGitHub, fftw, libsndfile, qtbase, qtmultimedia, qmake }:
 
 let
 
···
 
   buildInputs = [ fftw libsndfile qtbase qtmultimedia ];
 
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ qmake ];
 
   postPatch = ''
     substituteInPlace dfasma.pro --replace '$$DFASMAVERSIONGITPRO' '${version}'
···
   '';
 
   enableParallelBuilding = true;
-
-  postInstall = ''
-    wrapQtProgram "$out/bin/dfasma"
-  '';
 
   meta = with stdenv.lib; {
     description = "Analyse and compare audio files in time and frequency";

pkgs/applications/audio/sonic-visualiser/default.nix

···
 
 { stdenv, fetchurl, alsaLib, bzip2, fftw, libjack2, libX11, liblo
 , libmad, libogg, librdf, librdf_raptor, librdf_rasqal, libsamplerate
-, libsndfile, pkgconfig, libpulseaudio, makeQtWrapper, qtbase, redland
+, libsndfile, pkgconfig, libpulseaudio, qtbase, redland
 , qmake, rubberband, serd, sord, vampSDK, fftwFloat
 }:
 
···
       libX11
     ];
 
-  nativeBuildInputs = [ makeQtWrapper pkgconfig qmake ];
+  nativeBuildInputs = [ pkgconfig qmake ];
 
   configurePhase = ''
     for i in sonic-visualiser svapp svcore svgui;
···
     mkdir -p $out/{bin,share/sonic-visualiser}
     cp sonic-visualiser $out/bin/
     cp -r samples $out/share/sonic-visualiser/
-    wrapQtProgram "$out/bin/sonic-visualiser"
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/editors/kdevelop5/kdevelop.nix

···
-{ mkDerivation, lib, fetchurl, cmake, gettext, pkgconfig, extra-cmake-modules, wrapGAppsHook
+{ mkDerivation, lib, fetchurl, cmake, gettext, pkgconfig, extra-cmake-modules
 , qtquickcontrols, qtwebkit, qttools, kde-cli-tools
 , kconfig, kdeclarative, kdoctools, kiconthemes, ki18n, kitemmodels, kitemviews
 , kjobwidgets, kcmutils, kio, knewstuff, knotifyconfig, kparts, ktexteditor
···
   };
 
   nativeBuildInputs = [
-    cmake gettext pkgconfig extra-cmake-modules makeWrapper wrapGAppsHook
+    cmake gettext pkgconfig extra-cmake-modules makeWrapper
   ];
 
   buildInputs = [

pkgs/applications/editors/kdevelop5/kdevplatform.nix

···
-{ stdenv, fetchurl, fetchpatch, cmake, gettext, pkgconfig, extra-cmake-modules, makeQtWrapper
+{ stdenv, fetchurl, fetchpatch, cmake, gettext, pkgconfig, extra-cmake-modules
 , boost, subversion, apr, aprutil
 , qtscript, qtwebkit, grantlee, karchive, kconfig, kcoreaddons, kguiaddons, kiconthemes, ki18n
 , kitemmodels, kitemviews, kio, kparts, sonnet, kcmutils, knewstuff, knotifications
···
 in
 stdenv.mkDerivation rec {
   name = "${pname}-${version}";
-  
+
   src = fetchurl {
     url = "mirror://kde/stable/kdevelop/${version}/src/${name}.tar.xz";
     sha256 = "3159440512b1373c1a4b35f401ba1f81217de9578372b45137af141eeda6e726";
···
     })
   ];
 
-  nativeBuildInputs = [ cmake gettext pkgconfig extra-cmake-modules makeQtWrapper ];
+  nativeBuildInputs = [ cmake gettext pkgconfig extra-cmake-modules ];
 
-  propagatedBuildInputs = [ ];
   buildInputs = [
     boost subversion apr aprutil
     qtscript qtwebkit grantlee karchive kconfig kcoreaddons kguiaddons kiconthemes

pkgs/applications/editors/neovim/qt.nix

···
-{ stdenv, fetchFromGitHub, cmake, doxygen
-, libmsgpack, makeQtWrapper, neovim, pythonPackages, qtbase }:
+{ stdenv, fetchFromGitHub, cmake, doxygen, makeWrapper
+, libmsgpack, neovim, pythonPackages, qtbase }:
 
 stdenv.mkDerivation rec {
   name = "neovim-qt-${version}";
···
     jinja2 msgpack python
   ]);
 
-  nativeBuildInputs = [ cmake doxygen makeQtWrapper ];
+  nativeBuildInputs = [ cmake doxygen makeWrapper ];
 
   enableParallelBuilding = true;
 
···
   '';
 
   postInstall = ''
-    wrapQtProgram "$out/bin/nvim-qt" \
+    wrapProgram "$out/bin/nvim-qt" \
       --prefix PATH : "${neovim}/bin"
   '';
 

pkgs/applications/graphics/ipe/default.nix

···
-{ stdenv, fetchurl, pkgconfig, zlib, freetype, cairo, lua5, texlive, ghostscript
+{ stdenv, fetchurl, makeWrapper, pkgconfig, zlib, freetype, cairo, lua5, texlive, ghostscript
 , libjpeg, qtbase
-, makeQtWrapper
 }:
 
 stdenv.mkDerivation rec {
···
   LUA_PACKAGE = "lua";
 
   buildInputs = [
-    libjpeg pkgconfig zlib qtbase freetype cairo lua5 texlive ghostscript
+    libjpeg zlib qtbase freetype cairo lua5 texlive ghostscript
   ];
 
-  nativeBuildInputs = [ makeQtWrapper ];
+  nativeBuildInputs = [ makeWrapper pkgconfig ];
 
   postFixup = ''
     for prog in $out/bin/*; do
-      wrapQtProgram "$prog" --prefix PATH : "${texlive}/bin"
+      wrapProgram "$prog" --prefix PATH : "${texlive}/bin"
     done
   '';
 

pkgs/applications/graphics/krita/default.nix

···
-{ stdenv, lib, fetchurl, cmake, extra-cmake-modules, makeQtWrapper
+{ mkDerivation, lib, fetchurl, cmake, extra-cmake-modules
 , karchive, kconfig, kwidgetsaddons, kcompletion, kcoreaddons
 , kguiaddons, ki18n, kitemmodels, kitemviews, kwindowsystem
 , kio, kcrash
···
 , openjpeg, opencolorio, vc, poppler_qt5, curl, ilmbase
 }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "krita-${version}";
   ver_min = "3.1.3";
   version = "${ver_min}";
···
     sha256 = "125js6c8aw4bqhs28pwnl3rbgqx5yx4zsklw7bfdhy3vf6lrysw1";
   };
 
-  nativeBuildInputs = [ cmake extra-cmake-modules makeQtWrapper ];
+  nativeBuildInputs = [ cmake extra-cmake-modules ];
 
   buildInputs = [
     karchive kconfig kwidgetsaddons kcompletion kcoreaddons kguiaddons
···
 
   NIX_CFLAGS_COMPILE = [ "-I${ilmbase.dev}/include/OpenEXR" ];
 
-  enableParallelBuilding = true;
-
-  postInstall = ''
-    for i in $out/bin/*; do
-      wrapQtProgram "$i"
-    done
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A free an open source painting application";
     homepage = "https://krita.org/";
     maintainers = with maintainers; [ abbradar ];

pkgs/applications/graphics/photoqt/default.nix

···
-{ stdenv, fetchurl, cmake, makeQtWrapper, exiv2, graphicsmagick
+{ stdenv, fetchurl, cmake, exiv2, graphicsmagick
 , qtbase, qtdeclarative, qtmultimedia, qtquickcontrols, qttools
 }:
 
···
     sha256 = "0j2kvxfb5pd9abciv161nkcsyam6n8kfqs8ymwj2mxiqflwbmfl1";
   };
 
+  nativeBuildInputs = [ cmake ];
   buildInputs = [
-    cmake makeQtWrapper qtbase qtquickcontrols qttools exiv2 graphicsmagick
+    qtbase qtquickcontrols qttools exiv2 graphicsmagick
     qtmultimedia qtdeclarative
   ];
 
   preConfigure = ''
     export MAGICK_LOCATION="${graphicsmagick}/include/GraphicsMagick"
-  '';
-
-  postInstall = ''
-    wrapQtProgram $out/bin/photoqt
   '';
 
   meta = {

pkgs/applications/graphics/renderdoc/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, qtbase, qtx11extras
-, pkgconfig, xorg, makeQtWrapper, vulkan-loader
+{ stdenv, fetchFromGitHub, cmake, makeWrapper, pkgconfig
+, qtbase, qtx11extras, vulkan-loader, xorg
 }:
 
 stdenv.mkDerivation rec {
···
   buildInputs = [
     qtbase xorg.libpthreadstubs xorg.libXdmcp qtx11extras vulkan-loader
   ];
-  nativeBuildInputs = [ cmake makeQtWrapper pkgconfig ];
+  nativeBuildInputs = [ cmake makeWrapper pkgconfig ];
 
   cmakeFlags = [
     "-DBUILD_VERSION_HASH=${src.rev}-distro-nix"
···
     mkdir $out/bin/.bin
     mv $out/bin/qrenderdoc $out/bin/.bin/qrenderdoc
     ln -s $out/bin/.bin/qrenderdoc $out/bin/qrenderdoc
-    wrapQtProgram $out/bin/qrenderdoc --suffix LD_LIBRARY_PATH : $out/lib --suffix LD_LIBRARY_PATH : ${vulkan-loader}/lib
+    wrapProgram $out/bin/qrenderdoc --suffix LD_LIBRARY_PATH : $out/lib --suffix LD_LIBRARY_PATH : ${vulkan-loader}/lib
     mv $out/bin/renderdoccmd $out/bin/.bin/renderdoccmd
     ln -s $out/bin/.bin/renderdoccmd $out/bin/renderdoccmd
     wrapProgram $out/bin/renderdoccmd --suffix LD_LIBRARY_PATH : $out/lib --suffix LD_LIBRARY_PATH : ${vulkan-loader}/lib

pkgs/applications/kde/ark/default.nix

···
 {
-  mkDerivation, lib, config, wrapGAppsHook,
+  mkDerivation, lib, config, makeWrapper,
 
   extra-cmake-modules, kdoctools,
 
···
 
 mkDerivation {
   name = "ark";
-  nativeBuildInputs = [
-    extra-cmake-modules kdoctools wrapGAppsHook
-  ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools makeWrapper ];
   propagatedBuildInputs = [
     khtml ki18n kio karchive kconfig kcrash kdbusaddons kiconthemes kservice
     kpty kwidgetsaddons libarchive kitemmodels
   ];
-  preFixup =
+  postFixup =
     let
       PATH =
         lib.makeBinPath
         ([ p7zip unzipNLS zip ] ++ lib.optional unfreeEnableUnrar unrar);
     in ''
-      gappsWrapperArgs+=(--prefix PATH : "${PATH}")
+      wrapProgram "$out/bin/ark" --prefix PATH: "${PATH}"
     '';
   meta = {
     license = with lib.licenses;

pkgs/applications/kde/filelight.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kio, kparts, kxmlgui, qtscript, solid
 }:
 
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = with lib.maintainers; [ fridh vcunat ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [
     kio kparts kxmlgui qtscript solid
   ];

pkgs/applications/kde/gwenview.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
-  baloo, exiv2, kactivities, kdelibs4support, kio, kipi-plugins, lcms2,
-  libkdcraw, libkipi, phonon, qtimageformats, qtsvg, qtx11extras
+  extra-cmake-modules, kdoctools,
+  exiv2, lcms2,
+  baloo, kactivities, kdelibs4support, kio, kipi-plugins, libkdcraw, libkipi,
+  phonon, qtimageformats, qtsvg, qtx11extras
 }:
 
 mkDerivation {
···
     license = with lib.licenses; [ gpl2 fdl12 ];
     maintainers = [ lib.maintainers.ttuegel ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ exiv2 lcms2 ];
   propagatedBuildInputs = [
-    baloo kactivities kdelibs4support kio exiv2 lcms2 libkdcraw
-    libkipi phonon qtimageformats qtsvg qtx11extras
+    baloo kactivities kdelibs4support kio libkdcraw libkipi phonon
+    qtimageformats qtsvg qtx11extras
   ];
   propagatedUserEnvPkgs = [ kipi-plugins ];
 }

pkgs/applications/kde/k3b.nix

···
-{ mkDerivation, lib, wrapGAppsHook, extra-cmake-modules
+{ mkDerivation, lib
+, extra-cmake-modules, kdoctools, makeWrapper
 , qtwebkit
-, libkcddb, kcmutils, kdoctools, kfilemetadata, knewstuff, knotifyconfig, solid, kxmlgui
+, libkcddb, kcmutils, kfilemetadata, knewstuff, knotifyconfig, solid, kxmlgui
 , flac, lame, libmad, libmpcdec, libvorbis
 , libsamplerate, libsndfile, taglib
 , cdparanoia, cdrdao, cdrtools, dvdplusrwtools, libburn, libdvdcss, libdvdread, vcdimager
···
     maintainers = with maintainers; [ sander phreedom ];
     platforms = platforms.linux;
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools makeWrapper ];
   propagatedBuildInputs = [
     # qt
     qtwebkit
···
     # others
     ffmpeg libmusicbrainz2
   ];
-  preFixup =
+  postFixup =
     let k3bPath = lib.makeBinPath [
           cdrdao cdrtools dvdplusrwtools libburn normalize sox transcode
           vcdimager
         ];
     in ''
-      gappsWrapperArgs+=(--prefix PATH : "${k3bPath}")
+      wrapProgram "$out/bin/k3b" --prefix PATH : "${k3bPath}"
     '';
 }

pkgs/applications/kde/kate.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kactivities, kconfig, kcrash, kdbusaddons, kguiaddons, kiconthemes, ki18n,
   kinit, kio, kitemmodels, kjobwidgets, knewstuff, knotifications, konsole,
   kparts, ktexteditor, kwindowsystem, kwallet, kxmlgui, libgit2,
···
     license = with lib.licenses; [ gpl3 lgpl3 lgpl2 ];
     maintainers = [ lib.maintainers.ttuegel ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ libgit2 ];
   propagatedBuildInputs = [
     kactivities ki18n kio ktexteditor kwindowsystem plasma-framework
     qtscript kconfig kcrash kguiaddons kiconthemes kinit kjobwidgets kparts
     kxmlgui kdbusaddons kwallet kitemmodels knotifications threadweaver
-    knewstuff libgit2
+    knewstuff
   ];
   propagatedUserEnvPkgs = [ konsole ];
 }

pkgs/applications/kde/kcachegrind.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kio, ki18n,
   perl, python, php
 }:
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = with lib.maintainers; [ orivej ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [ kio ];
   buildInputs = [ perl python php ki18n ];
-  preFixup = ''
-    gappsWrapperArgs+=(--prefix PATH : "${lib.makeBinPath [ perl php python]}")
-  '';
 }

pkgs/applications/kde/kcalc.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kconfig, kconfigwidgets, kguiaddons, kinit, knotifications, gmp
 }:
 
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = [ lib.maintainers.fridh ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   buildInputs = [ gmp ];
   propagatedBuildInputs = [
     kconfig kconfigwidgets kguiaddons kinit knotifications

pkgs/applications/kde/kcolorchooser.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, wrapGAppsHook,
+  extra-cmake-modules,
   ki18n, kwidgetsaddons, kxmlgui
 }:
 
···
     license = with lib.licenses; [ mit ];
     maintainers = [ lib.maintainers.ttuegel ];
   };
-  nativeBuildInputs = [ extra-cmake-modules wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules ];
   buildInputs = [ ki18n ];
   propagatedBuildInputs = [ kwidgetsaddons kxmlgui ];
 }

pkgs/applications/kde/kcontacts.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, ki18n,
+  extra-cmake-modules,
+  ki18n,
   kcoreaddons, kconfig, kcodecs
 }:
 

pkgs/applications/kde/kdenlive.nix

···
 , lib
 , extra-cmake-modules
 , kdoctools
-, wrapGAppsHook
 , qtscript
 , kactivities
 , kconfig
···
   nativeBuildInputs = [
     extra-cmake-modules
     kdoctools
-    wrapGAppsHook
   ];
   buildInputs = [
-    qtscript
     kconfig
     kcrash
+    kdbusaddons
+    kfilemetadata
     kguiaddons
+    ki18n
     kiconthemes
     kinit
-    kdbusaddons
     knotifications
     knewstuff
     karchive
···
     kplotting
     ktextwidgets
     mlt
+    phonon-backend-gstreamer
+    qtquickcontrols
+    qtscript
     shared_mime_info
     libv4l
     ffmpeg
   ];
-  propagatedBuildInputs = [
-    kactivities kconfig kcrash kguiaddons kiconthemes kinit kio kio-extras
-    kdbusaddons kfilemetadata knotifications knewstuff karchive knotifyconfig
-    kplotting ktextwidgets kwindowsystem plasma-framework
-    phonon-backend-gstreamer qtquickcontrols shared_mime_info
-  ];
+  postPatch =
+    # Module Qt5::Concurrent must be included in `find_package` before it is used.
+    ''
+      sed -i CMakeLists.txt -e '/find_package(Qt5 REQUIRED/ s|)| Concurrent)|'
+    '';
   meta = {
     license = with lib.licenses; [ gpl2Plus ];
   };

pkgs/applications/kde/kdf.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kcmutils
 }:
 
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = [ lib.maintainers.peterhoeg ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [ kcmutils ];
 }

pkgs/applications/kde/kgpg.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, ki18n, wrapGAppsHook,
-  akonadi-contacts, gnupg1, gpgme, karchive, kcodecs, kcontacts, kcoreaddons, kcrash,
-  kdbusaddons, kiconthemes, kjobwidgets, kio, knotifications, kservice,
+  extra-cmake-modules, kdoctools, ki18n, makeWrapper,
+  akonadi-contacts, gnupg1, gpgme, karchive, kcodecs, kcontacts, kcoreaddons,
+  kcrash, kdbusaddons, kiconthemes, kjobwidgets, kio, knotifications, kservice,
   ktextwidgets, kxmlgui, kwidgetsaddons, kwindowsystem
 }:
 
 mkDerivation {
   name = "kgpg";
-  nativeBuildInputs = [ extra-cmake-modules kdoctools ki18n wrapGAppsHook ];
-  buildInputs = [
-    akonadi-contacts gnupg1 gpgme karchive kcodecs kcontacts kcoreaddons kcrash kdbusaddons
+  nativeBuildInputs = [ extra-cmake-modules kdoctools makeWrapper ];
+  buildInputs = [ gnupg1 gpgme ki18n ];
+  propagatedBuildInputs = [
+    akonadi-contacts karchive kcodecs kcontacts kcoreaddons kcrash kdbusaddons
     kiconthemes kjobwidgets kio knotifications kservice ktextwidgets kxmlgui
     kwidgetsaddons kwindowsystem
   ];
-  preFixup = ''
-    gappsWrapperArgs+=(--suffix PATH : ${lib.makeBinPath [ gnupg1 ]})
+  postFixup = ''
+    wrapProgram "$out/bin/kgpg" --prefix PATH : "${lib.makeBinPath [ gnupg1 ]}"
   '';
   meta = {
     license = [ lib.licenses.gpl2 ];

pkgs/applications/kde/khelpcenter.nix

···
 {
   mkDerivation,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   grantlee, kconfig, kcoreaddons, kdbusaddons, ki18n, kinit, kcmutils,
   kdelibs4support, khtml, kservice, xapian
 }:
 
 mkDerivation {
   name = "khelpcenter";
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
-  buildInputs = [
-    grantlee kdelibs4support khtml ki18n kconfig kcoreaddons kdbusaddons
-    kinit kcmutils kservice xapian
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ ki18n xapian ];
+  propagatedBuildInputs = [
+    grantlee kdelibs4support khtml kconfig kcoreaddons kdbusaddons
+    kinit kcmutils kservice
   ];
 }

pkgs/applications/kde/kig.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kparts, qtsvg, qtxmlpatterns, ktexteditor, boost
 }:
 
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = with lib.maintainers; [ raskin ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
-  buildInputs = [
-    kparts qtsvg qtxmlpatterns ktexteditor boost
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ boost ];
+  propagatedBuildInputs = [
+    kparts qtsvg qtxmlpatterns ktexteditor
   ];
 }
 

pkgs/applications/kde/kmix.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kglobalaccel, kxmlgui, kcoreaddons, kdelibs4support,
   plasma-framework, libpulseaudio, alsaLib, libcanberra_kde
 }:
···
     license = with lib.licenses; [ gpl2 lgpl21 fdl12 ];
     maintainers = [ lib.maintainers.rongcuid ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   buildInputs = [ libpulseaudio alsaLib libcanberra_kde ];
   propagatedBuildInputs = [
     kglobalaccel kxmlgui kcoreaddons kdelibs4support

pkgs/applications/kde/kolourpaint.nix

···
 , mkDerivation
 , extra-cmake-modules
 , kdoctools
-, wrapGAppsHook
 , kdelibs4support
 , libkexiv2
 }:
 
 mkDerivation {
   name = "kolourpaint";
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [ kdelibs4support libkexiv2 ];
   meta = {
     maintainers = [ lib.maintainers.fridh ];

pkgs/applications/kde/kompare.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kparts, ktexteditor, kwidgetsaddons, libkomparediff2
 }:
 
 mkDerivation {
   name = "kompare";
   meta = { license = with lib.licenses; [ gpl2 ]; };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [
     kparts ktexteditor kwidgetsaddons libkomparediff2
   ];

pkgs/applications/kde/konsole.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kbookmarks, kcompletion, kconfig, kconfigwidgets, kcoreaddons, kguiaddons,
   ki18n, kiconthemes, kinit, kdelibs4support, kio, knotifications,
   knotifyconfig, kparts, kpty, kservice, ktextwidgets, kwidgetsaddons,
···
     license = with lib.licenses; [ gpl2 lgpl21 fdl12 ];
     maintainers = [ lib.maintainers.ttuegel ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ ki18n ];
   propagatedBuildInputs = [
-    kdelibs4support ki18n kwindowsystem qtscript kbookmarks kcompletion
-    kconfig kconfigwidgets kcoreaddons kguiaddons kiconthemes kinit kio
-    knotifications knotifyconfig kparts kpty kservice ktextwidgets
-    kwidgetsaddons kxmlgui
+    kbookmarks kcompletion kconfig kconfigwidgets kcoreaddons kdelibs4support
+    kguiaddons kiconthemes kinit kio knotifications knotifyconfig kparts kpty
+    kservice ktextwidgets kwidgetsaddons kwindowsystem kxmlgui qtscript
   ];
 }

pkgs/applications/kde/krfb.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kdelibs4support, kdnssd, libvncserver, libXtst
 }:
 
···
     license = with lib.licenses; [ gpl2 fdl12 ];
     maintainers = with lib.maintainers; [ jerith666 ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
-  propagatedBuildInputs = [ kdelibs4support kdnssd libvncserver libXtst ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ libvncserver libXtst ];
+  propagatedBuildInputs = [ kdelibs4support kdnssd ];
 }

pkgs/applications/kde/kwalletmanager.nix

···
 , mkDerivation
 , extra-cmake-modules
 , kdoctools
-, wrapGAppsHook
 , kauth
 , kcmutils
 , kconfigwidgets
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = with lib.maintainers; [ fridh ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [
     kauth kcmutils kconfigwidgets kcoreaddons kdbusaddons kdelibs4support
     kxmlgui

pkgs/applications/kde/marble.nix

···
 { mkDerivation, lib
-, extra-cmake-modules, kdoctools, wrapGAppsHook
+, extra-cmake-modules, kdoctools
 , qtscript, qtsvg, qtquickcontrols, qtwebkit
 , krunner, shared_mime_info, kparts, knewstuff
 , gpsd, perl
···
 mkDerivation {
   name = "marble";
   meta.license = with lib.licenses; [ lgpl21 gpl3 ];
-  nativeBuildInputs = [ extra-cmake-modules kdoctools perl wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools perl ];
   propagatedBuildInputs = [
     qtscript qtsvg qtquickcontrols qtwebkit shared_mime_info krunner kparts
     knewstuff gpsd

pkgs/applications/kde/okteta.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   kconfig, kinit,
   kcmutils, kconfigwidgets, knewstuff, kparts, qca-qt5
 }:
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = with lib.maintainers; [ peterhoeg ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
   propagatedBuildInputs = [
-    kconfig kinit
-    kcmutils kconfigwidgets knewstuff kparts qca-qt5
+    kconfig kinit kcmutils kconfigwidgets knewstuff kparts qca-qt5
   ];
 }

pkgs/applications/kde/okular.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
+  extra-cmake-modules, kdoctools,
   djvulibre, ebook_tools, kactivities, karchive, kbookmarks, kcompletion,
   kconfig, kconfigwidgets, kcoreaddons, kdbusaddons, kdegraphics-mobipocket,
   kiconthemes, kjs, khtml, kio, kparts, kpty, kwallet, kwindowsystem, libkexiv2,
···
 
 mkDerivation {
   name = "okular";
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ djvulibre ebook_tools ];
   propagatedBuildInputs = [
-    djvulibre ebook_tools kactivities karchive kbookmarks kcompletion kconfig
-    kconfigwidgets kcoreaddons kdbusaddons kdegraphics-mobipocket kiconthemes
-    kjs khtml kio kparts kpty kwallet kwindowsystem libkexiv2 libspectre poppler
-    qca-qt5 qtdeclarative qtsvg threadweaver
+    kactivities karchive kbookmarks kcompletion kconfig kconfigwidgets
+    kcoreaddons kdbusaddons kdegraphics-mobipocket kiconthemes kjs khtml kio
+    kparts kpty kwallet kwindowsystem libkexiv2 libspectre poppler qca-qt5
+    qtdeclarative qtsvg threadweaver
   ];
   meta = {
     platforms = lib.platforms.linux;

pkgs/applications/kde/print-manager.nix

···
 {
-  mkDerivation, lib, extra-cmake-modules, wrapGAppsHook,
-  cups, kconfig, kconfigwidgets, kdbusaddons, kiconthemes, ki18n, kcmutils, kio,
+  mkDerivation, lib,
+  extra-cmake-modules,
+  cups, ki18n,
+  kconfig, kconfigwidgets, kdbusaddons, kiconthemes, kcmutils, kio,
   knotifications, kwidgetsaddons, kwindowsystem, kitemviews, plasma-framework,
   qtdeclarative
 }:
···
     license = [ lib.licenses.gpl2 ];
     maintainers = [ lib.maintainers.ttuegel ];
   };
-  nativeBuildInputs = [ extra-cmake-modules wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules ];
+  buildInputs = [ cups ki18n ];
   propagatedBuildInputs = [
-    cups kconfig kconfigwidgets kdbusaddons kiconthemes kcmutils knotifications
-    kwidgetsaddons kitemviews ki18n kio kwindowsystem plasma-framework
-    qtdeclarative
+    kconfig kconfigwidgets kdbusaddons kiconthemes kcmutils knotifications
+    kwidgetsaddons kitemviews kio kwindowsystem plasma-framework qtdeclarative
   ];
 }

pkgs/applications/kde/spectacle.nix

···
 {
   mkDerivation, lib,
-  extra-cmake-modules, kdoctools, wrapGAppsHook,
-  kconfig, kcoreaddons, kdbusaddons, kdeclarative, ki18n, kio, kipi-plugins,
+  extra-cmake-modules, kdoctools,
+  ki18n, xcb-util-cursor,
+  kconfig, kcoreaddons, kdbusaddons, kdeclarative, kio, kipi-plugins,
   knotifications, kscreen, kwidgetsaddons, kwindowsystem, kxmlgui, libkipi,
-  xcb-util-cursor
 }:
 
 mkDerivation {
   name = "spectacle";
   meta = with lib; { maintainers = with maintainers; [ ttuegel ]; };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [ ki18n xcb-util-cursor ];
   propagatedBuildInputs = [
-    kconfig kcoreaddons kdbusaddons kdeclarative ki18n kio knotifications
-    kscreen kwidgetsaddons kwindowsystem kxmlgui libkipi xcb-util-cursor
+    kconfig kcoreaddons kdbusaddons kdeclarative kio knotifications
+    kscreen kwidgetsaddons kwindowsystem kxmlgui libkipi
   ];
   propagatedUserEnvPkgs = [ kipi-plugins ];
 }

pkgs/applications/misc/albert/default.nix

···
-{ stdenv, fetchFromGitHub, qtbase, qtsvg, qtx11extras, makeQtWrapper, muparser, cmake }:
+{ mkDerivation, lib, fetchFromGitHub, qtbase, qtsvg, qtx11extras, muparser, cmake }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name    = "albert-${version}";
   version = "0.11.3";
 
···
     sha256 = "0ddz6h1334b9kqy1lfi7qa21znm3l0b9h0d4s62llxdasv103jh5";
   };
 
-  nativeBuildInputs = [ cmake makeQtWrapper ];
+  nativeBuildInputs = [ cmake ];
 
   buildInputs = [ qtbase qtsvg qtx11extras muparser ];
 
···
     rm "$out/lib"
   '';
 
-  fixupPhase = ''
-    wrapQtProgram $out/bin/albert
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage    = https://albertlauncher.github.io/;
     description = "Desktop agnostic launcher";
     license     = licenses.gpl3Plus;

pkgs/applications/misc/cool-retro-term/default.nix

···
-{ stdenv, fetchgit, makeQtWrapper, qtbase, qtquick1, qmltermwidget,
+{ stdenv, fetchgit, qtbase, qtquick1, qmltermwidget,
 qtquickcontrols, qtgraphicaleffects, qmake }:
 
 stdenv.mkDerivation rec {
···
   '';
 
   buildInputs = [ qtbase qtquick1 qmltermwidget qtquickcontrols qtgraphicaleffects ];
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ qmake ];
 
   installFlags = [ "INSTALL_ROOT=$(out)" ];
 
···
     mv $out/usr/share $out/share
     mv $out/usr/bin $out/bin
     rmdir $out/usr
-
-    wrapQtProgram $out/bin/cool-retro-term
   '';
 
   enableParallelBuilding = true;

pkgs/applications/misc/cura/default.nix

···
-{ stdenv, lib, fetchFromGitHub, cmake, python3, qtbase, makeQtWrapper, curaengine }:
+{ mkDerivation, lib, fetchFromGitHub, cmake, python3, qtbase, curaengine }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "cura-${version}";
   version = "2.4.0";
 
···
 
   buildInputs = [ qtbase ];
   propagatedBuildInputs = with python3.pkgs; [ uranium zeroconf pyserial ];
-  nativeBuildInputs = [ cmake python3.pkgs.wrapPython makeQtWrapper ];
+  nativeBuildInputs = [ cmake python3.pkgs.wrapPython ];
 
   cmakeFlags = [ "-DCMAKE_MODULE_PATH=${python3.pkgs.uranium}/share/cmake-${cmake.majorVersion}/Modules" ];
 
···
 
   postFixup = ''
     wrapPythonPrograms
-    mv $out/bin/cura $out/bin/.cura-noqtpath
-    makeQtWrapper $out/bin/.cura-noqtpath $out/bin/cura
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "3D printer / slicing GUI built on top of the Uranium framework";
     homepage = "https://github.com/Ultimaker/Cura";
     license = licenses.agpl3;

pkgs/applications/misc/golden-cheetah/default.nix

···
 { stdenv, fetchurl
 , qtbase, qtsvg, qtserialport, qtwebkit, qtmultimedia, qttools, qtconnectivity
-, yacc, flex, zlib, config, qmake, makeQtWrapper
+, yacc, flex, zlib, config, qmake, makeWrapper
 }:
 stdenv.mkDerivation rec {
   name = "golden-cheetah-${version}";
···
     url = "https://github.com/GoldenCheetah/GoldenCheetah/archive/V${version}.tar.gz";
     sha256 = "0fiz2pj155cd357kph50lc6rjyzwp045glfv4y68qls9j7m9ayaf";
   };
-  qtInputs = [
-    qtbase qtsvg qtserialport qtwebkit qtmultimedia qttools yacc flex zlib
+  buildInputs = [
+    qtbase qtsvg qtserialport qtwebkit qtmultimedia qttools zlib
     qtconnectivity
   ];
-  nativeBuildInputs = [ makeQtWrapper qmake ] ++ qtInputs;
+  nativeBuildInputs = [ flex makeWrapper qmake yacc ];
   preConfigure = ''
     cp src/gcconfig.pri.in src/gcconfig.pri
     cp qwt/qwtconfig.pri.in qwt/qwtconfig.pri
···
 
     mkdir -p $out/bin
     cp src/GoldenCheetah $out/bin
-    wrapQtProgram $out/bin/GoldenCheetah --set LD_LIBRARY_PATH "${zlib.out}/lib"
+    wrapProgram $out/bin/GoldenCheetah --set LD_LIBRARY_PATH "${zlib.out}/lib"
 
     runHook postInstall
   '';

pkgs/applications/misc/gpxsee/default.nix

···
-{ stdenv, fetchFromGitHub, qmake, qtbase, qttools, makeQtWrapper }:
+{ stdenv, fetchFromGitHub, qmake, qtbase, qttools }:
 
 stdenv.mkDerivation rec {
   name = "gpxsee-${version}";
···
     sha256 = "17s1v6b1j7pi0yj554bd0cg14bl854gssp5gj2pl51rxji6zr0wp";
   };
 
-  nativeBuildInputs = [ qmake qttools makeQtWrapper ];
+  nativeBuildInputs = [ qmake qttools ];
 
   preConfigure = ''
     substituteInPlace src/config.h --replace /usr/share/gpxsee $out/share/gpxsee
···
 
   preFixup = ''
     install -Dm755 GPXSee $out/bin/GPXSee
-    wrapQtProgram $out/bin/GPXSee
 
     mkdir -p $out/share/gpxsee
     cp pkg/maps.txt $out/share/gpxsee

pkgs/applications/misc/kdeconnect/default.nix

···
 , lib
 , fetchurl
 , extra-cmake-modules
-, makeQtWrapper
 , kcmutils
 , kconfigwidgets
 , kdbusaddons
···
     libXtst
   ];
 
-  nativeBuildInputs = [
-    extra-cmake-modules
-    makeQtWrapper
-  ];
-
-  postInstall = ''
-    wrapQtProgram "$out/bin/kdeconnect-cli"
-  '';
+  nativeBuildInputs = [ extra-cmake-modules ];
 
   meta = {
     description = "KDE Connect provides several features to integrate your phone and your computer";

pkgs/applications/misc/openbrf/default.nix

···
-{ stdenv, fetchFromGitHub, qtbase, vcg, glew, qmake, makeQtWrapper, mesa }:
+{ stdenv, fetchFromGitHub, qtbase, vcg, glew, qmake, mesa }:
 
 
 stdenv.mkDerivation {
···
   buildInputs = [ qtbase vcg glew ];
 
   enableParallelBuilding = true;
-  nativeBuildInputs = [ qmake makeQtWrapper ];
+  nativeBuildInputs = [ qmake ];
 
   qmakeFlags = [ "openBrf.pro" ];
 
···
       --set-rpath "${stdenv.lib.makeLibraryPath [ qtbase glew stdenv.cc.cc mesa ]}" \
       $out/share/openBrf/openBrf
 
-    makeQtWrapper "$out/share/openBrf/openBrf" "$out/bin/openBrf"
+    ln -s "$out/share/openBrf/openBrf" "$out/bin/openBrf"
   '';
 
   dontPatchELF = true;

pkgs/applications/misc/qsyncthingtray/default.nix

···
-{ stdenv, lib, fetchFromGitHub, procps ? null
+{ mkDerivation, stdenv, lib, fetchFromGitHub, procps ? null
 , qtbase, qtwebengine, qtwebkit
-, cmake, makeQtWrapper
+, cmake
 , syncthing, syncthing-inotify ? null
 , preferQWebView ? false }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   version = "0.5.7";
   name = "qsyncthingtray-${version}";
 
···
   };
 
   buildInputs = [ qtbase qtwebengine ] ++ lib.optional preferQWebView qtwebkit;
-  nativeBuildInputs = [ cmake makeQtWrapper ];
-  enableParallelBuilding = true;
+  nativeBuildInputs = [ cmake ];
 
   cmakeFlags = lib.optional preferQWebView "-DQST_BUILD_WEBKIT=1";
 
···
     mkdir -p $out/bin
     install -m755 QSyncthingTray $out/bin/${qst}
     ln -s $out/bin/${qst} $out/bin/QSyncthingTray
-    wrapQtProgram $out/bin/qsyncthingtray
 
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = https://github.com/sieren/QSyncthingTray/;
     description = "A Traybar Application for Syncthing written in C++";
     longDescription = ''

pkgs/applications/misc/qtpass/default.nix

···
-{ stdenv, fetchFromGitHub, git, gnupg, makeQtWrapper, pass, qtbase, qtsvg, qttools, qmake }:
+{ stdenv, fetchFromGitHub, git, gnupg, pass, qtbase, qtsvg, qttools, qmake, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "qtpass-${version}";
···
 
   buildInputs = [ git gnupg pass qtbase qtsvg qttools ];
 
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ makeWrapper qmake ];
 
   preConfigure = ''
-    qmakeFlags="$qmakeFlags CONFIG+=release DESTDIR=$out"
+    qmakeFlags="$qmakeFlags DESTDIR=$out"
   '';
 
   installPhase = ''
···
   '';
 
   postInstall = ''
-    wrapQtProgram $out/bin/qtpass \
+    wrapProgram $out/bin/qtpass \
       --suffix PATH : ${git}/bin \
       --suffix PATH : ${gnupg}/bin \
       --suffix PATH : ${pass}/bin

pkgs/applications/misc/redis-desktop-manager/default.nix

···
 { stdenv, lib, fetchgit, pkgconfig , libssh2
 , qtbase, qtdeclarative, qtgraphicaleffects, qtimageformats, qtquickcontrols
 , qtsvg, qttools, qtquick1
-, makeQtWrapper, qmake
+, qmake
 }:
 
 let
···
     sha256 = "0a7xa39qp1q32zkypw32mm3wi8wbhxhvrm6l3xsa3k1jzih7hzxr";
   };
 
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ qmake ];
 
   buildInputs = [
     pkgconfig libssh2 qtbase qtdeclarative qtgraphicaleffects qtimageformats
···
     mkdir -p $out/bin
     instdir="$srcdir/bin/linux/release"
     cp $instdir/rdm $out/bin
-    wrapQtProgram $out/bin/rdm
   '';
 
   meta = with lib; {

pkgs/applications/misc/xca/default.nix

···
-{ stdenv, fetchurl, pkgconfig, which, makeQtWrapper,
-  libtool, openssl, qtbase, qttools }:
+{ mkDerivation, lib, fetchurl, pkgconfig, which
+, libtool, openssl, qtbase, qttools }:
 
-with stdenv.lib;
+with lib;
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "xca-${version}";
   version = "1.3.2";
 
···
 
   buildInputs = [ libtool openssl qtbase qttools ];
 
-  nativeBuildInputs = [ makeQtWrapper pkgconfig which ];
+  nativeBuildInputs = [ pkgconfig which ];
 
   configureFlags = [ "CXXFLAGS=-std=c++11" ];
 
···
       --replace ${qtbase}/bin/uic ${qtbase.dev}/bin/uic
   '';
 
-  postInstall = ''
-    wrapQtProgram "$out/bin/xca"
-    wrapQtProgram "$out/bin/xca_db_stat"
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Interface for managing asymetric keys like RSA or DSA";
     homepage = http://xca.sourceforge.net/;
     platforms = platforms.all;

pkgs/applications/networking/browsers/qutebrowser/default.nix

···
-{ stdenv, lib, fetchurl, unzip, buildPythonApplication, makeQtWrapper, wrapGAppsHook
+{ stdenv, lib, fetchurl, unzip, buildPythonApplication, makeWrapper, wrapGAppsHook
 , qtbase, pyqt5, jinja2, pygments, pyyaml, pypeg2, cssutils, glib_networking
 , asciidoc, docbook_xml_dtd_45, docbook_xsl, libxml2, libxslt
 , gst-plugins-base, gst-plugins-good, gst-plugins-bad, gst-plugins-ugly, gst-libav
···
   ];
 
   nativeBuildInputs = [
-    makeQtWrapper wrapGAppsHook asciidoc docbook_xml_dtd_45 docbook_xsl libxml2 libxslt
+    makeWrapper wrapGAppsHook asciidoc docbook_xml_dtd_45 docbook_xsl libxml2 libxslt
   ];
 
   propagatedBuildInputs = [
···
     install -Dm755 -t "$out/share/qutebrowser/userscripts/" misc/userscripts/*
   '';
 
-  postFixup = ''
-    wrapQtProgram $out/bin/qutebrowser \
-      ${lib.optionalString withWebEngineDefault ''--add-flags "--backend webengine"''}
+  postFixup = lib.optionalString withWebEngineDefault ''
+    wrapProgram $out/bin/qutebrowser --add-flags "--backend webengine"
   '';
 
   meta = {

pkgs/applications/networking/dropbox/default.nix

···
-{ stdenv, fetchurl, makeDesktopItem, patchelf, makeWrapper, makeQtWrapper
+{ mkDerivation, stdenv, lib, fetchurl, makeDesktopItem
+, makeWrapper, patchelf
 , dbus_libs, fontconfig, freetype, gcc, glib
 , libdrm, libffi, libICE, libSM
 , libX11, libXcomposite, libXext, libXmu, libXrender, libxcb
···
     startupNotify = "false";
   };
 
-in stdenv.mkDerivation {
+in mkDerivation {
   name = "dropbox-${version}";
   src = fetchurl {
     name = "dropbox-${version}.tar.gz";
···
 
   sourceRoot = ".dropbox-dist";
 
-  nativeBuildInputs = [ makeQtWrapper patchelf ];
+  nativeBuildInputs = [ makeWrapper patchelf ];
   dontStrip = true; # already done
 
   installPhase = ''
···
 
     mkdir -p "$out/bin"
     RPATH="${ldpath}:$out/${appdir}"
-    makeQtWrapper "$out/${appdir}/dropbox" "$out/bin/dropbox" \
+    makeWrapper "$out/${appdir}/dropbox" "$out/bin/dropbox" \
       --prefix LD_LIBRARY_PATH : "$RPATH"
 
     chmod 755 $out/${appdir}/dropbox
···
   meta = {
     homepage = "http://www.dropbox.com";
     description = "Online stored folders (daemon version)";
-    maintainers = with stdenv.lib.maintainers; [ ttuegel ];
+    maintainers = with lib.maintainers; [ ttuegel ];
     platforms = [ "i686-linux" "x86_64-linux" ];
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
   };
 }

pkgs/applications/networking/instant-messengers/qtox/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, pkgconfig, openal, opencv,
+{ mkDerivation, lib, fetchFromGitHub, cmake, pkgconfig, openal, opencv,
   libtoxcore, libsodium, libXScrnSaver, glib, gdk_pixbuf, gtk2, cairo, xorg,
-  pango, atk, qrencode, ffmpeg, filter-audio, makeQtWrapper,
+  pango, atk, qrencode, ffmpeg, filter-audio,
   qtbase, qtsvg, qttools, qttranslations, sqlcipher,
   libvpx, libopus }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "qtox-${version}";
   version = "1.10.2";
 
···
     libpthreadstubs libXdmcp
   ]);
 
-  nativeBuildInputs = [ cmake makeQtWrapper pkgconfig ];
+  nativeBuildInputs = [ cmake pkgconfig ];
 
   cmakeFlags = [
     "-DGIT_DESCRIBE=${version}"
···
     runHook preInstall
 
     install -Dm755 qtox $out/bin/qtox
-    wrapQtProgram $out/bin/qtox
 
     runHook postInstall
   '';
 
-  enableParallelBuilding = true;
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Qt Tox client";
     license = licenses.gpl3;
     maintainers = with maintainers; [ viric jgeerds akaWolf peterhoeg ];

pkgs/applications/networking/instant-messengers/quaternion/default.nix

···
-{ stdenv, fetchgit, qtbase, qtquickcontrols, cmake, makeQtWrapper }:
+{ mkDerivation, lib, fetchgit, qtbase, qtquickcontrols, cmake }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "quaternion-git-${version}";
   version = "2017-04-15";
 
···
     sha256          = "0cm5j4vdnp5cljfnv5jqf89ccymspaqc6j9bb4c1x891vr42np0m";
     fetchSubmodules = true;
   };
-
-  enableParallelBuilding = true;
 
   buildInputs = [ qtbase qtquickcontrols ];
-  nativeBuildInputs = [ cmake makeQtWrapper ];
+  nativeBuildInputs = [ cmake ];
 
   cmakeFlags = [
     "-Wno-dev"
   ];
 
   postInstall = ''
-    wrapQtProgram $out/bin/quaternion
-
     substituteInPlace $out/share/applications/quaternion.desktop \
       --replace 'Exec=quaternion' "Exec=$out/bin/quaternion"
 
     rm $out/share/icons/hicolor/icon-theme.cache
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = https://matrix.org/docs/projects/client/quaternion.html;
     description = "Cross-platform desktop IM client for the Matrix protocol";
     license = licenses.gpl3;

pkgs/applications/networking/instant-messengers/ricochet/default.nix

···
 { stdenv, fetchurl, pkgconfig, makeDesktopItem, unzip
-, qtbase, qttools, makeQtWrapper, qtmultimedia, qtquick1, qtquickcontrols
+, qtbase, qttools, qtmultimedia, qtquick1, qtquickcontrols
 , openssl, protobuf, qmake
 }:
 
···
     openssl protobuf
   ];
 
-  nativeBuildInputs = [ pkgconfig makeQtWrapper qmake ];
+  nativeBuildInputs = [ pkgconfig qmake ];
 
   preConfigure = ''
     export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE $(pkg-config --cflags openssl)"
···
   installPhase = ''
     mkdir -p $out/bin
     cp ricochet $out/bin
-    wrapQtProgram $out/bin/ricochet
 
     mkdir -p $out/share/applications
     cp $desktopItem/share/applications"/"* $out/share/applications

pkgs/applications/networking/instant-messengers/telegram/cutegram/default.nix

···
 , qtimageformats, qtgraphicaleffects, qtwebkit
 , telegram-qml, libqtelegram-aseman-edition
 , gst_all_1
-, makeQtWrapper, qmake }:
+, makeWrapper, qmake }:
 
 stdenv.mkDerivation rec {
   name = "cutegram-${meta.version}";
···
 
 
   enableParallelBuilding = true;
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ makeWrapper qmake ];
 
   fixupPhase = ''
-    wrapQtProgram $out/bin/cutegram \
+    wrapProgram $out/bin/cutegram \
       --prefix GST_PLUGIN_SYSTEM_PATH_1_0 : "$GST_PLUGIN_SYSTEM_PATH_1_0"
   '';
 

pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix

···
-{ stdenv, lib, fetchFromGitHub, fetchgit, pkgconfig, gyp, cmake
-, qtbase, qtimageformats, makeQtWrapper
+{ mkDerivation, lib, fetchFromGitHub, fetchgit, pkgconfig, gyp, cmake
+, qtbase, qtimageformats
 , breakpad, gtk3, libappindicator-gtk3, dee
 , ffmpeg, openalSoft, minizip
 }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "telegram-desktop-${version}";
   version = "1.0.27";
 
···
     gtk3 libappindicator-gtk3 dee qtbase qtimageformats ffmpeg openalSoft minizip
   ];
 
-  nativeBuildInputs = [ pkgconfig gyp cmake makeQtWrapper ];
+  nativeBuildInputs = [ pkgconfig gyp cmake ];
 
   patches = [ "${tgaur}/aur-build-fixes.patch" ];
 
···
     for icon_size in 16 32 48 64 128 256 512; do
       install -Dm644 "../../../Telegram/Resources/art/icon''${icon_size}.png" "$out/share/icons/hicolor/''${icon_size}x''${icon_size}/apps/telegram-desktop.png"
     done
-    wrapQtProgram $out/bin/telegram-desktop
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Telegram Desktop messaging app";
     license = licenses.gpl3;
     platforms = platforms.linux;

pkgs/applications/networking/instant-messengers/tensor/default.nix

···
-{ stdenv, fetchgit, qtbase, qtquickcontrols, qmake, makeQtWrapper, makeDesktopItem }:
+{ stdenv, fetchgit, qtbase, qtquickcontrols, qmake, makeDesktopItem }:
 
 stdenv.mkDerivation rec {
   name = "tensor-git-${version}";
···
   enableParallelBuilding = true;
 
   buildInputs = [ qtbase qtquickcontrols ];
-  nativeBuildInputs = [ qmake makeQtWrapper ];
+  nativeBuildInputs = [ qmake ];
 
   desktopItem = makeDesktopItem {
     name        = "tensor";
···
                    $out/share/icons/hicolor/512x512/apps/tensor.png
     install -Dm644 ${desktopItem}/share/applications/tensor.desktop \
                    $out/share/applications/tensor.desktop
-
-    wrapQtProgram $out/bin/tensor
 
     substituteInPlace $out/share/applications/tensor.desktop \
       --subst-var-by bin $out/bin/tensor

pkgs/applications/networking/irc/communi/default.nix

···
-{ fetchgit, libcommuni, makeQtWrapper, qtbase, qmake, stdenv }:
+{ fetchgit, libcommuni, qtbase, qmake, stdenv }:
 
 stdenv.mkDerivation rec {
   name = "communi-${version}";
···
     fetchSubmodules = true;
   };
 
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ qmake ];
 
   buildInputs = [ libcommuni qtbase ];
 
···
   '';
 
   postInstall = ''
-    wrapQtProgram "$out/bin/communi"
     substituteInPlace "$out/share/applications/communi.desktop" \
       --replace "/usr/bin" "$out/bin"
   '';

pkgs/applications/networking/irc/konversation/default.nix

···
 , fetchurl
 , extra-cmake-modules
 , kdoctools
-, wrapGAppsHook
 , kbookmarks
 , karchive
 , kconfig
···
 , kio
 , kparts
 , kwallet
-, makeQtWrapper
 , solid
 , sonnet
 , phonon
···
   nativeBuildInputs = [
     extra-cmake-modules
     kdoctools
-    wrapGAppsHook
   ];
 
   meta = {

pkgs/applications/networking/mailreaders/trojita/default.nix

···
-{ stdenv
+{ mkDerivation
 , lib
 , fetchgit
 , cmake
 , qtbase
 , qtwebkit
-, makeQtWrapper
 }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "trojita-${version}";
   version = "0.7";
 
···
   };
 
   buildInputs = [
-    cmake
     qtbase
     qtwebkit
   ];
 
   nativeBuildInputs = [
-    makeQtWrapper
+    cmake
   ];
 
-  postInstall = ''
-    wrapQtProgram "$out/bin/trojita"
-  '';
 
-
-  meta = {
+  meta = with lib; {
     description = "A Qt IMAP e-mail client";
     homepage = http://trojita.flaska.net/;
-    license = with lib.licenses; [ gpl2 gpl3 ];
-    platforms = stdenv.lib.platforms.linux;
+    license = with licenses; [ gpl2 gpl3 ];
+    platforms = platforms.linux;
   };
 
 }

pkgs/applications/networking/mumble/default.nix

···
   client = source: generic {
     type = "mumble";
 
-    nativeBuildInputs = optionals (source.qtVersion == 5) [ qt5.qttools qt5.makeQtWrapper ];
+    nativeBuildInputs = optionals (source.qtVersion == 5) [ qt5.qttools ];
     buildInputs = [ libopus libsndfile speex ]
       ++ optional (source.qtVersion == 5) qt5.qtsvg
       ++ optional stdenv.isLinux alsaLib
···
       mkdir -p $out/share/icons{,/hicolor/scalable/apps}
       cp icons/mumble.svg $out/share/icons
       ln -s $out/share/icon/mumble.svg $out/share/icons/hicolor/scalable/apps
-
-      ${optionalString (source.qtVersion == 5) ''
-        wrapQtProgram $out/bin/mumble
-      ''}
     '';
   } source;
 

pkgs/applications/networking/newsreaders/quiterss/default.nix

···
-{ stdenv, fetchFromGitHub, qtbase, qmake, qttools, qtwebkit, makeQtWrapper, pkgconfig, sqlite }:
+{ stdenv, fetchFromGitHub, qtbase, qmake, qttools, qtwebkit, pkgconfig, sqlite }:
 
 stdenv.mkDerivation rec {
   name = "quiterss-${version}";
···
     sha256 = "1y0n5ps1z4wgf9hkfjrw7dfyncrw22bf9mi3052vmf3s7xzz6vbb";
   };
 
-  nativeBuildInputs = [ makeQtWrapper pkgconfig qmake ];
+  nativeBuildInputs = [ pkgconfig qmake ];
   buildInputs = [ qtbase qttools qtwebkit sqlite.dev ];
-
-  postInstall = ''
-    wrapQtProgram "$out/bin/quiterss"
-  '';
 
   meta = with stdenv.lib; {
     description = "A Qt-based RSS/Atom news feed reader";

pkgs/applications/office/mendeley/default.nix

···
 { fetchurl, stdenv, dpkg, which
+, makeWrapper
 , alsaLib
 , desktop_file_utils
 , dbus
···
     sha256 = sha256;
   };
 
-  nativeBuildInputs = [ qt5.makeQtWrapper ];
+  nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ dpkg which ] ++ deps;
 
   unpackPhase = "true";
···
              $out/bin/mendeleydesktop
     paxmark m $out/bin/mendeleydesktop
 
-    wrapQtProgram $out/bin/mendeleydesktop \
+    wrapProgram $out/bin/mendeleydesktop \
       --add-flags "--unix-distro-build" \
       ${stdenv.lib.optionalString autorunLinkHandler
       ''--run "$out/bin/install-mendeley-link-handler.sh $out/bin/mendeleydesktop"''}

pkgs/applications/office/mytetra/default.nix

···
-{ stdenv, fetchurl, qmake, makeQtWrapper, qtsvg }:
+{ stdenv, fetchurl, qmake, qtsvg }:
 
 let
   version = "1.42.2";
···
     sha256 = "1ah44nf4ksxkh01a2zmgvvby4pwczhyq5vcp270rf6visp8v9804";
   };
 
-  nativeBuildInputs = [ makeQtWrapper qmake ];
+  nativeBuildInputs = [ qmake ];
   buildInputs = [ qtsvg ];
 
   hardeningDisable = [ "format" ];
···
     substituteInPlace src/views/mainWindow/MainWindow.cpp \
       --replace ":/resource/pic/logo.svg" "$out/share/icons/hicolor/48x48/apps/mytetra.png"
   '';
-
-  postInstall = "wrapQtProgram $out/bin/mytetra";
 
   meta = with stdenv.lib; {
     description = "Smart manager for information collecting";

pkgs/applications/office/skrooge/default.nix

···
-{ stdenv, fetchurl, cmake, extra-cmake-modules, makeQtWrapper, qtwebkit, qtscript, grantlee,
+{ mkDerivation, lib, fetchurl,
+  cmake, extra-cmake-modules, qtwebkit, qtscript, grantlee,
   kxmlgui, kwallet, kparts, kdoctools, kjobwidgets, kdesignerplugin,
   kiconthemes, knewstuff, sqlcipher, qca-qt5, kdelibs4support, kactivities,
   knotifyconfig, krunner, libofx }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "skrooge-${version}";
   version = "2.7.0";
 
···
     sha256 = "1xrh9nal122rzlv4m0x8qah6zpqb6891al3351piarpk2xgjgj4x";
   };
 
-  nativeBuildInputs = [ cmake extra-cmake-modules makeQtWrapper ];
+  nativeBuildInputs = [ cmake extra-cmake-modules ];
 
   buildInputs = [ qtwebkit qtscript grantlee kxmlgui kwallet kparts kdoctools
     kjobwidgets kdesignerplugin kiconthemes knewstuff sqlcipher qca-qt5
     kdelibs4support kactivities knotifyconfig krunner libofx
   ];
 
-  enableParallelBuilding = true;
-
-  postInstall = ''
-    wrapQtProgram "$out/bin/skrooge"
-    wrapQtProgram "$out/bin/skroogeconvert"
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A personal finances manager, powered by KDE";
     license = with licenses; [ gpl3 ];
     maintainers = with maintainers; [ joko ];

pkgs/applications/science/astronomy/stellarium/default.nix

···
-{ stdenv, fetchurl, cmake, freetype, libpng, mesa, gettext, openssl, perl, libiconv
-, qtscript, qtserialport, qttools, makeQtWrapper
+{ mkDerivation, lib, fetchurl
+, cmake, freetype, libpng, mesa, gettext, openssl, perl, libiconv
+, qtscript, qtserialport, qttools
 , qtmultimedia
 }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "stellarium-${version}";
   version = "0.15.0";
 
···
     sha256 = "0il751lgnfkx35h1m8fzwwnrygpxjx2a80gng1i1rbybkykf7l3l";
   };
 
-  nativeBuildInputs = [ makeQtWrapper ];
+  nativeBuildInputs = [ cmake perl ];
 
   buildInputs = [
-    cmake freetype libpng mesa gettext openssl perl libiconv qtscript
-    qtserialport qttools qtmultimedia
+    freetype libpng mesa openssl libiconv qtscript qtserialport qttools
+    qtmultimedia
   ];
 
-  enableParallelBuilding = true;
-
-  postInstall = ''
-    wrapQtProgram "$out/bin/stellarium"
-  '';
-
-  meta = {
+  meta = with lib; {
     description = "Free open-source planetarium";
     homepage = "http://stellarium.org/";
-    license = stdenv.lib.licenses.gpl2;
+    license = licenses.gpl2;
 
-    platforms = stdenv.lib.platforms.linux; # should be mesaPlatforms, but we don't have qt on darwin
-    maintainers = [ stdenv.lib.maintainers.peti ];
+    platforms = platforms.linux; # should be mesaPlatforms, but we don't have qt on darwin
+    maintainers = [ maintainers.peti ];
   };
 }

pkgs/applications/science/electronics/fritzing/default.nix

···
-{ stdenv, fetchpatch, fetchFromGitHub, makeQtWrapper, qmake, pkgconfig
+{ stdenv, fetchpatch, fetchFromGitHub, qmake, pkgconfig
 , qtbase, qtsvg, qtserialport, boost, libgit2
 }:
 
···
 
   buildInputs = [ qtbase qtsvg qtserialport boost libgit2 ];
 
-  nativeBuildInputs = [ qmake makeQtWrapper pkgconfig ];
+  nativeBuildInputs = [ qmake pkgconfig ];
 
   qmakeFlags = [ "phoenix.pro" ];
-
-  enableParallelBuilding = true;
 
   preConfigure = ''
     ln -s "$parts" parts
-  '';
-
-  postInstall = ''
-    wrapQtProgram $out/bin/Fritzing
   '';
 
   meta = {

pkgs/applications/science/math/speedcrunch/default.nix

···
-{ stdenv, fetchgit, cmake, makeQtWrapper, qtbase, qttools }:
+{ mkDerivation, lib, fetchgit, cmake, qtbase, qttools }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "speedcrunch-${version}";
   version = "0.12.0";
 
···
     sha256 = "0vh7cd1915bjqzkdp3sk25ngy8cq624mkh8c53c5bnzk357kb0fk";
   };
 
-  enableParallelBuilding = true;
-
   buildInputs = [ qtbase qttools ];
 
-  nativeBuildInputs = [ cmake makeQtWrapper ];
+  nativeBuildInputs = [ cmake ];
 
   preConfigure = ''
     cd src
   '';
 
-  postFixup = ''
-    wrapQtProgram $out/bin/speedcrunch
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage    = http://speedcrunch.org;
     license     = licenses.gpl2Plus;
     description = "A fast power user calculator";

pkgs/applications/science/robotics/qgroundcontrol/default.nix

···
 { stdenv, fetchgit, git,  espeak, SDL, udev, doxygen, cmake
 , qtbase, qtlocation, qtserialport, qtdeclarative, qtconnectivity, qtxmlpatterns
 , qtsvg, qtquick1, qtquickcontrols, qtgraphicaleffects, qmake
-, makeQtWrapper, lndir
+, makeWrapper, lndir
 , gst_all_1, qt-gstreamer1, pkgconfig, glibc
 , version ? "2.9.4"
 }:
···
 
   enableParallelBuilding = true;
   buildInputs = [ SDL udev doxygen git ] ++ gstInputs ++ qtInputs;
-  nativeBuildInputs = [ pkgconfig makeQtWrapper qmake ];
+  nativeBuildInputs = [ pkgconfig makeWrapper qmake ];
 
   patches = [ ./0001-fix-gcc-cmath-namespace-issues.patch ];
   postPatch = ''
···
 
 
   postInstall = ''
-    wrapQtProgram "$out/bin/qgroundcontrol" \
+    wrapProgram "$out/bin/qgroundcontrol" \
       --prefix GST_PLUGIN_SYSTEM_PATH : "$GST_PLUGIN_SYSTEM_PATH"
   '';
   

pkgs/applications/video/bomi/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, pkgconfig, perl, python, which, makeQtWrapper
+{ stdenv, fetchFromGitHub, fetchpatch, pkgconfig, perl, python, which
 , libX11, libxcb, mesa
-, qtbase, qtdeclarative, qtquickcontrols, qttools, qtx11extras, qmake
+, qtbase, qtdeclarative, qtquickcontrols, qttools, qtx11extras, qmake, makeWrapper
 , libchardet
 , ffmpeg
 
···
   '';
 
   postInstall = ''
-    wrapQtProgram $out/bin/bomi \
+    wrapProgram $out/bin/bomi \
       ${optionalString youtubeSupport "--prefix PATH ':' '${youtube-dl}/bin'"}
   '';
 
···
                    ++ optional cddaSupport "--enable-cdda"
                    ;
 
-  nativeBuildInputs = [ pkgconfig perl python which qttools makeQtWrapper qmake ];
-
-  enableParallelBuilding = true;
+  nativeBuildInputs = [ makeWrapper pkgconfig perl python which qttools qmake ];
 
   meta = with stdenv.lib; {
     description = "Powerful and easy-to-use multimedia player";

pkgs/applications/video/openshot-qt/default.nix

···
 { stdenv, fetchFromGitHub
 , doxygen, python3Packages, libopenshot
-, makeQtWrapper, wrapGAppsHook, gtk3 }:
+, wrapGAppsHook, gtk3 }:
 
 python3Packages.buildPythonApplication rec {
   name = "openshot-qt-${version}";

pkgs/applications/video/shotcut/default.nix

···
 { stdenv, fetchurl, SDL, frei0r, gettext, mlt, jack1, pkgconfig, qtbase,
 qtmultimedia, qtwebkit, qtx11extras, qtwebsockets, qtquickcontrols,
 qtgraphicaleffects,
-qmake, makeQtWrapper }:
+qmake, makeWrapper }:
 
 stdenv.mkDerivation rec {
   name = "shotcut-${version}";
···
 
 
   enableParallelBuilding = true;
-  nativeBuildInputs = [ makeQtWrapper pkgconfig qmake ];
+  nativeBuildInputs = [ makeWrapper pkgconfig qmake ];
   buildInputs = [
     SDL frei0r gettext mlt
     qtbase qtmultimedia qtwebkit qtx11extras qtwebsockets qtquickcontrols
···
   postInstall = ''
     mkdir -p $out/share/shotcut
     cp -r src/qml $out/share/shotcut/
-    wrapQtProgram $out/bin/shotcut --prefix FREI0R_PATH : ${frei0r}/lib/frei0r-1 --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath [ jack1 SDL ]} --prefix PATH : ${mlt}/bin
+    wrapProgram $out/bin/shotcut --prefix FREI0R_PATH : ${frei0r}/lib/frei0r-1 --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath [ jack1 SDL ]} --prefix PATH : ${mlt}/bin
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/virtualization/virt-manager/qt.nix

···
-{ stdenv, fetchFromGitHub, cmake, pkgconfig
-, qtbase, qtmultimedia, qtsvg, makeQtWrapper
+{ mkDerivation, lib, fetchFromGitHub, cmake, pkgconfig
+, qtbase, qtmultimedia, qtsvg
 , lxqt, libvncserver, libvirt, pixman, spice_gtk, spice_protocol
 }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "virt-manager-qt-${version}";
   version = "0.43.70.2";
 
···
     libvirt libvncserver pixman spice_gtk spice_protocol
   ];
 
-  nativeBuildInputs = [ cmake pkgconfig makeQtWrapper ];
-
-  postFixup = ''
-    for f in $out/bin/* ; do
-      wrapQtProgram $f
-    done
-  '';
-
-  enableParallelBuilding = true;
+  nativeBuildInputs = [ cmake pkgconfig ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = http://f1ash.github.io/qt-virt-manager;
     description = "Desktop user interface for managing virtual machines (QT)";
     longDescription = ''

pkgs/applications/virtualization/virtualbox/default.nix

···
     ++ optional pythonBindings python # Python is needed even when not building bindings
     ++ optional pulseSupport libpulseaudio
     ++ optionals (headless) [ libXrandr ]
-    ++ optionals (!headless) [ qt5.qtbase qt5.qtx11extras qt5.makeQtWrapper libXinerama SDL ];
+    ++ optionals (!headless) [ qt5.qtbase qt5.qtx11extras libXinerama SDL ];
 
   hardeningDisable = [ "fortify" "pic" "stackprotector" ];
 
···
     find out/linux.*/${buildType}/bin -mindepth 1 -maxdepth 1 \
       -name src -o -exec cp -avt "$libexec" {} +
 
-    # Create wrapper script
     mkdir -p $out/bin
-    ${optionalString (!headless) ''
-      makeQtWrapper "$libexec/VirtualBox" $out/bin/VirtualBox
-    ''}
-    for file in ${optionalString (!headless) "VBoxSDL rdesktop-vrdp"} VBoxManage VBoxBalloonCtrl VBoxHeadless; do
+    for file in ${optionalString (!headless) "VirtualBox VBoxSDL rdesktop-vrdp"} VBoxManage VBoxBalloonCtrl VBoxHeadless; do
         echo "Linking $file to /bin"
         test -x "$libexec/$file"
         ln -s "$libexec/$file" $out/bin/$file

pkgs/desktops/plasma-5/systemsettings.nix

···
 {
-  mkDerivation, extra-cmake-modules, kdoctools, makeQtWrapper,
+  mkDerivation, extra-cmake-modules, kdoctools,
   kcmutils, kconfig, kdbusaddons, khtml, ki18n, kiconthemes, kio, kitemviews,
   kservice, kwindowsystem, kxmlgui, qtquickcontrols, qtquickcontrols2
 }:

pkgs/development/libraries/libqtav/default.nix

···
-{ stdenv, lib, fetchFromGitHub, extra-cmake-modules, makeQtWrapper
+{ mkDerivation, lib, fetchFromGitHub, extra-cmake-modules
 , qtbase, qtmultimedia, qtquick1, qttools
 , mesa, libX11
 , libass, openal, ffmpeg, libuchardet
 , alsaLib, libpulseaudio, libva
 }:
 
-with stdenv.lib;
+with lib;
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "libqtav-${version}";
 
   # Awaiting upcoming `v1.12.0` release. `v1.11.0` is not supporting cmake which is the
   # the reason behind taking an unstable git rev. 
   version = "unstable-2017-03-30";
 
-  nativeBuildInputs = [ extra-cmake-modules makeQtWrapper qttools ];
+  nativeBuildInputs = [ extra-cmake-modules qttools ];
   buildInputs = [ 
     qtbase qtmultimedia qtquick1
     mesa libX11
···
   preFixup = ''
     mkdir -p "$out/bin"
     cp -a "./bin/"* "$out/bin"
-  '';
-
-  postFixup = ''
-    for i in `find $out/bin -maxdepth 1 -xtype f -executable`; do
-      wrapQtProgram "$i"
-    done
   '';
 
   meta = {

pkgs/development/libraries/qt-5/5.6/default.nix

···
         qtwebchannel qtwebengine qtwebkit qtwebsockets qtx11extras qtxmlpatterns
       ];
 
-      makeQtWrapper =
-        makeSetupHook
-        { deps = [ makeWrapper ]; }
-        (if stdenv.isDarwin then ../make-qt-wrapper-darwin.sh else ../make-qt-wrapper.sh);
-
       qmake = makeSetupHook {
         deps = [ self.qtbase.dev ];
         substitutions = { inherit (stdenv) isDarwin; };

pkgs/development/libraries/qt-5/5.8/default.nix

···
       ] ++ optional (!stdenv.isDarwin) qtwayland
         ++ optional (stdenv.isDarwin) qtmacextras);
 
-      makeQtWrapper =
-        makeSetupHook
-        { deps = [ makeWrapper ] ++ optionals (!stdenv.isDarwin) [ dconf.lib gtk3 ]; }
-        (if stdenv.isDarwin then ../make-qt-wrapper-darwin.sh else ../make-qt-wrapper.sh);
-
-
       qmake = makeSetupHook {
         deps = [ self.qtbase.dev ];
         substitutions = { inherit (stdenv) isDarwin; };

pkgs/development/libraries/qt-5/5.8/qtdeclarative/default.nix

···
-{ stdenv, qtSubmodule, makeQtWrapper, copyPathsToStore, python2, qtbase, qtsvg, qtxmlpatterns }:
+{ stdenv, qtSubmodule, copyPathsToStore, python2, qtbase, qtsvg, qtxmlpatterns }:
 
 with stdenv.lib;
 
···
   name = "qtdeclarative";
   patches = copyPathsToStore (readPathsFromFile ./. ./series);
   qtInputs = [ qtbase qtsvg qtxmlpatterns ];
-  nativeBuildInputs = [ python2 makeQtWrapper ];
+  nativeBuildInputs = [ python2 ];
 
   preConfigure = ''
     NIX_CFLAGS_COMPILE+=" -DNIXPKGS_QML2_IMPORT_PREFIX=\"$qtQmlPrefix\""
-  '';
-
-  postInstall = ''
-    wrapQtProgram $out/bin/qmleasing
-    wrapQtProgram $out/bin/qmlscene
-    wrapQtProgram $out/bin/qmltestrunner
-  '' + optionalString (stdenv.isDarwin) ''
-    wrapQtProgram $out/bin/qml.app/Contents/MacOS/qml
   '';
 }

pkgs/development/libraries/qt-5/5.8/qttools/default.nix

···
-{ stdenv, qtSubmodule, makeQtWrapper, copyPathsToStore, qtbase }:
+{ stdenv, qtSubmodule, copyPathsToStore, qtbase }:
 
 with stdenv.lib;
 
 qtSubmodule {
   name = "qttools";
   qtInputs = [ qtbase ];
-  nativeBuildInputs = [ makeQtWrapper ];
 
   patches = copyPathsToStore (readPathsFromFile ./. ./series);
   postFixup = ''
     moveToOutput "bin/qdbus" "$out"
     moveToOutput "bin/qtpaths" "$out"
-  '';
-
-  postInstall =   ''
-    wrapQtProgram $out/bin/qcollectiongenerator
-    wrapQtProgram $out/bin/qhelpconverter
-    wrapQtProgram $out/bin/qhelpgenerator
-    wrapQtProgram $out/bin/qtdiag
-  '' + optionalString (stdenv.isDarwin) ''
-    wrapQtProgram $out/bin/Assistant.app/Contents/MacOS/Assistant
-    wrapQtProgram $out/bin/Designer.app/Contents/MacOS/Designer
-    wrapQtProgram $out/bin/Linguist.app/Contents/MacOS/Linguist
-    wrapQtProgram $out/bin/pixeltool.app/Contents/MacOS/pixeltool
-    wrapQtProgram $out/bin/qdbusviewer.app/Contents/MacOS/qdbusviewer
   '';
 }

pkgs/development/libraries/qt-5/make-qt-wrapper-darwin.sh

···
-wrapQtProgram() {
-    local prog="$1"
-    shift
-    wrapProgram "$prog" \
-        --set QT_PLUGIN_PATH "$QT_PLUGIN_PATH" \
-        --set QML2_IMPORT_PATH "$QML2_IMPORT_PATH" \
-        --set DYLD_FRAMEWORK_PATH "/System/Library/Frameworks" \
-        --prefix XDG_DATA_DIRS : "$RUNTIME_XDG_DATA_DIRS" \
-        --prefix XDG_CONFIG_DIRS : "$RUNTIME_XDG_CONFIG_DIRS" \
-        "$@"
-}
-
-makeQtWrapper() {
-    local old="$1"
-    local new="$2"
-    shift
-    shift
-    makeWrapper "$old" "$new" \
-        --set QT_PLUGIN_PATH "$QT_PLUGIN_PATH" \
-        --set QML2_IMPORT_PATH "$QML2_IMPORT_PATH" \
-        --set DYLD_FRAMEWORK_PATH "/System/Library/Frameworks" \
-        --prefix XDG_DATA_DIRS : "$RUNTIME_XDG_DATA_DIRS" \
-        --prefix XDG_CONFIG_DIRS : "$RUNTIME_XDG_CONFIG_DIRS" \
-        "$@"
-}
-
-_makeQtWrapperSetup() {
-    # cannot use addToSearchPath because these directories may not exist yet
-    export QT_PLUGIN_PATH="$QT_PLUGIN_PATH${QT_PLUGIN_PATH:+:}${!outputLib}/$qtPluginPrefix"
-    export QML2_IMPORT_PATH="$QML2_IMPORT_PATH${QML2_IMPORT_PATH:+:}${!outputLib}/$qtQmlPrefix"
-    export RUNTIME_XDG_DATA_DIRS="$RUNTIME_XDG_DATA_DIRS${RUNTIME_XDG_DATA_DIRS:+:}${!outputBin}/share"
-    export RUNTIME_XDG_CONFIG_DIRS="$RUNTIME_XDG_CONFIG_DIRS${RUNTIME_XDG_CONFIG_DIRS:+:}${!outputBin}/etc/xdg"
-}
-
-prePhases+=(_makeQtWrapperSetup)

pkgs/development/libraries/qt-5/make-qt-wrapper.sh

···
-wrapQtProgram() {
-    local prog="$1"
-    shift
-    wrapProgram "$prog" \
-        --prefix QT_PLUGIN_PATH : "$QT_PLUGIN_PATH" \
-        --prefix QML2_IMPORT_PATH : "$QML2_IMPORT_PATH" \
-        --prefix XDG_DATA_DIRS : "$RUNTIME_XDG_DATA_DIRS" \
-        --prefix XDG_CONFIG_DIRS : "$RUNTIME_XDG_CONFIG_DIRS" \
-        --prefix GIO_EXTRA_MODULES : "$GIO_EXTRA_MODULES" \
-        "$@"
-}
-
-makeQtWrapper() {
-    local old="$1"
-    local new="$2"
-    shift
-    shift
-    makeWrapper "$old" "$new" \
-        --prefix QT_PLUGIN_PATH : "$QT_PLUGIN_PATH" \
-        --prefix QML2_IMPORT_PATH : "$QML2_IMPORT_PATH" \
-        --prefix XDG_DATA_DIRS : "$RUNTIME_XDG_DATA_DIRS" \
-        --prefix XDG_CONFIG_DIRS : "$RUNTIME_XDG_CONFIG_DIRS" \
-        --prefix GIO_EXTRA_MODULES : "$GIO_EXTRA_MODULES" \
-        "$@"
-}
-
-_makeQtWrapperSetup() {
-    # cannot use addToSearchPath because these directories may not exist yet
-    export QT_PLUGIN_PATH="$QT_PLUGIN_PATH${QT_PLUGIN_PATH:+:}${!outputLib}/$qtPluginPrefix"
-    export QML2_IMPORT_PATH="$QML2_IMPORT_PATH${QML2_IMPORT_PATH:+:}${!outputLib}/$qtQmlPrefix"
-    export RUNTIME_XDG_DATA_DIRS="$RUNTIME_XDG_DATA_DIRS${RUNTIME_XDG_DATA_DIRS:+:}${!outputBin}/share${GSETTINGS_SCHEMAS_PATH:+:$GSETTINGS_SCHEMAS_PATH}"
-    export RUNTIME_XDG_CONFIG_DIRS="$RUNTIME_XDG_CONFIG_DIRS${RUNTIME_XDG_CONFIG_DIRS:+:}${!outputBin}/etc/xdg"
-}
-
-prePhases+=(_makeQtWrapperSetup)
-
-_findGioModules() {
-    if [ -d "$1"/lib/gio/modules ] && [ -n "$(ls -A $1/lib/gio/modules)" ] ; then
-        export GIO_EXTRA_MODULES="$GIO_EXTRA_MODULES${GIO_EXTRA_MODULES:+:}$1/lib/gio/modules"
-    fi
-}
-
-envHooks+=(_findGioModules)

pkgs/development/qtcreator/default.nix

···
 { stdenv, fetchurl, makeWrapper
-, qtbase, makeQtWrapper, qtquickcontrols, qtscript, qtdeclarative, qmake
+, qtbase, qtquickcontrols, qtscript, qtdeclarative, qmake
 , withDocumentation ? false
 }:
 
···
 
   buildInputs = [ qtbase qtscript qtquickcontrols qtdeclarative ];
 
-  nativeBuildInputs = [ qmake makeQtWrapper makeWrapper ];
+  nativeBuildInputs = [ qmake makeWrapper ];
 
   doCheck = true;
 
···
   postInstall = ''
     substituteInPlace $out/share/applications/org.qt-project.qtcreator.desktop \
       --replace "Exec=qtcreator" "Exec=$out/bin/qtcreator"
-    wrapQtProgram $out/bin/qtcreator
   '';
 
   meta = {

pkgs/development/tools/analysis/qcachegrind/default.nix

···
-{ stdenv, fetchurl, cmake, qmake, makeQtWrapper, qtbase, perl, python, php }:
+{ stdenv, fetchurl, cmake, qmake, qtbase, perl, python, php }:
 
 stdenv.mkDerivation rec {
   name = "qcachegrind-${version}";
···
 
   buildInputs = [ qtbase perl python php ];
 
-  nativeBuildInputs = [ qmake makeQtWrapper ];
+  nativeBuildInputs = [ qmake ];
 
   postInstall = ''
      mkdir -p $out/bin
···
     mkdir -p $out/Applications
     cp cgview/cgview.app/Contents/MacOS/cgview $out/bin
     cp -a qcachegrind/qcachegrind.app $out/Applications
-    wrapQtProgram $out/Applications/qcachegrind.app/Contents/MacOS/qcachegrind
   '' else ''
     install qcachegrind/qcachegrind cgview/cgview -t "$out/bin"
-    wrapQtProgram "$out/bin/qcachegrind"
     install -Dm644 qcachegrind/qcachegrind.desktop -t "$out/share/applications"
     install -Dm644 kcachegrind/hi32-app-kcachegrind.png "$out/share/icons/hicolor/32x32/apps/kcachegrind.png"
     install -Dm644 kcachegrind/hi48-app-kcachegrind.png "$out/share/icons/hicolor/48x48/apps/kcachegrind.png"

pkgs/development/tools/database/sqlitebrowser/default.nix

···
-{ stdenv, fetchFromGitHub, qtbase, qttools, makeQtWrapper, sqlite, cmake }:
+{ mkDerivation, lib, fetchFromGitHub, qtbase, qttools, sqlite, cmake }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   version = "3.9.1";
   name = "sqlitebrowser-${version}";
 
···
   };
 
   buildInputs = [ qtbase qttools sqlite ];
-  nativeBuildInputs = [ makeQtWrapper cmake ];
-  
-  enableParallelBuilding = true;
-  
+  nativeBuildInputs = [ cmake ];
+
   cmakeFlags = [ "-DUSE_QT5=TRUE" ];
-  
+
   # A regression was introduced in CMakeLists.txt on v3.9.x
   # See https://github.com/sqlitebrowser/sqlitebrowser/issues/832 and issues/755
   postPatch = ''
     substituteInPlace CMakeLists.txt --replace 'project("DB Browser for SQLite")' 'project(sqlitebrowser)'
   '';
 
-  postInstall = ''
-    wrapQtProgram $out/bin/sqlitebrowser
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "DB Browser for SQLite";
     homepage = "http://sqlitebrowser.org/";
     license = licenses.gpl3;

pkgs/development/tools/tora/default.nix

···
-{ stdenv, lib, fetchFromGitHub, cmake, extra-cmake-modules, makeQtWrapper
+{ mkDerivation, lib, fetchFromGitHub, cmake, extra-cmake-modules, makeWrapper
 , boost, doxygen, openssl, mysql, postgresql, graphviz, loki, qscintilla, qtbase }:
 
 let
   qscintillaLib = (qscintilla.override { withQt5 = true; });
 
-in stdenv.mkDerivation rec {
+in mkDerivation rec {
   name = "tora-${version}";
   version = "3.1";
 
···
     sha256 = "0wninl10bcgiljf6wnhn2rv8kmzryw78x5qvbw8s2zfjlnxjsbn7";
   };
 
-  enableParallelBuilding = true;
-
+  nativeBuildInputs = [ cmake extra-cmake-modules makeWrapper ];
   buildInputs = [
-    cmake extra-cmake-modules makeQtWrapper
     boost doxygen graphviz loki mysql openssl postgresql qscintillaLib qtbase
   ];
 
···
   ];
 
   postFixup = ''
-    wrapQtProgram $out/bin/tora \
+    wrapProgram $out/bin/tora \
       --prefix PATH : ${lib.getBin graphviz}/bin
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Tora SQL tool";
     maintainers = with maintainers; [ peterhoeg ];
     platforms = platforms.linux;

pkgs/development/tools/vogl/default.nix

···
-{ fetchFromGitHub, stdenv
+{ mkDerivation, lib, fetchFromGitHub
 , cmake, git, pkgconfig, wget, zip
-, makeQtWrapper, qtbase, qtx11extras
+, qtbase, qtx11extras
 , libdwarf, libjpeg_turbo, libunwind, lzma, tinyxml, libX11
 , SDL2, SDL2_gfx, SDL2_image, SDL2_ttf
 , freeglut, mesa_glu
 }:
-stdenv.mkDerivation rec {
+
+mkDerivation rec {
   name = "vogl-${version}";
   version = "2016-05-13";
 
···
     sha256 = "17gwd73x3lnqv6ccqs48pzqwbzjhbn41c0x0l5zzirhiirb3yh0n";
   };
 
-  nativeBuildInputs = [
-    cmake makeQtWrapper pkgconfig
-  ];
+  nativeBuildInputs = [ cmake pkgconfig ];
 
   buildInputs = [
     git wget zip
···
     freeglut mesa_glu
   ];
 
-  enableParallelBuilding = true;
-
   dontUseCmakeBuildDir = true;
   preConfigure = ''
     cmakeDir=$PWD
     mkdir -p vogl/vogl_build/release64 && cd $_
   '';
-  cmakeFlags = '' -DCMAKE_VERBOSE=On -DCMAKE_BUILD_TYPE=Release -DBUILD_X64=On'';
+  cmakeFlags = [
+    "-DCMAKE_VERBOSE=On"
+    "-DBUILD_X64=On"
+  ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "OpenGL capture / playback debugger.";
     homepage = https://github.com/ValveSoftware/vogl;
     license = licenses.mit;

pkgs/os-specific/linux/v4l-utils/default.nix

···
-{ stdenv, lib, fetchurl, pkgconfig, perl, makeQtWrapper
+{ stdenv, lib, fetchurl, pkgconfig, perl
 , libjpeg, udev
 , withUtils ? true
 , withGUI ? true, alsaLib, libX11, qtbase, mesa_glu
···
     ln -s "$dev/include/libv4l1-videodev.h" "$dev/include/videodev.h"
   '';
 
-  nativeBuildInputs = [ pkgconfig perl ] ++ lib.optional (withUtils && withGUI) makeQtWrapper;
+  nativeBuildInputs = [ pkgconfig perl ];
 
   buildInputs = [ udev ] ++ lib.optionals (withUtils && withGUI) [ alsaLib libX11 qtbase mesa_glu ];
 
···
 
   postPatch = ''
     patchShebangs .
-  '';
-
-  postInstall = lib.optionalString (withUtils && withGUI) ''
-    wrapQtProgram $out/bin/qv4l2
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/audio/qastools/default.nix

···
-{ stdenv, fetchurl, cmake, alsaLib, udev, qtbase,
-  qtsvg, qttools, makeQtWrapper }:
+{ mkDerivation, lib, fetchurl, cmake, alsaLib, udev, qtbase, qtsvg, qttools }:
 
 let
   version = "0.21.0";
 in
 
-stdenv.mkDerivation {
+mkDerivation {
   name = "qastools-${version}";
 
   src = fetchurl {
···
   };
 
   buildInputs = [
-    cmake alsaLib udev qtbase qtsvg qttools makeQtWrapper
+    alsaLib udev qtbase qtsvg qttools
   ];
+  nativeBuildInputs = [ cmake ];
 
   cmakeFlags = [
-    "-DCMAKE_INSALL_PREFIX=$out"
     "-DALSA_INCLUDE=${alsaLib.dev}/include/alsa/version.h"
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Collection of desktop applications for ALSA configuration";
     license = licenses.gpl3;
     platforms = platforms.linux;

pkgs/tools/misc/antimicro/default.nix

···
-{ stdenv, cmake, pkgconfig, SDL2, qtbase, qttools, makeQtWrapper, xorg, fetchFromGitHub }:
+{ mkDerivation, lib, cmake, pkgconfig, SDL2, qtbase, qttools, xorg, fetchFromGitHub }:
 
-stdenv.mkDerivation rec {
+mkDerivation rec {
   name = "antimicro-${version}";
   version = "2.23";
 
···
     sha256 = "1q40ayxwwyq85lc89cnj1cm2nar625h4vhh8dvmb2qcxczaggf4v";
   };
 
+  nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [
-    cmake pkgconfig SDL2 qtbase qttools xorg.libXtst makeQtWrapper
+    SDL2 qtbase qttools xorg.libXtst
   ];
 
-  postInstall = ''
-    wrapQtProgram $out/bin/antimicro
-  '';
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "GUI for mapping keyboard and mouse controls to a gamepad";
     inherit (src.meta) homepage;
     maintainers = with maintainers; [ jb55 ];

pkgs/tools/misc/qt5ct/default.nix

···
-{ stdenv, fetchurl, qtbase, qtsvg, qttools, qmake, makeQtWrapper }:
+{ stdenv, fetchurl, qtbase, qtsvg, qttools, qmake }:
 
 stdenv.mkDerivation rec {
   name = "qt5ct-${version}";
···
 
   preConfigure = ''
     qmakeFlags="$qmakeFlags PLUGINDIR=$out/$qtPluginPrefix"
-  '';
-
-  preFixup = ''
-    wrapQtProgram $out/bin/qt5ct
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/misc/radeon-profile/default.nix

···
-{ stdenv, fetchFromGitHub, qtbase, qmake, makeQtWrapper, libXrandr }:
+{ stdenv, fetchFromGitHub, qtbase, qmake, libXrandr }:
 
 stdenv.mkDerivation rec {
 
   name = "radeon-profile-${version}";
   version = "20161221";
 
-  nativeBuildInputs = [ qmake makeQtWrapper ];
+  nativeBuildInputs = [ qmake ];
   buildInputs = [ qtbase libXrandr ];
 
   src = (fetchFromGitHub {
···
   postInstall = ''
     mkdir -p $out/bin
     cp ./radeon-profile $out/bin/radeon-profile
-    wrapQtProgram  $out/bin/radeon-profile
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/misc/rockbox-utility/default.nix

···
 { stdenv, fetchurl, pkgconfig, libusb1
-, qtbase, qttools, makeQtWrapper, qmake
+, qtbase, qttools, makeWrapper, qmake
 , withEspeak ? false, espeak ? null }:
 
 stdenv.mkDerivation  rec {
···
 
   buildInputs = [ libusb1 qtbase qttools ]
     ++ stdenv.lib.optional withEspeak espeak;
-  nativeBuildInputs = [ makeQtWrapper pkgconfig qmake ];
+  nativeBuildInputs = [ makeWrapper pkgconfig qmake ];
 
   preConfigure = ''
     cd rbutil/rbutilqt
···
 
     install -Dm755 RockboxUtility $out/bin/rockboxutility
     ln -s $out/bin/rockboxutility $out/bin/RockboxUtility
-    wrapQtProgram $out/bin/rockboxutility \
+    wrapProgram $out/bin/rockboxutility \
     ${stdenv.lib.optionalString withEspeak ''
       --prefix PATH : ${espeak}/bin
     ''}

pkgs/top-level/all-packages.nix

···
       recurseIntoAttrs (makeOverridable mkApplications attrs);
 
   inherit (kdeApplications)
-    akonadi ark dolphin ffmpegthumbs filelight gwenview kate
-    kdenlive kcalc kcolorchooser kcontacts kgpg khelpcenter kig
-    kolourpaint konsole krfb marble
-    okteta okular spectacle;
+    akonadi ark dolphin ffmpegthumbs filelight gwenview kate kdenlive
+    kcachegrind kcalc kcolorchooser kcontacts kdf kgpg khelpcenter kig kmix
+    kolourpaint kompare konsole krfb kwalletmanager marble okteta okular
+    spectacle;
 
   kdeconnect = libsForQt5.callPackage ../applications/misc/kdeconnect { };