commit 4f34e030a59a9ef89cec459c223c54cf1e6bc199 · pyrox.dev/nixpkgs

+2 -2

nixos/modules/misc/ids.nix

···

       64
       64
        
             cups = 36;

     

       65
       65
        
             foldingathome = 37;

     

       66
       66
        
             sabnzbd = 38;

     

       67
       67
       -
             kdm = 39;

     

       67
       67
       +
             #kdm = 39; # dropped in 17.03

     

       68
       68
        
             ghostone = 40;

     

       69
       69
        
             git = 41;

     

       70
       70
        
             fourstore = 42;

     
···

       333
       333
        
             #cups = 36; # unused

     

       334
       334
        
             #foldingathome = 37; # unused

     

       335
       335
        
             #sabnzd = 38; # unused

     

       336
       336
       -
             #kdm = 39; # unused

     

       336
       336
       +
             #kdm = 39; # unused, even before 17.03

     

       337
       337
        
             ghostone = 40;

     

       338
       338
        
             git = 41;

     

       339
       339
        
             fourstore = 42;

-1

nixos/modules/module-list.nix

···

       559
       559
        
         ./services/x11/display-managers/auto.nix

     

       560
       560
        
         ./services/x11/display-managers/default.nix

     

       561
       561
        
         ./services/x11/display-managers/gdm.nix

     

       562
       562
       -
         ./services/x11/display-managers/kdm.nix

     

       563
       562
        
         ./services/x11/display-managers/lightdm.nix

     

       564
       563
        
         ./services/x11/display-managers/sddm.nix

     

       565
       564
        
         ./services/x11/display-managers/slim.nix

+2 -4

nixos/modules/services/hardware/bluetooth.nix

···

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       let

     

       5
       5
       -
         isBluez4 = config.services.xserver.desktopManager.kde4.enable;

     

       6
       6
       -
         bluez-bluetooth = if isBluez4 then pkgs.bluez4 else pkgs.bluez;

     

       7
       7
       -
       

     

       5
       5
       +
         bluez-bluetooth = pkgs.bluez;

     

       8
       6
        
       in

     

       9
       7
        
       

     

       10
       8
        
       {

     
···

       38
       36
        
             aliases = [ "dbus-org.bluez.service" ];

     

       39
       37
        
           };

     

       40
       38
        
       

     

       41
       41
       -
           systemd.user.services.obex = mkIf (!isBluez4) {

     

       39
       39
       +
           systemd.user.services.obex = {

     

       42
       40
        
             aliases = [ "dbus-org.bluez.obex.service" ];

     

       43
       41
        
           };

     

       44
       42

+3 -3

nixos/modules/services/networking/quassel.nix

···

       25
       25
        
       

     

       26
       26
        
             package = mkOption {

     

       27
       27
        
               type = types.package;

     

       28
       28
       -
               default = pkgs.kde4.quasselDaemon;

     

       29
       29
       -
               defaultText = "pkgs.kde4.quasselDaemon";

     

       28
       28
       +
               default = pkgs.quasselDaemon_qt5;

     

       29
       29
       +
               defaultText = "pkgs.quasselDaemon_qt5";

     

       30
       30
        
               description = ''

     

       31
       31
        
                 The package of the quassel daemon.

     

       32
       32
        
               '';

     

       33
       33
       -
               example = literalExample "pkgs.quasselDaemon";

     

       33
       33
       +
               example = literalExample "pkgs.quasselDaemon_qt5";

     

       34
       34
        
             };

     

       35
       35
        
       

     

       36
       36
        
             interfaces = mkOption {

+2 -3

nixos/modules/services/x11/desktop-managers/default.nix

···

       18
       18
        
         # determines the default: later modules (if enabled) are preferred.

     

       19
       19
        
         # E.g., if KDE is enabled, it supersedes xterm.

     

       20
       20
        
         imports = [

     

       21
       21
       -
           ./none.nix ./xterm.nix ./xfce.nix ./kde4.nix ./kde5.nix

     

       22
       22
       -
           ./lumina.nix ./lxqt.nix ./enlightenment.nix ./gnome3.nix

     

       23
       23
       -
           ./kodi.nix

     

       21
       21
       +
           ./none.nix ./xterm.nix ./xfce.nix ./kde5.nix ./lumina.nix

     

       22
       22
       +
           ./lxqt.nix ./enlightenment.nix ./gnome3.nix ./kodi.nix

     

       24
       23
        
         ];

     

       25
       24
        
       

     

       26
       25
        
         options = {

-202

nixos/modules/services/x11/desktop-managers/kde4.nix

···

       1
       1
       -
       { config, lib, pkgs, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
       

     

       7
       7
       -
         xcfg = config.services.xserver;

     

       8
       8
       -
         cfg = xcfg.desktopManager.kde4;

     

       9
       9
       -
         xorg = pkgs.xorg;

     

       10
       10
       -
         kde_workspace = config.services.xserver.desktopManager.kde4.kdeWorkspacePackage;

     

       11
       11
       -
       

     

       12
       12
       -
         # Disable Nepomuk and Strigi by default.  As of KDE 4.7, they don't

     

       13
       13
       -
         # really work very well (e.g. searching files often fails to find

     

       14
       14
       -
         # files), segfault sometimes and consume significant resources.

     

       15
       15
       -
         # They can be re-enabled in the KDE System Settings under "Desktop

     

       16
       16
       -
         # Search".

     

       17
       17
       -
         disableNepomuk = pkgs.writeTextFile

     

       18
       18
       -
           { name = "nepomuk-config";

     

       19
       19
       -
             destination = "/share/config/nepomukserverrc";

     

       20
       20
       -
             text =

     

       21
       21
       -
               ''

     

       22
       22
       -
                 [Basic Settings]

     

       23
       23
       -
                 Start Nepomuk=false

     

       24
       24
       -
       

     

       25
       25
       -
                 [Service-nepomukstrigiservice]

     

       26
       26
       -
                 autostart=false

     

       27
       27
       -
               '';

     

       28
       28
       -
           };

     

       29
       29
       -
       

     

       30
       30
       -
         phononBackends = {

     

       31
       31
       -
           gstreamer = [

     

       32
       32
       -
             pkgs.phonon-backend-gstreamer

     

       33
       33
       -
             pkgs.gst_all.gstPluginsBase

     

       34
       34
       -
             pkgs.gst_all.gstPluginsGood

     

       35
       35
       -
             pkgs.gst_all.gstPluginsUgly

     

       36
       36
       -
             pkgs.gst_all.gstPluginsBad

     

       37
       37
       -
             pkgs.gst_all.gstFfmpeg # for mp3 playback

     

       38
       38
       -
             pkgs.gst_all.gstreamer # needed?

     

       39
       39
       -
           ];

     

       40
       40
       -
       

     

       41
       41
       -
           vlc = [pkgs.phonon-backend-vlc];

     

       42
       42
       -
         };

     

       43
       43
       -
       

     

       44
       44
       -
         phononBackendPackages = flip concatMap cfg.phononBackends

     

       45
       45
       -
           (name: attrByPath [name] (throw "unknown phonon backend `${name}'") phononBackends);

     

       46
       46
       -
       

     

       47
       47
       -
       in

     

       48
       48
       -
       

     

       49
       49
       -
       {

     

       50
       50
       -
         options = {

     

       51
       51
       -
       

     

       52
       52
       -
           services.xserver.desktopManager.kde4 = {

     

       53
       53
       -
             enable = mkOption {

     

       54
       54
       -
               type = types.bool;

     

       55
       55
       -
               default = false;

     

       56
       56
       -
               description = "Enable the KDE 4 desktop environment.";

     

       57
       57
       -
             };

     

       58
       58
       -
       

     

       59
       59
       -
             phononBackends = mkOption {

     

       60
       60
       -
               type = types.listOf types.str;

     

       61
       61
       -
               default = ["gstreamer"];

     

       62
       62
       -
               example = ["gstreamer" "vlc"];

     

       63
       63
       -
               description = "Which phonon multimedia backend kde should use";

     

       64
       64
       -
             };

     

       65
       65
       -
       

     

       66
       66
       -
             kdeWorkspacePackage = mkOption {

     

       67
       67
       -
               internal = true;

     

       68
       68
       -
               default = pkgs.kde4.kde_workspace;

     

       69
       69
       -
               defaultText = "pkgs.kde4.kde_workspace";

     

       70
       70
       -
               type = types.package;

     

       71
       71
       -
               description = "Custom kde-workspace, used for NixOS rebranding.";

     

       72
       72
       -
             };

     

       73
       73
       -
       

     

       74
       74
       -
             enablePIM = mkOption {

     

       75
       75
       -
               type = types.bool;

     

       76
       76
       -
               default = true;

     

       77
       77
       -
               description = "Whether to enable PIM support. Note that enabling this pulls in Akonadi and MariaDB as dependencies.";

     

       78
       78
       -
             };

     

       79
       79
       -
       

     

       80
       80
       -
             enableNepomuk = mkOption {

     

       81
       81
       -
               type = types.bool;

     

       82
       82
       -
               default = false;

     

       83
       83
       -
               description = "Whether to enable Nepomuk (deprecated).";

     

       84
       84
       -
             };

     

       85
       85
       -
           };

     

       86
       86
       -
         };

     

       87
       87
       -
       

     

       88
       88
       -
       

     

       89
       89
       -
         config = mkIf (xcfg.enable && cfg.enable) {

     

       90
       90
       -
           warnings = [

     

       91
       91
       -
             "KDE4 is long unmaintained and will be removed. Please update to KDE5."

     

       92
       92
       -
           ];

     

       93
       93
       -
       

     

       94
       94
       -
           # If KDE 4 is enabled, make it the default desktop manager (unless

     

       95
       95
       -
           # overridden by the user's configuration).

     

       96
       96
       -
           # !!! doesn't work yet ("Multiple definitions. Only one is allowed

     

       97
       97
       -
           # for this option.")

     

       98
       98
       -
           # services.xserver.desktopManager.default = mkOverride 900 "kde4";

     

       99
       99
       -
       

     

       100
       100
       -
           services.xserver.desktopManager.session = singleton

     

       101
       101
       -
             { name = "kde4";

     

       102
       102
       -
               bgSupport = true;

     

       103
       103
       -
               start =

     

       104
       104
       -
                 ''

     

       105
       105
       -
                   # The KDE icon cache is supposed to update itself

     

       106
       106
       -
                   # automatically, but it uses the timestamp on the icon

     

       107
       107
       -
                   # theme directory as a trigger.  Since in Nix the

     

       108
       108
       -
                   # timestamp is always the same, this doesn't work.  So as

     

       109
       109
       -
                   # a workaround, nuke the icon cache on login.  This isn't

     

       110
       110
       -
                   # perfect, since it may require logging out after

     

       111
       111
       -
                   # installing new applications to update the cache.

     

       112
       112
       -
                   # See http://lists-archives.org/kde-devel/26175-what-when-will-icon-cache-refresh.html

     

       113
       113
       -
                   rm -fv $HOME/.kde/cache-*/icon-cache.kcache

     

       114
       114
       -
       

     

       115
       115
       -
                   # Qt writes a weird ‘libraryPath’ line to

     

       116
       116
       -
                   # ~/.config/Trolltech.conf that causes the KDE plugin

     

       117
       117
       -
                   # paths of previous KDE invocations to be searched.

     

       118
       118
       -
                   # Obviously using mismatching KDE libraries is potentially

     

       119
       119
       -
                   # disastrous, so here we nuke references to the Nix store

     

       120
       120
       -
                   # in Trolltech.conf.  A better solution would be to stop

     

       121
       121
       -
                   # Qt from doing this wackiness in the first place.

     

       122
       122
       -
                   if [ -e $HOME/.config/Trolltech.conf ]; then

     

       123
       123
       -
                       sed -e '/nix\\store\|nix\/store/ d' -i $HOME/.config/Trolltech.conf

     

       124
       124
       -
                   fi

     

       125
       125
       -
       

     

       126
       126
       -
                   # Load PulseAudio module for routing support.

     

       127
       127
       -
                   # See http://colin.guthr.ie/2009/10/so-how-does-the-kde-pulseaudio-support-work-anyway/

     

       128
       128
       -
                   ${optionalString config.hardware.pulseaudio.enable ''

     

       129
       129
       -
                     ${getBin config.hardware.pulseaudio.package}/bin/pactl load-module module-device-manager "do_routing=1"

     

       130
       130
       -
                   ''}

     

       131
       131
       -
       

     

       132
       132
       -
                   # Start KDE.

     

       133
       133
       -
                   exec ${kde_workspace}/bin/startkde

     

       134
       134
       -
                 '';

     

       135
       135
       -
             };

     

       136
       136
       -
       

     

       137
       137
       -
           security.setuidOwners = singleton

     

       138
       138
       -
             { program = "kcheckpass";

     

       139
       139
       -
               source = "${kde_workspace}/lib/kde4/libexec/kcheckpass";

     

       140
       140
       -
               owner = "root";

     

       141
       141
       -
               group = "root";

     

       142
       142
       -
               setuid = true;

     

       143
       143
       -
             };

     

       144
       144
       -
       

     

       145
       145
       -
           environment.systemPackages =

     

       146
       146
       -
               [ pkgs.kde4.kdelibs

     

       147
       147
       -
       

     

       148
       148
       -
                 pkgs.kde4.kde_baseapps # Splitted kdebase

     

       149
       149
       -
                 kde_workspace

     

       150
       150
       -
                 pkgs.kde4.kde_runtime

     

       151
       151
       -
                 pkgs.kde4.konsole

     

       152
       152
       -
                 pkgs.kde4.kate

     

       153
       153
       -
       

     

       154
       154
       -
                 pkgs.kde4.kde_wallpapers # contains kdm's default background

     

       155
       155
       -
                 pkgs.kde4.oxygen_icons

     

       156
       156
       -
       

     

       157
       157
       -
                 # Starts KDE's Polkit authentication agent.

     

       158
       158
       -
                 pkgs.kde4.polkit_kde_agent

     

       159
       159
       -
       

     

       160
       160
       -
                 # Miscellaneous runtime dependencies.

     

       161
       161
       -
                 pkgs.kde4.qt4 # needed for qdbus

     

       162
       162
       -
                 pkgs.shared_mime_info

     

       163
       163
       -
                 xorg.xmessage # so that startkde can show error messages

     

       164
       164
       -
                 xorg.xset # used by startkde, non-essential

     

       165
       165
       -
                 xorg.xauth # used by kdesu

     

       166
       166
       -
               ]

     

       167
       167
       -
             ++ optionals cfg.enablePIM

     

       168
       168
       -
               [ pkgs.kde4.kdepim_runtime

     

       169
       169
       -
                 pkgs.kde4.akonadi

     

       170
       170
       -
                 pkgs.mysql # used by akonadi

     

       171
       171
       -
               ]

     

       172
       172
       -
             ++ (if cfg.enableNepomuk then

     

       173
       173
       -
               [ pkgs.shared_desktop_ontologies # used by nepomuk

     

       174
       174
       -
                 pkgs.strigi # used by nepomuk

     

       175
       175
       -
                 pkgs.virtuoso # to enable Nepomuk to find Virtuoso

     

       176
       176
       -
               ] else

     

       177
       177
       -
               [ disableNepomuk ])

     

       178
       178
       -
             ++ optional config.hardware.pulseaudio.enable pkgs.kde4.kmix  # Perhaps this should always be enabled

     

       179
       179
       -
             ++ optional config.hardware.bluetooth.enable pkgs.kde4.bluedevil

     

       180
       180
       -
             ++ optional config.networking.networkmanager.enable pkgs.kde4.plasma-nm

     

       181
       181
       -
             ++ phononBackendPackages;

     

       182
       182
       -
       

     

       183
       183
       -
           environment.pathsToLink = [ "/share" ];

     

       184
       184
       -
       

     

       185
       185
       -
           environment.profileRelativeEnvVars = mkIf (elem "gstreamer" cfg.phononBackends) {

     

       186
       186
       -
             GST_PLUGIN_SYSTEM_PATH = [ "/lib/gstreamer-0.10" ];

     

       187
       187
       -
           };

     

       188
       188
       -
       

     

       189
       189
       -
           environment.etc = singleton

     

       190
       190
       -
             { source = "${pkgs.xkeyboard_config}/etc/X11/xkb";

     

       191
       191
       -
               target = "X11/xkb";

     

       192
       192
       -
             };

     

       193
       193
       -
       

     

       194
       194
       -
           # Enable helpful DBus services.

     

       195
       195
       -
           services.udisks2.enable = true;

     

       196
       196
       -
           services.upower.enable = config.powerManagement.enable;

     

       197
       197
       -
       

     

       198
       198
       -
           security.pam.services.kde = { allowNullPassword = true; };

     

       199
       199
       -
       

     

       200
       200
       -
         };

     

       201
       201
       -
       

     

       202
       202
       -
       }

-4

nixos/modules/services/x11/desktop-managers/kde5.nix

···

       50
       50
        
           })

     

       51
       51
        
       

     

       52
       52
        
           (mkIf (xcfg.enable && cfg.enable) {

     

       53
       53
       -
       

     

       54
       54
       -
             warnings = optional config.services.xserver.desktopManager.kde4.enable

     

       55
       55
       -
               "KDE 4 should not be enabled at the same time as KDE 5";

     

       56
       56
       -
       

     

       57
       53
        
             services.xserver.desktopManager.session = singleton {

     

       58
       54
        
               name = "kde5";

     

       59
       55
        
               bgSupport = true;

-3

nixos/modules/services/x11/display-managers/default.nix

···

       55
       55
        
               fi

     

       56
       56
        
             ''}

     

       57
       57
        
       

     

       58
       58
       -
             # Handle being called by kdm.

     

       59
       59
       -
             if test "''${1:0:1}" = /; then eval exec "$1"; fi

     

       60
       60
       -
       

     

       61
       58
        
             # Start PulseAudio if enabled.

     

       62
       59
        
             ${optionalString (config.hardware.pulseaudio.enable) ''

     

       63
       60
        
               ${optionalString (!config.hardware.pulseaudio.systemWide)

-161

nixos/modules/services/x11/display-managers/kdm.nix

···

       1
       1
       -
       { config, lib, pkgs, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
       

     

       7
       7
       -
         dmcfg = config.services.xserver.displayManager;

     

       8
       8
       -
         cfg = dmcfg.kdm;

     

       9
       9
       -
       

     

       10
       10
       -
         inherit (pkgs.kde4) kdebase_workspace;

     

       11
       11
       -
       

     

       12
       12
       -
         defaultConfig =

     

       13
       13
       -
           ''

     

       14
       14
       -
             [Shutdown]

     

       15
       15
       -
             HaltCmd=${config.systemd.package}/sbin/shutdown -h now

     

       16
       16
       -
             RebootCmd=${config.systemd.package}/sbin/shutdown -r now

     

       17
       17
       -
             ${optionalString (config.system.boot.loader.id == "grub") ''

     

       18
       18
       -
               BootManager=${if config.boot.loader.grub.version == 2 then "Grub2" else "Grub"}

     

       19
       19
       -
             ''}

     

       20
       20
       -
       

     

       21
       21
       -
             [X-*-Core]

     

       22
       22
       -
             Xrdb=${pkgs.xorg.xrdb}/bin/xrdb

     

       23
       23
       -
             SessionsDirs=${dmcfg.session.desktops}

     

       24
       24
       -
             Session=${dmcfg.session.script}

     

       25
       25
       -
             FailsafeClient=${pkgs.xterm}/bin/xterm

     

       26
       26
       -
       

     

       27
       27
       -
             [X-:*-Core]

     

       28
       28
       -
             ServerCmd=${dmcfg.xserverBin} ${toString dmcfg.xserverArgs}

     

       29
       29
       -
             # KDM calls `rm' somewhere to clean up some temporary directory.

     

       30
       30
       -
             SystemPath=${pkgs.coreutils}/bin

     

       31
       31
       -
             # The default timeout (15) is too short in a heavily loaded boot process.

     

       32
       32
       -
             ServerTimeout=60

     

       33
       33
       -
             # Needed to prevent the X server from dying on logout and not coming back:

     

       34
       34
       -
             TerminateServer=true

     

       35
       35
       -
             ${optionalString (cfg.setupScript != "")

     

       36
       36
       -
             ''

     

       37
       37
       -
               Setup=${cfg.setupScript}

     

       38
       38
       -
             ''}

     

       39
       39
       -
       

     

       40
       40
       -
             [X-*-Greeter]

     

       41
       41
       -
             HiddenUsers=root,${concatStringsSep "," dmcfg.hiddenUsers}

     

       42
       42
       -
             PluginsLogin=${kdebase_workspace}/lib/kde4/kgreet_classic.so

     

       43
       43
       -
             ${optionalString (cfg.themeDirectory != null)

     

       44
       44
       -
             ''

     

       45
       45
       -
               UseTheme=true

     

       46
       46
       -
               Theme=${cfg.themeDirectory}

     

       47
       47
       -
             ''

     

       48
       48
       -
             }

     

       49
       49
       -
       

     

       50
       50
       -
             ${optionalString (cfg.enableXDMCP)

     

       51
       51
       -
             ''

     

       52
       52
       -
               [Xdmcp]

     

       53
       53
       -
               Enable=true

     

       54
       54
       -
             ''}

     

       55
       55
       -
           '';

     

       56
       56
       -
       

     

       57
       57
       -
         kdmrc = pkgs.runCommand "kdmrc"

     

       58
       58
       -
           { config = defaultConfig + cfg.extraConfig;

     

       59
       59
       -
             preferLocalBuild = true;

     

       60
       60
       -
           }

     

       61
       61
       -
           ''

     

       62
       62
       -
             echo "$config" > $out

     

       63
       63
       -
       

     

       64
       64
       -
             # The default kdmrc would add "-nolisten tcp", and we already

     

       65
       65
       -
             # have that managed by nixos. Hence the grep.

     

       66
       66
       -
             cat ${kdebase_workspace}/share/config/kdm/kdmrc | grep -v nolisten >> $out

     

       67
       67
       -
           '';

     

       68
       68
       -
       

     

       69
       69
       -
       in

     

       70
       70
       -
       

     

       71
       71
       -
       {

     

       72
       72
       -
       

     

       73
       73
       -
         ###### interface

     

       74
       74
       -
       

     

       75
       75
       -
         options = {

     

       76
       76
       -
       

     

       77
       77
       -
           services.xserver.displayManager.kdm = {

     

       78
       78
       -
       

     

       79
       79
       -
             enable = mkOption {

     

       80
       80
       -
               type = types.bool;

     

       81
       81
       -
               default = false;

     

       82
       82
       -
               description = ''

     

       83
       83
       -
                 Whether to enable the KDE display manager.

     

       84
       84
       -
               '';

     

       85
       85
       -
             };

     

       86
       86
       -
       

     

       87
       87
       -
             enableXDMCP = mkOption {

     

       88
       88
       -
               type = types.bool;

     

       89
       89
       -
               default = false;

     

       90
       90
       -
               description = ''

     

       91
       91
       -
                 Whether to enable XDMCP, which allows remote logins.

     

       92
       92
       -
               '';

     

       93
       93
       -
             };

     

       94
       94
       -
       

     

       95
       95
       -
             themeDirectory = mkOption {

     

       96
       96
       -
               type = types.nullOr types.str;

     

       97
       97
       -
               default = null;

     

       98
       98
       -
               description = ''

     

       99
       99
       -
                 The path to a KDM theme directory. This theme

     

       100
       100
       -
                 will be used by the KDM greeter.

     

       101
       101
       -
               '';

     

       102
       102
       -
             };

     

       103
       103
       -
       

     

       104
       104
       -
             setupScript = mkOption {

     

       105
       105
       -
               type = types.lines;

     

       106
       106
       -
               default = "";

     

       107
       107
       -
               description = ''

     

       108
       108
       -
                 The path to a KDM setup script. This script is run as root just

     

       109
       109
       -
                 before KDM starts. Can be used for setting up

     

       110
       110
       -
                 monitors with xrandr, for example.

     

       111
       111
       -
               '';

     

       112
       112
       -
             };

     

       113
       113
       -
       

     

       114
       114
       -
             extraConfig = mkOption {

     

       115
       115
       -
               type = types.lines;

     

       116
       116
       -
               default = "";

     

       117
       117
       -
               description = ''

     

       118
       118
       -
                 Options appended to <filename>kdmrc</filename>, the

     

       119
       119
       -
                 configuration file of KDM.

     

       120
       120
       -
               '';

     

       121
       121
       -
             };

     

       122
       122
       -
       

     

       123
       123
       -
           };

     

       124
       124
       -
       

     

       125
       125
       -
         };

     

       126
       126
       -
       

     

       127
       127
       -
       

     

       128
       128
       -
         ###### implementation

     

       129
       129
       -
       

     

       130
       130
       -
         config = mkIf cfg.enable {

     

       131
       131
       -
           warnings = [

     

       132
       132
       -
             "KDM is long unmaintained and will be removed. Please update to SDDM."

     

       133
       133
       -
           ];

     

       134
       134
       -
       

     

       135
       135
       -
           services.xserver.displayManager.slim.enable = false;

     

       136
       136
       -
       

     

       137
       137
       -
           services.xserver.displayManager.job =

     

       138
       138
       -
             { execCmd =

     

       139
       139
       -
                 ''

     

       140
       140
       -
                   mkdir -m 0755 -p /var/lib/kdm

     

       141
       141
       -
                   chown kdm /var/lib/kdm

     

       142
       142
       -
                   ${(optionalString (config.system.boot.loader.id == "grub" && config.system.build.grub != null) "PATH=${config.system.build.grub}/sbin:$PATH ") +

     

       143
       143
       -
                     "KDEDIRS=/run/current-system/sw exec ${kdebase_workspace}/bin/kdm -config ${kdmrc} -nodaemon -logfile /dev/stderr"}

     

       144
       144
       -
                 '';

     

       145
       145
       -
               logsXsession = true;

     

       146
       146
       -
             };

     

       147
       147
       -
       

     

       148
       148
       -
           security.pam.services.kde = { allowNullPassword = true; startSession = true; };

     

       149
       149
       -
       

     

       150
       150
       -
           users.extraUsers = singleton

     

       151
       151
       -
             { name = "kdm";

     

       152
       152
       -
               uid = config.ids.uids.kdm;

     

       153
       153
       -
               description = "KDM user";

     

       154
       154
       -
             };

     

       155
       155
       -
       

     

       156
       156
       -
           environment.systemPackages =

     

       157
       157
       -
             [ pkgs.kde4.kde_wallpapers ]; # contains kdm's default background

     

       158
       158
       -
       

     

       159
       159
       -
         };

     

       160
       160
       -
       

     

       161
       161
       -
       }

-2

nixos/modules/system/boot/loader/grub/install-grub.pl

···

       256
       256
        
               # ‘grub-reboot’ sets a one-time saved entry, which we process here and

     

       257
       257
        
               # then delete.

     

       258
       258
        
               if [ \"\${next_entry}\" ]; then

     

       259
       259
       -
                 # FIXME: KDM expects the next line to be present.

     

       260
       260
       -
                 set default=\"\${saved_entry}\"

     

       261
       259
        
                 set default=\"\${next_entry}\"

     

       262
       260
        
                 set next_entry=

     

       263
       261
        
                 save_env next_entry

-9

nixos/modules/testing/test-instrumentation.nix

···

       123
       123
        
           users.extraUsers.root.initialHashedPassword = mkOverride 150 "";

     

       124
       124
        
       

     

       125
       125
        
           services.xserver.displayManager.logToJournal = true;

     

       126
       126
       -
       

     

       127
       127
       -
           # Bump kdm's X server start timeout to account for heavily loaded

     

       128
       128
       -
           # VM host systems.

     

       129
       129
       -
           services.xserver.displayManager.kdm.extraConfig =

     

       130
       130
       -
             ''

     

       131
       131
       -
               [X-:*-Core]

     

       132
       132
       -
               ServerTimeout=240

     

       133
       133
       -
             '';

     

       134
       134
       -
       

     

       135
       126
        
         };

     

       136
       127
        
       

     

       137
       128
        
       }

-1

nixos/release-combined.nix

···

       72
       72
        
               (all nixos.tests.ecryptfs)

     

       73
       73
        
               (all nixos.tests.ipv6)

     

       74
       74
        
               (all nixos.tests.i3wm)

     

       75
       75
       -
               (all nixos.tests.kde4)

     

       76
       75
        
               (all nixos.tests.kde5)

     

       77
       76
        
               #(all nixos.tests.lightdm)

     

       78
       77
        
               (all nixos.tests.login)

-1

nixos/release.nix

···

       255
       255
        
         tests.influxdb = callTest tests/influxdb.nix {};

     

       256
       256
        
         tests.ipv6 = callTest tests/ipv6.nix {};

     

       257
       257
        
         tests.jenkins = callTest tests/jenkins.nix {};

     

       258
       258
       -
         tests.kde4 = callTest tests/kde4.nix {};

     

       259
       258
        
         tests.kde5 = callTest tests/kde5.nix {};

     

       260
       259
        
         tests.keymap = callSubTests tests/keymap.nix {};

     

       261
       260
        
         tests.initrdNetwork = callTest tests/initrd-network.nix {};

-70

nixos/tests/kde4.nix

···

       1
       1
       -
       import ./make-test.nix ({ pkgs, ... }: {

     

       2
       2
       -
         name = "kde4";

     

       3
       3
       -
         meta = with pkgs.stdenv.lib.maintainers; {

     

       4
       4
       -
           maintainers = [ domenkozar eelco chaoflow ];

     

       5
       5
       -
         };

     

       6
       6
       -
       

     

       7
       7
       -
         machine =

     

       8
       8
       -
           { config, pkgs, ... }:

     

       9
       9
       -
       

     

       10
       10
       -
           { imports = [ ./common/user-account.nix ];

     

       11
       11
       -
       

     

       12
       12
       -
             virtualisation.memorySize = 1024;

     

       13
       13
       -
       

     

       14
       14
       -
             services.xserver.enable = true;

     

       15
       15
       -
       

     

       16
       16
       -
             services.httpd.enable = true;

     

       17
       17
       -
             services.httpd.adminAddr = "foo@example.org";

     

       18
       18
       -
             services.httpd.documentRoot = "${pkgs.valgrind.doc}/share/doc/valgrind/html";

     

       19
       19
       -
       

     

       20
       20
       -
             services.xserver.displayManager.kdm.enable = true;

     

       21
       21
       -
             services.xserver.displayManager.kdm.extraConfig =

     

       22
       22
       -
               ''

     

       23
       23
       -
                 [X-:0-Core]

     

       24
       24
       -
                 AutoLoginEnable=true

     

       25
       25
       -
                 AutoLoginUser=alice

     

       26
       26
       -
                 AutoLoginPass=foobar

     

       27
       27
       -
               '';

     

       28
       28
       -
       

     

       29
       29
       -
             services.xserver.desktopManager.kde4.enable = true;

     

       30
       30
       -
       

     

       31
       31
       -
             # Include most of KDE. We don't really test these here, but at

     

       32
       32
       -
             # least they should build.

     

       33
       33
       -
             environment.systemPackages =

     

       34
       34
       -
               [ pkgs.kde4.kdemultimedia

     

       35
       35
       -
                 pkgs.kde4.kdegraphics

     

       36
       36
       -
                 pkgs.kde4.kdeutils

     

       37
       37
       -
                 pkgs.kde4.kdegames

     

       38
       38
       -
                 #pkgs.kde4.kdeedu

     

       39
       39
       -
                 pkgs.kde4.kdeaccessibility

     

       40
       40
       -
                 pkgs.kde4.kdeadmin

     

       41
       41
       -
                 pkgs.kde4.kdenetwork

     

       42
       42
       -
                 pkgs.kde4.kdetoys

     

       43
       43
       -
                 pkgs.kde4.kdewebdev

     

       44
       44
       -
                 pkgs.xorg.xmessage

     

       45
       45
       -
               ];

     

       46
       46
       -
           };

     

       47
       47
       -
       

     

       48
       48
       -
         testScript = ''

     

       49
       49
       -
             $machine->waitUntilSucceeds("pgrep plasma-desktop");

     

       50
       50
       -
             $machine->succeed("xauth merge ~alice/.Xauthority");

     

       51
       51
       -
             $machine->waitForWindow(qr/plasma-desktop/);

     

       52
       52
       -
       

     

       53
       53
       -
             # Check that logging in has given the user ownership of devices.

     

       54
       54
       -
             $machine->succeed("getfacl /dev/snd/timer | grep -q alice");

     

       55
       55
       -
       

     

       56
       56
       -
             $machine->execute("su - alice -c 'DISPLAY=:0.0 kwrite /var/log/messages &'");

     

       57
       57
       -
             $machine->waitForWindow(qr/messages.*KWrite/);

     

       58
       58
       -
       

     

       59
       59
       -
             $machine->execute("su - alice -c 'DISPLAY=:0.0 konqueror http://localhost/ &'");

     

       60
       60
       -
             $machine->waitForWindow(qr/Valgrind.*Konqueror/);

     

       61
       61
       -
       

     

       62
       62
       -
             $machine->execute("su - alice -c 'DISPLAY=:0.0 gwenview ${pkgs.kde4.kde_wallpapers}/share/wallpapers/Hanami/contents/images/1280x1024.jpg &'");

     

       63
       63
       -
             $machine->waitForWindow(qr/Gwenview/);

     

       64
       64
       -
       

     

       65
       65
       -
             $machine->sleep(10);

     

       66
       66
       -
       

     

       67
       67
       -
             $machine->screenshot("screen");

     

       68
       68
       -
           '';

     

       69
       69
       -
       

     

       70
       70
       -
       })