commit 4cc6ce454d3049ded63959b0c80f4c50dc6f89cc · pyrox.dev/nixpkgs

+1 -1

nixos/doc/manual/configuration/modularity.section.md

···

       27
       27
        
       { config, pkgs, ... }:

     

       28
       28
        
       

     

       29
       29
        
       { services.xserver.enable = true;

     

       30
       30
       -
         services.xserver.displayManager.sddm.enable = true;

     

       30
       30
       +
         services.displayManager.sddm.enable = true;

     

       31
       31
        
         services.xserver.desktopManager.plasma5.enable = true;

     

       32
       32
        
         environment.systemPackages = [ pkgs.vim ];

     

       33
       33
        
       }

+1 -1

nixos/doc/manual/configuration/profiles/demo.section.md

···

       1
       1
        
       # Demo {#sec-profile-demo}

     

       2
       2
        
       

     

       3
       3
        
       This profile just enables a `demo` user, with password `demo`, uid `1000`, `wheel` group and

     

       4
       4
       -
       [autologin in the SDDM display manager](#opt-services.xserver.displayManager.autoLogin).

     

       4
       4
       +
       [autologin in the SDDM display manager](#opt-services.displayManager.autoLogin).

+1 -1

nixos/doc/manual/configuration/profiles/graphical.section.md

···

       4
       4
        
       graphical installation CD.

     

       5
       5
        
       

     

       6
       6
        
       It sets [](#opt-services.xserver.enable),

     

       7
       7
       -
       [](#opt-services.xserver.displayManager.sddm.enable),

     

       7
       7
       +
       [](#opt-services.displayManager.sddm.enable),

     

       8
       8
        
       [](#opt-services.xserver.desktopManager.plasma5.enable),

     

       9
       9
        
       and [](#opt-services.xserver.libinput.enable) to true. It also

     

       10
       10
        
       includes glxinfo and firefox in the system packages list.

+4 -4

nixos/doc/manual/configuration/x-windows.chapter.md

···

       45
       45
        
       

     

       46
       46
        
       ```nix

     

       47
       47
        
       {

     

       48
       48
       -
         services.xserver.displayManager.sddm.enable = true;

     

       48
       48
       +
         services.displayManager.sddm.enable = true;

     

       49
       49
        
         services.xserver.displayManager.gdm.enable = true;

     

       50
       50
        
       }

     

       51
       51
        
       ```

     
···

       99
       99
        
       

     

       100
       100
        
       ```nix

     

       101
       101
        
       {

     

       102
       102
       -
         services.xserver.displayManager.defaultSession = "none+i3";

     

       102
       102
       +
         services.displayManager.defaultSession = "none+i3";

     

       103
       103
        
       }

     

       104
       104
        
       ```

     

       105
       105
        
       

     
···

       109
       109
        
       ```nix

     

       110
       110
        
       {

     

       111
       111
        
         services.xserver.displayManager.lightdm.enable = true;

     

       112
       112
       -
         services.xserver.displayManager.autoLogin.enable = true;

     

       113
       113
       -
         services.xserver.displayManager.autoLogin.user = "alice";

     

       112
       112
       +
         services.displayManager.autoLogin.enable = true;

     

       113
       113
       +
         services.displayManager.autoLogin.user = "alice";

     

       114
       114
        
       }

     

       115
       115
        
       ```

     

       116
       116

+1 -1

nixos/doc/manual/configuration/xfce.chapter.md

···

       5
       5
        
       ```nix

     

       6
       6
        
       {

     

       7
       7
        
         services.xserver.desktopManager.xfce.enable = true;

     

       8
       8
       -
         services.xserver.displayManager.defaultSession = "xfce";

     

       8
       8
       +
         services.displayManager.defaultSession = "xfce";

     

       9
       9
        
       }

     

       10
       10
        
       ```

     

       11
       11

+14 -15

nixos/modules/installer/cd-dvd/installation-cd-graphical-calamares-gnome.nix

···

       35
       35
        
           QT_QPA_PLATFORM = "$([[ $XDG_SESSION_TYPE = \"wayland\" ]] && echo \"wayland\")";

     

       36
       36
        
         };

     

       37
       37
        
       

     

       38
       38
       -
         services.xserver.displayManager = {

     

       39
       39
       -
           gdm = {

     

       40
       40
       -
             enable = true;

     

       41
       41
       -
             # autoSuspend makes the machine automatically suspend after inactivity.

     

       42
       42
       -
             # It's possible someone could/try to ssh'd into the machine and obviously

     

       43
       43
       -
             # have issues because it's inactive.

     

       44
       44
       -
             # See:

     

       45
       45
       -
             # * https://github.com/NixOS/nixpkgs/pull/63790

     

       46
       46
       -
             # * https://gitlab.gnome.org/GNOME/gnome-control-center/issues/22

     

       47
       47
       -
             autoSuspend = false;

     

       48
       48
       -
           };

     

       49
       49
       -
           autoLogin = {

     

       50
       50
       -
             enable = true;

     

       51
       51
       -
             user = "nixos";

     

       52
       52
       -
           };

     

       38
       38
       +
         services.xserver.displayManager.gdm = {

     

       39
       39
       +
           enable = true;

     

       40
       40
       +
           # autoSuspend makes the machine automatically suspend after inactivity.

     

       41
       41
       +
           # It's possible someone could/try to ssh'd into the machine and obviously

     

       42
       42
       +
           # have issues because it's inactive.

     

       43
       43
       +
           # See:

     

       44
       44
       +
           # * https://github.com/NixOS/nixpkgs/pull/63790

     

       45
       45
       +
           # * https://gitlab.gnome.org/GNOME/gnome-control-center/issues/22

     

       46
       46
       +
           autoSuspend = false;

     

       47
       47
       +
         };

     

       48
       48
       +
       

     

       49
       49
       +
         services.displayManager.autoLogin = {

     

       50
       50
       +
           enable = true;

     

       51
       51
       +
           user = "nixos";

     

       53
       52
        
         };

     

       54
       53
        
       }

+9 -11

nixos/modules/installer/cd-dvd/installation-cd-graphical-calamares-plasma5.nix

···

       8
       8
        
       

     

       9
       9
        
         isoImage.edition = "plasma5";

     

       10
       10
        
       

     

       11
       11
       -
         services.xserver = {

     

       12
       12
       -
           desktopManager.plasma5 = {

     

       13
       13
       -
             enable = true;

     

       14
       14
       -
           };

     

       11
       11
       +
         services.xserver.desktopManager.plasma5 = {

     

       12
       12
       +
           enable = true;

     

       13
       13
       +
         };

     

       15
       14
        
       

     

       16
       16
       -
           # Automatically login as nixos.

     

       17
       17
       -
           displayManager = {

     

       18
       18
       -
             sddm.enable = true;

     

       19
       19
       -
             autoLogin = {

     

       20
       20
       -
               enable = true;

     

       21
       21
       -
               user = "nixos";

     

       22
       22
       -
             };

     

       15
       15
       +
         # Automatically login as nixos.

     

       16
       16
       +
         services.displayManager = {

     

       17
       17
       +
           sddm.enable = true;

     

       18
       18
       +
           autoLogin = {

     

       19
       19
       +
             enable = true;

     

       20
       20
       +
             user = "nixos";

     

       23
       21
        
           };

     

       24
       22
        
         };

     

       25
       23

+7 -9

nixos/modules/installer/cd-dvd/installation-cd-graphical-calamares-plasma6.nix

···

       7
       7
        
       

     

       8
       8
        
         isoImage.edition = "plasma6";

     

       9
       9
        
       

     

       10
       10
       -
         services.xserver = {

     

       11
       11
       -
           desktopManager.plasma6.enable = true;

     

       10
       10
       +
         services.desktopManager.plasma6.enable = true;

     

       12
       11
        
       

     

       13
       13
       -
           # Automatically login as nixos.

     

       14
       14
       -
           displayManager = {

     

       15
       15
       -
             sddm.enable = true;

     

       16
       16
       -
             autoLogin = {

     

       17
       17
       -
               enable = true;

     

       18
       18
       -
               user = "nixos";

     

       19
       19
       -
             };

     

       12
       12
       +
         # Automatically login as nixos.

     

       13
       13
       +
         services.displayManager = {

     

       14
       14
       +
           sddm.enable = true;

     

       15
       15
       +
           autoLogin = {

     

       16
       16
       +
             enable = true;

     

       17
       17
       +
             user = "nixos";

     

       20
       18
        
           };

     

       21
       19
        
         };

     

       22
       20

+13 -15

nixos/modules/installer/cd-dvd/installation-cd-graphical-gnome.nix

···

       16
       16
        
           enable = true;

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         services.xserver.displayManager = {

     

       20
       20
       -
           gdm = {

     

       21
       21
       -
             enable = true;

     

       22
       22
       -
             # autoSuspend makes the machine automatically suspend after inactivity.

     

       23
       23
       -
             # It's possible someone could/try to ssh'd into the machine and obviously

     

       24
       24
       -
             # have issues because it's inactive.

     

       25
       25
       -
             # See:

     

       26
       26
       -
             # * https://github.com/NixOS/nixpkgs/pull/63790

     

       27
       27
       -
             # * https://gitlab.gnome.org/GNOME/gnome-control-center/issues/22

     

       28
       28
       -
             autoSuspend = false;

     

       29
       29
       -
           };

     

       30
       30
       -
           autoLogin = {

     

       31
       31
       -
             enable = true;

     

       32
       32
       -
             user = "nixos";

     

       33
       33
       -
           };

     

       19
       19
       +
         services.xserver.displayManager.gdm = {

     

       20
       20
       +
           enable = true;

     

       21
       21
       +
           # autoSuspend makes the machine automatically suspend after inactivity.

     

       22
       22
       +
           # It's possible someone could/try to ssh'd into the machine and obviously

     

       23
       23
       +
           # have issues because it's inactive.

     

       24
       24
       +
           # See:

     

       25
       25
       +
           # * https://github.com/NixOS/nixpkgs/pull/63790

     

       26
       26
       +
           # * https://gitlab.gnome.org/GNOME/gnome-control-center/issues/22

     

       27
       27
       +
           autoSuspend = false;

     

       34
       28
        
         };

     

       35
       29
        
       

     

       30
       30
       +
         services.displayManager.autoLogin = {

     

       31
       31
       +
           enable = true;

     

       32
       32
       +
           user = "nixos";

     

       33
       33
       +
         };

     

       36
       34
        
       }

+9 -11

nixos/modules/installer/cd-dvd/installation-cd-graphical-plasma5.nix

···

       8
       8
        
       

     

       9
       9
        
         isoImage.edition = "plasma5";

     

       10
       10
        
       

     

       11
       11
       -
         services.xserver = {

     

       12
       12
       -
           desktopManager.plasma5 = {

     

       13
       13
       -
             enable = true;

     

       14
       14
       -
           };

     

       11
       11
       +
         services.xserver.desktopManager.plasma5 = {

     

       12
       12
       +
           enable = true;

     

       13
       13
       +
         };

     

       15
       14
        
       

     

       16
       16
       -
           # Automatically login as nixos.

     

       17
       17
       -
           displayManager = {

     

       18
       18
       -
             sddm.enable = true;

     

       19
       19
       -
             autoLogin = {

     

       20
       20
       -
               enable = true;

     

       21
       21
       -
               user = "nixos";

     

       22
       22
       -
             };

     

       15
       15
       +
         # Automatically login as nixos.

     

       16
       16
       +
         services.displayManager = {

     

       17
       17
       +
           sddm.enable = true;

     

       18
       18
       +
           autoLogin = {

     

       19
       19
       +
             enable = true;

     

       20
       20
       +
             user = "nixos";

     

       23
       21
        
           };

     

       24
       22
        
         };

     

       25
       23

+1 -1

nixos/modules/installer/virtualbox-demo.nix

···

       40
       40
        
         # If you prefer another desktop manager or display manager, you may want

     

       41
       41
        
         # to disable the default.

     

       42
       42
        
         # services.xserver.desktopManager.plasma5.enable = lib.mkForce false;

     

       43
       43
       -
         # services.xserver.displayManager.sddm.enable = lib.mkForce false;

     

       43
       43
       +
         # services.displayManager.sddm.enable = lib.mkForce false;

     

       44
       44
        
       

     

       45
       45
        
         # Enable GDM/GNOME by uncommenting above two lines and two lines below.

     

       46
       46
        
         # services.xserver.displayManager.gdm.enable = true;

+3 -1

nixos/modules/module-list.nix

···

       508
       508
        
         ./services/development/nixseparatedebuginfod.nix

     

       509
       509
        
         ./services/development/rstudio-server/default.nix

     

       510
       510
        
         ./services/development/zammad.nix

     

       511
       511
       +
         ./services/display-managers/default.nix

     

       511
       512
        
         ./services/display-managers/greetd.nix

     

       513
       513
       +
         ./services/display-managers/sddm.nix

     

       512
       514
        
         ./services/editors/emacs.nix

     

       513
       515
        
         ./services/editors/haste.nix

     

       514
       516
        
         ./services/editors/infinoted.nix

     
···

       708
       710
        
         ./services/misc/gogs.nix

     

       709
       711
        
         ./services/misc/gollum.nix

     

       710
       712
        
         ./services/misc/gpsd.nix

     

       713
       713
       +
         ./services/misc/graphical-desktop.nix

     

       711
       714
        
         ./services/misc/greenclip.nix

     

       712
       715
        
         ./services/misc/guix

     

       713
       716
        
         ./services/misc/headphones.nix

     
···

       1444
       1447
        
         ./services/x11/display-managers/default.nix

     

       1445
       1448
        
         ./services/x11/display-managers/gdm.nix

     

       1446
       1449
        
         ./services/x11/display-managers/lightdm.nix

     

       1447
       1447
       -
         ./services/x11/display-managers/sddm.nix

     

       1448
       1450
        
         ./services/x11/display-managers/slim.nix

     

       1449
       1451
        
         ./services/x11/display-managers/startx.nix

     

       1450
       1452
        
         ./services/x11/display-managers/sx.nix

+1 -1

nixos/modules/programs/miriway.nix

···

       71
       71
        
           programs.xwayland.enable = lib.mkDefault true;

     

       72
       72
        
       

     

       73
       73
        
           # To make the Miriway session available if a display manager like SDDM is enabled:

     

       74
       74
       -
           services.xserver.displayManager.sessionPackages = [ pkgs.miriway ];

     

       74
       74
       +
           services.displayManager.sessionPackages = [ pkgs.miriway ];

     

       75
       75
        
         };

     

       76
       76
        
       

     

       77
       77
        
         meta.maintainers = with lib.maintainers; [ OPNA2608 ];

+1 -1

nixos/modules/programs/steam.nix

···

       161
       161
        
           };

     

       162
       162
        
       

     

       163
       163
        
           programs.gamescope.enable = mkDefault cfg.gamescopeSession.enable;

     

       164
       164
       -
           services.xserver.displayManager.sessionPackages = mkIf cfg.gamescopeSession.enable [ gamescopeSessionFile ];

     

       164
       164
       +
           services.displayManager.sessionPackages = mkIf cfg.gamescopeSession.enable [ gamescopeSessionFile ];

     

       165
       165
        
       

     

       166
       166
        
           # optionally enable 32bit pulseaudio support if pulseaudio is enabled

     

       167
       167
        
           hardware.pulseaudio.support32Bit = config.hardware.pulseaudio.enable;

+1 -1

nixos/modules/programs/wayland/cardboard.nix

···

       17
       17
        
             environment.systemPackages = [ cfg.package ];

     

       18
       18
        
       

     

       19
       19
        
             # To make a cardboard session available for certain DMs like SDDM

     

       20
       20
       -
             services.xserver.displayManager.sessionPackages = [ cfg.package ];

     

       20
       20
       +
             services.displayManager.sessionPackages = [ cfg.package ];

     

       21
       21
        
           }

     

       22
       22
        
           (import ./wayland-session.nix { inherit lib pkgs; })

     

       23
       23
        
         ]);

+1 -1

nixos/modules/programs/wayland/hyprland.nix

···

       66
       66
        
       

     

       67
       67
        
           security.polkit.enable = true;

     

       68
       68
        
       

     

       69
       69
       -
           services.xserver.displayManager.sessionPackages = [ cfg.finalPackage ];

     

       69
       69
       +
           services.displayManager.sessionPackages = [ cfg.finalPackage ];

     

       70
       70
        
       

     

       71
       71
        
           xdg.portal = {

     

       72
       72
        
             enable = mkDefault true;

+1 -1

nixos/modules/programs/wayland/labwc.nix

···

       18
       18
        
             xdg.portal.config.wlroots.default = lib.mkDefault [ "wlr" "gtk" ];

     

       19
       19
        
       

     

       20
       20
        
             # To make a labwc session available for certain DMs like SDDM

     

       21
       21
       -
             services.xserver.displayManager.sessionPackages = [ cfg.package ];

     

       21
       21
       +
             services.displayManager.sessionPackages = [ cfg.package ];

     

       22
       22
        
           }

     

       23
       23
        
           (import ./wayland-session.nix { inherit lib pkgs; })

     

       24
       24
        
         ]);

+1 -1

nixos/modules/programs/wayland/river.nix

···

       47
       47
        
               environment.systemPackages = optional (cfg.package != null) cfg.package ++ cfg.extraPackages;

     

       48
       48
        
       

     

       49
       49
        
               # To make a river session available if a display manager like SDDM is enabled:

     

       50
       50
       -
               services.xserver.displayManager.sessionPackages = optionals (cfg.package != null) [ cfg.package ];

     

       50
       50
       +
               services.displayManager.sessionPackages = optionals (cfg.package != null) [ cfg.package ];

     

       51
       51
        
       

     

       52
       52
        
               # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1050913

     

       53
       53
        
               xdg.portal.config.river.default = mkDefault [ "wlr" "gtk" ];

+1 -1

nixos/modules/programs/wayland/sway.nix

···

       174
       174
        
               xdg.portal.config.sway.default = mkDefault [ "wlr" "gtk" ];

     

       175
       175
        
       

     

       176
       176
        
               # To make a Sway session available if a display manager like SDDM is enabled:

     

       177
       177
       -
               services.xserver.displayManager.sessionPackages = optionals (cfg.package != null) [ cfg.package ]; }

     

       177
       177
       +
               services.displayManager.sessionPackages = optionals (cfg.package != null) [ cfg.package ]; }

     

       178
       178
        
             (import ./wayland-session.nix { inherit lib pkgs; })

     

       179
       179
        
           ]);

     

       180
       180

+1 -1

nixos/modules/programs/wayland/wayfire.nix

···

       38
       38
        
             finalPackage

     

       39
       39
        
           ];

     

       40
       40
        
       

     

       41
       41
       -
           services.xserver.displayManager.sessionPackages = [ finalPackage ];

     

       41
       41
       +
           services.displayManager.sessionPackages = [ finalPackage ];

     

       42
       42
        
       

     

       43
       43
        
           xdg.portal = {

     

       44
       44
        
             enable = lib.mkDefault true;

+1 -1

nixos/modules/rename.nix

···

       93
       93
        
             The services.xserver.displayManager.auto module has been removed

     

       94
       94
        
             because it was only intended for use in internal NixOS tests, and gave the

     

       95
       95
        
             false impression of it being a special display manager when it's actually

     

       96
       96
       -
             LightDM. Please use the services.xserver.displayManager.autoLogin options

     

       96
       96
       +
             LightDM. Please use the services.displayManager.autoLogin options

     

       97
       97
        
             instead, or any other display manager in NixOS as they all support auto-login.

     

       98
       98
        
           '')

     

       99
       99
        
           (mkRemovedOptionModule [ "services" "xserver" "multitouch" ] ''

+2 -2

nixos/modules/services/desktop-managers/plasma6.nix

···

       246
       246
        
           xdg.portal.configPackages = mkDefault [kdePackages.xdg-desktop-portal-kde];

     

       247
       247
        
           services.pipewire.enable = mkDefault true;

     

       248
       248
        
       

     

       249
       249
       -
           services.xserver.displayManager = {

     

       249
       249
       +
           services.displayManager = {

     

       250
       250
        
             sessionPackages = [kdePackages.plasma-workspace];

     

       251
       251
        
             defaultSession = mkDefault "plasma";

     

       252
       252
        
           };

     

       253
       253
       -
           services.xserver.displayManager.sddm = {

     

       253
       253
       +
           services.displayManager.sddm = {

     

       254
       254
        
             package = kdePackages.sddm;

     

       255
       255
        
             theme = mkDefault "breeze";

     

       256
       256
        
             wayland.compositor = "kwin";

+257

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

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         cfg = config.services.displayManager;

     

       5
       5
       +
       

     

       6
       6
       +
         installedSessions = pkgs.runCommand "desktops"

     

       7
       7
       +
           { # trivial derivation

     

       8
       8
       +
             preferLocalBuild = true;

     

       9
       9
       +
             allowSubstitutes = false;

     

       10
       10
       +
           }

     

       11
       11
       +
           ''

     

       12
       12
       +
             mkdir -p "$out/share/"{xsessions,wayland-sessions}

     

       13
       13
       +
       

     

       14
       14
       +
             ${lib.concatMapStrings (pkg: ''

     

       15
       15
       +
               for n in ${lib.concatStringsSep " " pkg.providedSessions}; do

     

       16
       16
       +
                 if ! test -f ${pkg}/share/wayland-sessions/$n.desktop -o \

     

       17
       17
       +
                           -f ${pkg}/share/xsessions/$n.desktop; then

     

       18
       18
       +
                   echo "Couldn't find provided session name, $n.desktop, in session package ${pkg.name}:"

     

       19
       19
       +
                   echo "  ${pkg}"

     

       20
       20
       +
                   return 1

     

       21
       21
       +
                 fi

     

       22
       22
       +
               done

     

       23
       23
       +
       

     

       24
       24
       +
               if test -d ${pkg}/share/xsessions; then

     

       25
       25
       +
                 ${pkgs.buildPackages.xorg.lndir}/bin/lndir ${pkg}/share/xsessions $out/share/xsessions

     

       26
       26
       +
               fi

     

       27
       27
       +
               if test -d ${pkg}/share/wayland-sessions; then

     

       28
       28
       +
                 ${pkgs.buildPackages.xorg.lndir}/bin/lndir ${pkg}/share/wayland-sessions $out/share/wayland-sessions

     

       29
       29
       +
               fi

     

       30
       30
       +
             '') cfg.sessionPackages}

     

       31
       31
       +
           '';

     

       32
       32
       +
       

     

       33
       33
       +
         dmDefault = config.services.xserver.desktopManager.default;

     

       34
       34
       +
         # fallback default for cases when only default wm is set

     

       35
       35
       +
         dmFallbackDefault = if dmDefault != null then dmDefault else "none";

     

       36
       36
       +
         wmDefault = config.services.xserver.windowManager.default;

     

       37
       37
       +
         defaultSessionFromLegacyOptions = dmFallbackDefault + lib.optionalString (wmDefault != null && wmDefault != "none") "+${wmDefault}";

     

       38
       38
       +
       in

     

       39
       39
       +
       {

     

       40
       40
       +
         options = {

     

       41
       41
       +
           services.displayManager = {

     

       42
       42
       +
             enable = lib.mkEnableOption "systemd's display-manager service";

     

       43
       43
       +
       

     

       44
       44
       +
             preStart = lib.mkOption {

     

       45
       45
       +
               type = lib.types.lines;

     

       46
       46
       +
               default = "";

     

       47
       47
       +
               example = "rm -f /var/log/my-display-manager.log";

     

       48
       48
       +
               description = lib.mdDoc "Script executed before the display manager is started.";

     

       49
       49
       +
             };

     

       50
       50
       +
       

     

       51
       51
       +
             execCmd = lib.mkOption {

     

       52
       52
       +
               type = lib.types.str;

     

       53
       53
       +
               example = lib.literalExpression ''"''${pkgs.lightdm}/bin/lightdm"'';

     

       54
       54
       +
               description = lib.mdDoc "Command to start the display manager.";

     

       55
       55
       +
             };

     

       56
       56
       +
       

     

       57
       57
       +
             environment = lib.mkOption {

     

       58
       58
       +
               type = with lib.types; attrsOf unspecified;

     

       59
       59
       +
               default = {};

     

       60
       60
       +
               description = lib.mdDoc "Additional environment variables needed by the display manager.";

     

       61
       61
       +
             };

     

       62
       62
       +
       

     

       63
       63
       +
             hiddenUsers = lib.mkOption {

     

       64
       64
       +
               type = with lib.types; listOf str;

     

       65
       65
       +
               default = [ "nobody" ];

     

       66
       66
       +
               description = lib.mdDoc ''

     

       67
       67
       +
                 A list of users which will not be shown in the display manager.

     

       68
       68
       +
               '';

     

       69
       69
       +
             };

     

       70
       70
       +
       

     

       71
       71
       +
             logToFile = lib.mkOption {

     

       72
       72
       +
               type = lib.types.bool;

     

       73
       73
       +
               default = false;

     

       74
       74
       +
               description = lib.mdDoc ''

     

       75
       75
       +
                 Whether the display manager redirects the output of the

     

       76
       76
       +
                 session script to {file}`~/.xsession-errors`.

     

       77
       77
       +
               '';

     

       78
       78
       +
             };

     

       79
       79
       +
       

     

       80
       80
       +
             logToJournal = lib.mkOption {

     

       81
       81
       +
               type = lib.types.bool;

     

       82
       82
       +
               default = true;

     

       83
       83
       +
               description = lib.mdDoc ''

     

       84
       84
       +
                 Whether the display manager redirects the output of the

     

       85
       85
       +
                 session script to the systemd journal.

     

       86
       86
       +
               '';

     

       87
       87
       +
             };

     

       88
       88
       +
       

     

       89
       89
       +
             # Configuration for automatic login. Common for all DM.

     

       90
       90
       +
             autoLogin = lib.mkOption {

     

       91
       91
       +
               type = lib.types.submodule ({ config, options, ... }: {

     

       92
       92
       +
                 options = {

     

       93
       93
       +
                   enable = lib.mkOption {

     

       94
       94
       +
                     type = lib.types.bool;

     

       95
       95
       +
                     default = config.user != null;

     

       96
       96
       +
                     defaultText = lib.literalExpression "config.${options.user} != null";

     

       97
       97
       +
                     description = lib.mdDoc ''

     

       98
       98
       +
                       Automatically log in as {option}`autoLogin.user`.

     

       99
       99
       +
                     '';

     

       100
       100
       +
                   };

     

       101
       101
       +
       

     

       102
       102
       +
                   user = lib.mkOption {

     

       103
       103
       +
                     type = with lib.types; nullOr str;

     

       104
       104
       +
                     default = null;

     

       105
       105
       +
                     description = lib.mdDoc ''

     

       106
       106
       +
                       User to be used for the automatic login.

     

       107
       107
       +
                     '';

     

       108
       108
       +
                   };

     

       109
       109
       +
                 };

     

       110
       110
       +
               });

     

       111
       111
       +
       

     

       112
       112
       +
               default = {};

     

       113
       113
       +
               description = lib.mdDoc ''

     

       114
       114
       +
                 Auto login configuration attrset.

     

       115
       115
       +
               '';

     

       116
       116
       +
             };

     

       117
       117
       +
       

     

       118
       118
       +
             defaultSession = lib.mkOption {

     

       119
       119
       +
               type = lib.types.nullOr lib.types.str // {

     

       120
       120
       +
                 description = "session name";

     

       121
       121
       +
                 check = d:

     

       122
       122
       +
                   lib.assertMsg (d != null -> (lib.types.str.check d && lib.elem d config.services.displayManager.sessionData.sessionNames)) ''

     

       123
       123
       +
                       Default graphical session, '${d}', not found.

     

       124
       124
       +
                       Valid names for 'services.displayManager.defaultSession' are:

     

       125
       125
       +
                         ${lib.concatStringsSep "\n  " cfg.displayManager.sessionData.sessionNames}

     

       126
       126
       +
                     '';

     

       127
       127
       +
               };

     

       128
       128
       +
               default =

     

       129
       129
       +
                 if dmDefault != null || wmDefault != null then

     

       130
       130
       +
                   defaultSessionFromLegacyOptions

     

       131
       131
       +
                 else

     

       132
       132
       +
                   null;

     

       133
       133
       +
               defaultText = lib.literalMD ''

     

       134
       134
       +
                 Taken from display manager settings or window manager settings, if either is set.

     

       135
       135
       +
               '';

     

       136
       136
       +
               example = "gnome";

     

       137
       137
       +
               description = lib.mdDoc ''

     

       138
       138
       +
                 Graphical session to pre-select in the session chooser (only effective for GDM, LightDM and SDDM).

     

       139
       139
       +
       

     

       140
       140
       +
                 On GDM, LightDM and SDDM, it will also be used as a session for auto-login.

     

       141
       141
       +
               '';

     

       142
       142
       +
             };

     

       143
       143
       +
       

     

       144
       144
       +
             sessionData = lib.mkOption {

     

       145
       145
       +
               description = lib.mdDoc "Data exported for display managers’ convenience";

     

       146
       146
       +
               internal = true;

     

       147
       147
       +
               default = {};

     

       148
       148
       +
             };

     

       149
       149
       +
       

     

       150
       150
       +
             sessionPackages = lib.mkOption {

     

       151
       151
       +
               type = lib.types.listOf (lib.types.package // {

     

       152
       152
       +
                 description = "package with provided sessions";

     

       153
       153
       +
                 check = p: lib.assertMsg

     

       154
       154
       +
                   (lib.types.package.check p && p ? providedSessions

     

       155
       155
       +
                   && p.providedSessions != [] && lib.all lib.isString p.providedSessions)

     

       156
       156
       +
                   ''

     

       157
       157
       +
                     Package, '${p.name}', did not specify any session names, as strings, in

     

       158
       158
       +
                     'passthru.providedSessions'. This is required when used as a session package.

     

       159
       159
       +
       

     

       160
       160
       +
                     The session names can be looked up in:

     

       161
       161
       +
                       ${p}/share/xsessions

     

       162
       162
       +
                       ${p}/share/wayland-sessions

     

       163
       163
       +
                  '';

     

       164
       164
       +
               });

     

       165
       165
       +
               default = [];

     

       166
       166
       +
               description = lib.mdDoc ''

     

       167
       167
       +
                 A list of packages containing x11 or wayland session files to be passed to the display manager.

     

       168
       168
       +
               '';

     

       169
       169
       +
             };

     

       170
       170
       +
           };

     

       171
       171
       +
         };

     

       172
       172
       +
       

     

       173
       173
       +
         imports = [

     

       174
       174
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "autoLogin" ] [ "services" "displayManager" "autoLogin" ])

     

       175
       175
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "defaultSession" ] [ "services" "displayManager" "defaultSession" ])

     

       176
       176
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "environment" ] [ "services" "displayManager" "environment" ])

     

       177
       177
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "execCmd" ] [ "services" "displayManager" "execCmd" ])

     

       178
       178
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "logToFile" ] [ "services" "displayManager" "logToFile" ])

     

       179
       179
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "logToJournal" ] [ "services" "displayManager" "logToJournal" ])

     

       180
       180
       +
           (lib.mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "preStart" ] [ "services" "displayManager" "preStart" ])

     

       181
       181
       +
         ];

     

       182
       182
       +
       

     

       183
       183
       +
         config = lib.mkIf cfg.enable {

     

       184
       184
       +
           assertions = [

     

       185
       185
       +
             { assertion = cfg.autoLogin.enable -> cfg.autoLogin.user != null;

     

       186
       186
       +
               message = ''

     

       187
       187
       +
                 services.displayManager.autoLogin.enable requires services.displayManager.autoLogin.user to be set

     

       188
       188
       +
               '';

     

       189
       189
       +
             }

     

       190
       190
       +
           ];

     

       191
       191
       +
       

     

       192
       192
       +
           warnings =

     

       193
       193
       +
             lib.mkIf (dmDefault != null || wmDefault != null) [

     

       194
       194
       +
               ''

     

       195
       195
       +
                 The following options are deprecated:

     

       196
       196
       +
                   ${lib.concatStringsSep "\n  " (map ({c, t}: t) (lib.filter ({c, t}: c != null) [

     

       197
       197
       +
                   { c = dmDefault; t = "- services.xserver.desktopManager.default"; }

     

       198
       198
       +
                   { c = wmDefault; t = "- services.xserver.windowManager.default"; }

     

       199
       199
       +
                   ]))}

     

       200
       200
       +
                 Please use

     

       201
       201
       +
                   services.displayManager.defaultSession = "${defaultSessionFromLegacyOptions}";

     

       202
       202
       +
                 instead.

     

       203
       203
       +
               ''

     

       204
       204
       +
             ];

     

       205
       205
       +
       

     

       206
       206
       +
           # Make xsessions and wayland sessions available in XDG_DATA_DIRS

     

       207
       207
       +
           # as some programs have behavior that depends on them being present

     

       208
       208
       +
           environment.sessionVariables.XDG_DATA_DIRS = lib.mkIf (cfg.sessionPackages != [ ]) [

     

       209
       209
       +
             "${cfg.sessionData.desktops}/share"

     

       210
       210
       +
           ];

     

       211
       211
       +
       

     

       212
       212
       +
           services.displayManager.sessionData = {

     

       213
       213
       +
             desktops = installedSessions;

     

       214
       214
       +
             sessionNames = lib.concatMap (p: p.providedSessions) config.services.displayManager.sessionPackages;

     

       215
       215
       +
             # We do not want to force users to set defaultSession when they have only single DE.

     

       216
       216
       +
             autologinSession =

     

       217
       217
       +
               if cfg.defaultSession != null then

     

       218
       218
       +
                 cfg.defaultSession

     

       219
       219
       +
               else if cfg.sessionData.sessionNames != [] then

     

       220
       220
       +
                 lib.head cfg.sessionData.sessionNames

     

       221
       221
       +
               else

     

       222
       222
       +
                 null;

     

       223
       223
       +
           };

     

       224
       224
       +
       

     

       225
       225
       +
           # so that the service won't be enabled when only startx is used

     

       226
       226
       +
           systemd.services.display-manager.enable =

     

       227
       227
       +
             let dmConf = config.services.xserver.displayManager;

     

       228
       228
       +
                 noDmUsed = !(dmConf.gdm.enable

     

       229
       229
       +
                           || cfg.sddm.enable

     

       230
       230
       +
                           || dmConf.xpra.enable

     

       231
       231
       +
                           || dmConf.lightdm.enable);

     

       232
       232
       +
             in lib.mkIf noDmUsed (lib.mkDefault false);

     

       233
       233
       +
       

     

       234
       234
       +
           systemd.services.display-manager = {

     

       235
       235
       +
             description = "Display Manager";

     

       236
       236
       +
             after = [ "acpid.service" "systemd-logind.service" "systemd-user-sessions.service" ];

     

       237
       237
       +
             restartIfChanged = false;

     

       238
       238
       +
       

     

       239
       239
       +
             environment = lib.optionalAttrs config.hardware.opengl.setLdLibraryPath {

     

       240
       240
       +
               LD_LIBRARY_PATH = lib.makeLibraryPath [ pkgs.addOpenGLRunpath.driverLink ];

     

       241
       241
       +
             } // cfg.environment;

     

       242
       242
       +
       

     

       243
       243
       +
             preStart = cfg.preStart;

     

       244
       244
       +
             script = lib.mkIf (config.systemd.services.display-manager.enable == true) cfg.execCmd;

     

       245
       245
       +
       

     

       246
       246
       +
             # Stop restarting if the display manager stops (crashes) 2 times

     

       247
       247
       +
             # in one minute. Starting X typically takes 3-4s.

     

       248
       248
       +
             startLimitIntervalSec = 30;

     

       249
       249
       +
             startLimitBurst = 3;

     

       250
       250
       +
             serviceConfig = {

     

       251
       251
       +
               Restart = "always";

     

       252
       252
       +
               RestartSec = "200ms";

     

       253
       253
       +
               SyslogIdentifier = "display-manager";

     

       254
       254
       +
             };

     

       255
       255
       +
           };

     

       256
       256
       +
         };

     

       257
       257
       +
       }

+54

nixos/modules/services/misc/graphical-desktop.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         config,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         pkgs,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         xcfg = config.services.xserver;

     

       9
       9
       +
         dmcfg = config.services.displayManager;

     

       10
       10
       +
       in

     

       11
       11
       +
       {

     

       12
       12
       +
         config = lib.mkIf (xcfg.enable || dmcfg.enable) {

     

       13
       13
       +
           # The default max inotify watches is 8192.

     

       14
       14
       +
           # Nowadays most apps require a good number of inotify watches,

     

       15
       15
       +
           # the value below is used by default on several other distros.

     

       16
       16
       +
           boot.kernel.sysctl = {

     

       17
       17
       +
             "fs.inotify.max_user_instances" = lib.mkDefault 524288;

     

       18
       18
       +
             "fs.inotify.max_user_watches" = lib.mkDefault 524288;

     

       19
       19
       +
           };

     

       20
       20
       +
       

     

       21
       21
       +
           environment = {

     

       22
       22
       +
             # localectl looks into 00-keyboard.conf

     

       23
       23
       +
             etc."X11/xorg.conf.d/00-keyboard.conf".text = ''

     

       24
       24
       +
               Section "InputClass"

     

       25
       25
       +
                 Identifier "Keyboard catchall"

     

       26
       26
       +
                 MatchIsKeyboard "on"

     

       27
       27
       +
                 Option "XkbModel" "${xcfg.xkb.model}"

     

       28
       28
       +
                 Option "XkbLayout" "${xcfg.xkb.layout}"

     

       29
       29
       +
                 Option "XkbOptions" "${xcfg.xkb.options}"

     

       30
       30
       +
                 Option "XkbVariant" "${xcfg.xkb.variant}"

     

       31
       31
       +
               EndSection

     

       32
       32
       +
             '';

     

       33
       33
       +
             systemPackages = with pkgs; [

     

       34
       34
       +
               nixos-icons # needed for gnome and pantheon about dialog, nixos-manual and maybe more

     

       35
       35
       +
               xdg-utils

     

       36
       36
       +
             ];

     

       37
       37
       +
           };

     

       38
       38
       +
       

     

       39
       39
       +
           fonts.enableDefaultPackages = lib.mkDefault true;

     

       40
       40
       +
       

     

       41
       41
       +
           hardware.opengl.enable = lib.mkDefault true;

     

       42
       42
       +
       

     

       43
       43
       +
           programs.gnupg.agent.pinentryPackage = lib.mkOverride 1100 pkgs.pinentry-gnome3;

     

       44
       44
       +
       

     

       45
       45
       +
           systemd.defaultUnit = lib.mkIf (xcfg.autorun || dmcfg.enable) "graphical.target";

     

       46
       46
       +
       

     

       47
       47
       +
           xdg = {

     

       48
       48
       +
             autostart.enable = true;

     

       49
       49
       +
             menus.enable = true;

     

       50
       50
       +
             mime.enable = true;

     

       51
       51
       +
             icons.enable = true;

     

       52
       52
       +
           };

     

       53
       53
       +
         };

     

       54
       54
       +
       }

+1 -1

nixos/modules/services/system/nix-daemon.nix

···

       247
       247
        
       

     

       248
       248
        
           users.users = nixbldUsers;

     

       249
       249
        
       

     

       250
       250
       -
           services.xserver.displayManager.hiddenUsers = attrNames nixbldUsers;

     

       250
       250
       +
           services.displayManager.hiddenUsers = attrNames nixbldUsers;

     

       251
       251
        
       

     

       252
       252
        
           # Legacy configuration conversion.

     

       253
       253
        
           nix.settings = mkMerge [

+1 -1

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

···

       91
       91
        
         };

     

       92
       92
        
       

     

       93
       93
        
         config = mkIf cfg.enable {

     

       94
       94
       -
           services.xserver.displayManager.sessionPackages = with pkgs; [

     

       94
       94
       +
           services.displayManager.sessionPackages = with pkgs; [

     

       95
       95
        
             budgie.budgie-desktop

     

       96
       96
        
           ];

     

       97
       97

+1 -1

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

···

       60
       60
        
       

     

       61
       61
        
         config = mkMerge [

     

       62
       62
        
           (mkIf cfg.enable {

     

       63
       63
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.cinnamon.cinnamon-common ];

     

       63
       63
       +
             services.displayManager.sessionPackages = [ pkgs.cinnamon.cinnamon-common ];

     

       64
       64
        
       

     

       65
       65
        
             services.xserver.displayManager.lightdm.greeters.slick = {

     

       66
       66
        
               enable = mkDefault true;

+2 -2

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

···

       38
       38
        
       

     

       39
       39
        
         config = mkIf cfg.enable

     

       40
       40
        
           {

     

       41
       41
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.deepin.dde-session ];

     

       42
       42
       -
             services.xserver.displayManager.defaultSession = mkDefault "dde-x11";

     

       41
       41
       +
             services.displayManager.sessionPackages = [ pkgs.deepin.dde-session ];

     

       42
       42
       +
             services.displayManager.defaultSession = mkDefault "dde-x11";

     

       43
       43
        
       

     

       44
       44
        
             # Update the DBus activation environment after launching the desktop manager.

     

       45
       45
        
             services.xserver.displayManager.sessionCommands = ''

+1 -1

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

···

       87
       87
        
               default = null;

     

       88
       88
        
               example = "none";

     

       89
       89
        
               description = lib.mdDoc ''

     

       90
       90
       -
                 **Deprecated**, please use [](#opt-services.xserver.displayManager.defaultSession) instead.

     

       90
       90
       +
                 **Deprecated**, please use [](#opt-services.displayManager.defaultSession) instead.

     

       91
       91
        
       

     

       92
       92
        
                 Default desktop manager loaded if none have been chosen.

     

       93
       93
        
               '';

+1 -1

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

···

       54
       54
        
             "/share/locale"

     

       55
       55
        
           ];

     

       56
       56
        
       

     

       57
       57
       -
           services.xserver.displayManager.sessionPackages = [ pkgs.enlightenment.enlightenment ];

     

       57
       57
       +
           services.displayManager.sessionPackages = [ pkgs.enlightenment.enlightenment ];

     

       58
       58
        
       

     

       59
       59
        
           services.xserver.displayManager.sessionCommands = ''

     

       60
       60
        
             if test "$XDG_CURRENT_DESKTOP" = "Enlightenment"; then

+2 -2

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

···

       261
       261
        
             services.gnome.core-shell.enable = true;

     

       262
       262
        
             services.gnome.core-utilities.enable = mkDefault true;

     

       263
       263
        
       

     

       264
       264
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.gnome.gnome-session.sessions ];

     

       264
       264
       +
             services.displayManager.sessionPackages = [ pkgs.gnome.gnome-session.sessions ];

     

       265
       265
        
       

     

       266
       266
        
             environment.extraInit = ''

     

       267
       267
        
               ${concatMapStrings (p: ''

     
···

       285
       285
        
           })

     

       286
       286
        
       

     

       287
       287
        
           (mkIf flashbackEnabled {

     

       288
       288
       -
             services.xserver.displayManager.sessionPackages =

     

       288
       288
       +
             services.displayManager.sessionPackages =

     

       289
       289
        
               let

     

       290
       290
        
                 wmNames = map (wm: wm.wmName) flashbackWms;

     

       291
       291
        
                 namesAreUnique = lib.unique wmNames == wmNames;

+1 -1

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

···

       27
       27
        
       

     

       28
       28
        
         config = mkIf cfg.enable {

     

       29
       29
        
       

     

       30
       30
       -
           services.xserver.displayManager.sessionPackages = [

     

       30
       30
       +
           services.displayManager.sessionPackages = [

     

       31
       31
        
             pkgs.lumina.lumina

     

       32
       32
        
           ];

     

       33
       33

+2 -2

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

···

       49
       49
        
       

     

       50
       50
        
         config = mkMerge [

     

       51
       51
        
           (mkIf (cfg.enable || cfg.enableWaylandSession) {

     

       52
       52
       -
             services.xserver.displayManager.sessionPackages = [

     

       52
       52
       +
             services.displayManager.sessionPackages = [

     

       53
       53
        
               pkgs.mate.mate-session-manager

     

       54
       54
        
             ];

     

       55
       55
        
       

     
···

       103
       103
        
             environment.sessionVariables.NIX_GSETTINGS_OVERRIDES_DIR = "${pkgs.mate.mate-gsettings-overrides}/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas";

     

       104
       104
        
       

     

       105
       105
        
             environment.systemPackages = [ pkgs.mate.mate-wayland-session ];

     

       106
       106
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.mate.mate-wayland-session ];

     

       106
       106
       +
             services.displayManager.sessionPackages = [ pkgs.mate.mate-wayland-session ];

     

       107
       107
        
           })

     

       108
       108
        
         ];

     

       109
       109
        
       }

+2 -2

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

···

       96
       96
        
               pkgs.pantheon.pantheon-agent-geoclue2

     

       97
       97
        
             ] config.environment.pantheon.excludePackages;

     

       98
       98
        
       

     

       99
       99
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.pantheon.elementary-session-settings ];

     

       99
       99
       +
             services.displayManager.sessionPackages = [ pkgs.pantheon.elementary-session-settings ];

     

       100
       100
        
       

     

       101
       101
        
             # Ensure lightdm is used when Pantheon is enabled

     

       102
       102
        
             # Without it screen locking will be nonfunctional because of the use of lightlocker

     
···

       109
       109
        
       

     

       110
       110
        
             # Without this, elementary LightDM greeter will pre-select non-existent `default` session

     

       111
       111
        
             # https://github.com/elementary/greeter/issues/368

     

       112
       112
       -
             services.xserver.displayManager.defaultSession = mkDefault "pantheon";

     

       112
       112
       +
             services.displayManager.defaultSession = mkDefault "pantheon";

     

       113
       113
        
       

     

       114
       114
        
             services.xserver.displayManager.sessionCommands = ''

     

       115
       115
        
               if test "$XDG_CURRENT_DESKTOP" = "Pantheon"; then

+1 -1

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

···

       220
       220
        
       

     

       221
       221
        
           services.gnome.core-shell.enable = true;

     

       222
       222
        
           services.gnome.core-os-services.enable = true;

     

       223
       223
       -
           services.xserver.displayManager.sessionPackages = [ cfg.package ];

     

       223
       223
       +
           services.displayManager.sessionPackages = [ cfg.package ];

     

       224
       224
        
       

     

       225
       225
        
           environment.etc."phosh/phoc.ini".source =

     

       226
       226
        
             if builtins.isPath cfg.phocConfig then cfg.phocConfig

+6 -6

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

···

       357
       357
        
               pkgs.media-player-info

     

       358
       358
        
             ];

     

       359
       359
        
       

     

       360
       360
       -
             services.xserver.displayManager.sddm = {

     

       360
       360
       +
             services.displayManager.sddm = {

     

       361
       361
        
               theme = mkDefault "breeze";

     

       362
       362
        
             };

     

       363
       363
        
       

     
···

       403
       403
        
             system.nixos-generate-config.desktopConfiguration = [

     

       404
       404
        
               ''

     

       405
       405
        
                 # Enable the Plasma 5 Desktop Environment.

     

       406
       406
       -
                 services.xserver.displayManager.sddm.enable = true;

     

       406
       406
       +
                 services.displayManager.sddm.enable = true;

     

       407
       407
        
                 services.xserver.desktopManager.plasma5.enable = true;

     

       408
       408
        
               ''

     

       409
       409
        
             ];

     

       410
       410
        
       

     

       411
       411
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.plasma5Packages.plasma-workspace ];

     

       411
       411
       +
             services.displayManager.sessionPackages = [ pkgs.plasma5Packages.plasma-workspace ];

     

       412
       412
        
             # Default to be `plasma` (X11) instead of `plasmawayland`, since plasma wayland currently has

     

       413
       413
        
             # many tiny bugs.

     

       414
       414
        
             # See: https://github.com/NixOS/nixpkgs/issues/143272

     

       415
       415
       -
             services.xserver.displayManager.defaultSession = mkDefault "plasma";

     

       415
       415
       +
             services.displayManager.defaultSession = mkDefault "plasma";

     

       416
       416
        
       

     

       417
       417
        
             environment.systemPackages =

     

       418
       418
        
               with pkgs.plasma5Packages;

     
···

       538
       538
        
               };

     

       539
       539
        
             };

     

       540
       540
        
       

     

       541
       541
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.plasma5Packages.plasma-mobile ];

     

       541
       541
       +
             services.displayManager.sessionPackages = [ pkgs.plasma5Packages.plasma-mobile ];

     

       542
       542
        
           })

     

       543
       543
        
       

     

       544
       544
        
           # Plasma Bigscreen

     
···

       559
       559
        
                 kdeconnect-kde

     

       560
       560
        
               ];

     

       561
       561
        
       

     

       562
       562
       -
             services.xserver.displayManager.sessionPackages = [ pkgs.plasma5Packages.plasma-bigscreen ];

     

       562
       562
       +
             services.displayManager.sessionPackages = [ pkgs.plasma5Packages.plasma-bigscreen ];

     

       563
       563
        
       

     

       564
       564
        
             # required for plasma-remotecontrollers to work correctly

     

       565
       565
        
             hardware.uinput.enable = true;

+1 -1

nixos/modules/services/x11/desktop-managers/surf-display.nix

···

       119
       119
        
         };

     

       120
       120
        
       

     

       121
       121
        
         config = mkIf cfg.enable {

     

       122
       122
       -
           services.xserver.displayManager.sessionPackages = [

     

       122
       122
       +
           services.displayManager.sessionPackages = [

     

       123
       123
        
             pkgs.surf-display

     

       124
       124
        
           ];

     

       125
       125

+8 -211

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

···

       14
       14
        
       let

     

       15
       15
        
       

     

       16
       16
        
         cfg = config.services.xserver;

     

       17
       17
       -
         opt = options.services.xserver;

     

       18
       17
        
         xorg = pkgs.xorg;

     

       19
       18
        
       

     

       20
       19
        
         fontconfig = config.fonts.fontconfig;

     
···

       70
       69
        
                 source ~/.xprofile

     

       71
       70
        
             fi

     

       72
       71
        
       

     

       73
       73
       -
             ${optionalString cfg.displayManager.job.logToJournal ''

     

       72
       72
       +
             ${optionalString config.services.displayManager.logToJournal ''

     

       74
       73
        
               if [ -z "$_DID_SYSTEMD_CAT" ]; then

     

       75
       74
        
                 export _DID_SYSTEMD_CAT=1

     

       76
       75
        
                 exec ${config.systemd.package}/bin/systemd-cat -t xsession "$0" "$@"

     

       77
       76
        
               fi

     

       78
       77
        
             ''}

     

       79
       78
        
       

     

       80
       80
       -
             ${optionalString cfg.displayManager.job.logToFile ''

     

       79
       79
       +
             ${optionalString config.services.displayManager.logToFile ''

     

       81
       80
        
               exec &> >(tee ~/.xsession-errors)

     

       82
       81
        
             ''}

     

       83
       82
        
       

     
···

       130
       129
        
                 exit 1

     

       131
       130
        
             fi

     

       132
       131
        
           '';

     

       133
       133
       -
       

     

       134
       134
       -
         installedSessions = pkgs.runCommand "desktops"

     

       135
       135
       -
           { # trivial derivation

     

       136
       136
       -
             preferLocalBuild = true;

     

       137
       137
       -
             allowSubstitutes = false;

     

       138
       138
       -
           }

     

       139
       139
       -
           ''

     

       140
       140
       -
             mkdir -p "$out/share/"{xsessions,wayland-sessions}

     

       141
       141
       -
       

     

       142
       142
       -
             ${concatMapStrings (pkg: ''

     

       143
       143
       -
               for n in ${concatStringsSep " " pkg.providedSessions}; do

     

       144
       144
       -
                 if ! test -f ${pkg}/share/wayland-sessions/$n.desktop -o \

     

       145
       145
       -
                           -f ${pkg}/share/xsessions/$n.desktop; then

     

       146
       146
       -
                   echo "Couldn't find provided session name, $n.desktop, in session package ${pkg.name}:"

     

       147
       147
       -
                   echo "  ${pkg}"

     

       148
       148
       -
                   return 1

     

       149
       149
       -
                 fi

     

       150
       150
       -
               done

     

       151
       151
       -
       

     

       152
       152
       -
               if test -d ${pkg}/share/xsessions; then

     

       153
       153
       -
                 ${pkgs.buildPackages.xorg.lndir}/bin/lndir ${pkg}/share/xsessions $out/share/xsessions

     

       154
       154
       -
               fi

     

       155
       155
       -
               if test -d ${pkg}/share/wayland-sessions; then

     

       156
       156
       -
                 ${pkgs.buildPackages.xorg.lndir}/bin/lndir ${pkg}/share/wayland-sessions $out/share/wayland-sessions

     

       157
       157
       -
               fi

     

       158
       158
       -
             '') cfg.displayManager.sessionPackages}

     

       159
       159
       -
           '';

     

       160
       160
       -
       

     

       161
       161
       -
         dmDefault = cfg.desktopManager.default;

     

       162
       162
       -
         # fallback default for cases when only default wm is set

     

       163
       163
       -
         dmFallbackDefault = if dmDefault != null then dmDefault else "none";

     

       164
       164
       -
         wmDefault = cfg.windowManager.default;

     

       165
       165
       -
       

     

       166
       166
       -
         defaultSessionFromLegacyOptions = dmFallbackDefault + optionalString (wmDefault != null && wmDefault != "none") "+${wmDefault}";

     

       167
       167
       -
       

     

       168
       132
        
       in

     

       169
       133
        
       

     

       170
       134
        
       {

     
···

       215
       179
        
               '';

     

       216
       180
        
             };

     

       217
       181
        
       

     

       218
       218
       -
             hiddenUsers = mkOption {

     

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

     

       220
       220
       -
               default = [ "nobody" ];

     

       221
       221
       -
               description = lib.mdDoc ''

     

       222
       222
       -
                 A list of users which will not be shown in the display manager.

     

       223
       223
       -
               '';

     

       224
       224
       -
             };

     

       225
       225
       -
       

     

       226
       226
       -
             sessionPackages = mkOption {

     

       227
       227
       -
               type = with types; listOf (package // {

     

       228
       228
       -
                 description = "package with provided sessions";

     

       229
       229
       -
                 check = p: assertMsg

     

       230
       230
       -
                   (package.check p && p ? providedSessions

     

       231
       231
       -
                   && p.providedSessions != [] && all isString p.providedSessions)

     

       232
       232
       -
                   ''

     

       233
       233
       -
                     Package, '${p.name}', did not specify any session names, as strings, in

     

       234
       234
       -
                     'passthru.providedSessions'. This is required when used as a session package.

     

       235
       235
       -
       

     

       236
       236
       -
                     The session names can be looked up in:

     

       237
       237
       -
                       ${p}/share/xsessions

     

       238
       238
       -
                       ${p}/share/wayland-sessions

     

       239
       239
       -
                  '';

     

       240
       240
       -
               });

     

       241
       241
       -
               default = [];

     

       242
       242
       -
               description = lib.mdDoc ''

     

       243
       243
       -
                 A list of packages containing x11 or wayland session files to be passed to the display manager.

     

       244
       244
       -
               '';

     

       245
       245
       -
             };

     

       246
       246
       -
       

     

       247
       182
        
             session = mkOption {

     

       248
       183
        
               default = [];

     

       249
       184
        
               type = types.listOf types.attrs;

     
···

       274
       209
        
               '';

     

       275
       210
        
             };

     

       276
       211
        
       

     

       277
       277
       -
             sessionData = mkOption {

     

       278
       278
       -
               description = lib.mdDoc "Data exported for display managers’ convenience";

     

       279
       279
       -
               internal = true;

     

       280
       280
       -
               default = {};

     

       281
       281
       -
               apply = val: {

     

       282
       282
       -
                 wrapper = xsessionWrapper;

     

       283
       283
       -
                 desktops = installedSessions;

     

       284
       284
       -
                 sessionNames = concatMap (p: p.providedSessions) cfg.displayManager.sessionPackages;

     

       285
       285
       -
                 # We do not want to force users to set defaultSession when they have only single DE.

     

       286
       286
       -
                 autologinSession =

     

       287
       287
       -
                   if cfg.displayManager.defaultSession != null then

     

       288
       288
       -
                     cfg.displayManager.defaultSession

     

       289
       289
       -
                   else if cfg.displayManager.sessionData.sessionNames != [] then

     

       290
       290
       -
                     head cfg.displayManager.sessionData.sessionNames

     

       291
       291
       -
                   else

     

       292
       292
       -
                     null;

     

       293
       293
       -
               };

     

       294
       294
       -
             };

     

       295
       295
       -
       

     

       296
       296
       -
             defaultSession = mkOption {

     

       297
       297
       -
               type = with types; nullOr str // {

     

       298
       298
       -
                 description = "session name";

     

       299
       299
       -
                 check = d:

     

       300
       300
       -
                   assertMsg (d != null -> (str.check d && elem d cfg.displayManager.sessionData.sessionNames)) ''

     

       301
       301
       -
                       Default graphical session, '${d}', not found.

     

       302
       302
       -
                       Valid names for 'services.xserver.displayManager.defaultSession' are:

     

       303
       303
       -
                         ${concatStringsSep "\n  " cfg.displayManager.sessionData.sessionNames}

     

       304
       304
       -
                     '';

     

       305
       305
       -
               };

     

       306
       306
       -
               default =

     

       307
       307
       -
                 if dmDefault != null || wmDefault != null then

     

       308
       308
       -
                   defaultSessionFromLegacyOptions

     

       309
       309
       -
                 else

     

       310
       310
       -
                   null;

     

       311
       311
       -
               defaultText = literalMD ''

     

       312
       312
       -
                 Taken from display manager settings or window manager settings, if either is set.

     

       313
       313
       -
               '';

     

       314
       314
       -
               example = "gnome";

     

       315
       315
       -
               description = lib.mdDoc ''

     

       316
       316
       -
                 Graphical session to pre-select in the session chooser (only effective for GDM, LightDM and SDDM).

     

       317
       317
       -
       

     

       318
       318
       -
                 On GDM, LightDM and SDDM, it will also be used as a session for auto-login.

     

       319
       319
       -
               '';

     

       320
       320
       -
             };

     

       321
       321
       -
       

     

       322
       212
        
             importedVariables = mkOption {

     

       323
       213
        
               type = types.listOf (types.strMatching "[a-zA-Z_][a-zA-Z0-9_]*");

     

       324
       214
        
               visible = false;

     
···

       327
       217
        
               '';

     

       328
       218
        
             };

     

       329
       219
        
       

     

       330
       330
       -
             job = {

     

       331
       331
       -
       

     

       332
       332
       -
               preStart = mkOption {

     

       333
       333
       -
                 type = types.lines;

     

       334
       334
       -
                 default = "";

     

       335
       335
       -
                 example = "rm -f /var/log/my-display-manager.log";

     

       336
       336
       -
                 description = lib.mdDoc "Script executed before the display manager is started.";

     

       337
       337
       -
               };

     

       338
       338
       -
       

     

       339
       339
       -
               execCmd = mkOption {

     

       340
       340
       -
                 type = types.str;

     

       341
       341
       -
                 example = literalExpression ''"''${pkgs.lightdm}/bin/lightdm"'';

     

       342
       342
       -
                 description = lib.mdDoc "Command to start the display manager.";

     

       343
       343
       -
               };

     

       344
       344
       -
       

     

       345
       345
       -
               environment = mkOption {

     

       346
       346
       -
                 type = types.attrsOf types.unspecified;

     

       347
       347
       -
                 default = {};

     

       348
       348
       -
                 description = lib.mdDoc "Additional environment variables needed by the display manager.";

     

       349
       349
       -
               };

     

       350
       350
       -
       

     

       351
       351
       -
               logToFile = mkOption {

     

       352
       352
       -
                 type = types.bool;

     

       353
       353
       -
                 default = false;

     

       354
       354
       -
                 description = lib.mdDoc ''

     

       355
       355
       -
                   Whether the display manager redirects the output of the

     

       356
       356
       -
                   session script to {file}`~/.xsession-errors`.

     

       357
       357
       -
                 '';

     

       358
       358
       -
               };

     

       359
       359
       -
       

     

       360
       360
       -
               logToJournal = mkOption {

     

       361
       361
       -
                 type = types.bool;

     

       362
       362
       -
                 default = true;

     

       363
       363
       -
                 description = lib.mdDoc ''

     

       364
       364
       -
                   Whether the display manager redirects the output of the

     

       365
       365
       -
                   session script to the systemd journal.

     

       366
       366
       -
                 '';

     

       367
       367
       -
               };

     

       368
       368
       -
       

     

       369
       369
       -
             };

     

       370
       370
       -
       

     

       371
       371
       -
             # Configuration for automatic login. Common for all DM.

     

       372
       372
       -
             autoLogin = mkOption {

     

       373
       373
       -
               type = types.submodule ({ config, options, ... }: {

     

       374
       374
       -
                 options = {

     

       375
       375
       -
                   enable = mkOption {

     

       376
       376
       -
                     type = types.bool;

     

       377
       377
       -
                     default = config.user != null;

     

       378
       378
       -
                     defaultText = literalExpression "config.${options.user} != null";

     

       379
       379
       -
                     description = lib.mdDoc ''

     

       380
       380
       -
                       Automatically log in as {option}`autoLogin.user`.

     

       381
       381
       -
                     '';

     

       382
       382
       -
                   };

     

       383
       383
       -
       

     

       384
       384
       -
                   user = mkOption {

     

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

     

       386
       386
       -
                     default = null;

     

       387
       387
       -
                     description = lib.mdDoc ''

     

       388
       388
       -
                       User to be used for the automatic login.

     

       389
       389
       -
                     '';

     

       390
       390
       -
                   };

     

       391
       391
       -
                 };

     

       392
       392
       -
               });

     

       393
       393
       -
       

     

       394
       394
       -
               default = {};

     

       395
       395
       -
               description = lib.mdDoc ''

     

       396
       396
       -
                 Auto login configuration attrset.

     

       397
       397
       -
               '';

     

       398
       398
       -
             };

     

       399
       399
       -
       

     

       400
       220
        
           };

     

       401
       221
        
       

     

       402
       222
        
         };

     

       403
       223
        
       

     

       404
       224
        
         config = {

     

       405
       225
        
           assertions = [

     

       406
       406
       -
             { assertion = cfg.displayManager.autoLogin.enable -> cfg.displayManager.autoLogin.user != null;

     

       407
       407
       -
               message = ''

     

       408
       408
       -
                 services.xserver.displayManager.autoLogin.enable requires services.xserver.displayManager.autoLogin.user to be set

     

       409
       409
       -
               '';

     

       410
       410
       -
             }

     

       411
       226
        
             {

     

       412
       227
        
               assertion = cfg.desktopManager.default != null || cfg.windowManager.default != null -> cfg.displayManager.defaultSession == defaultSessionFromLegacyOptions;

     

       413
       413
       -
               message = "You cannot use both services.xserver.displayManager.defaultSession option and legacy options (services.xserver.desktopManager.default and services.xserver.windowManager.default).";

     

       228
       228
       +
               message = "You cannot use both services.displayManager.defaultSession option and legacy options (services.xserver.desktopManager.default and services.xserver.windowManager.default).";

     

       414
       229
        
             }

     

       415
       230
        
           ];

     

       416
       231
        
       

     

       417
       417
       -
           warnings =

     

       418
       418
       -
             mkIf (dmDefault != null || wmDefault != null) [

     

       419
       419
       -
               ''

     

       420
       420
       -
                 The following options are deprecated:

     

       421
       421
       -
                   ${concatStringsSep "\n  " (map ({c, t}: t) (filter ({c, t}: c != null) [

     

       422
       422
       -
                   { c = dmDefault; t = "- services.xserver.desktopManager.default"; }

     

       423
       423
       -
                   { c = wmDefault; t = "- services.xserver.windowManager.default"; }

     

       424
       424
       -
                   ]))}

     

       425
       425
       -
                 Please use

     

       426
       426
       -
                   services.xserver.displayManager.defaultSession = "${defaultSessionFromLegacyOptions}";

     

       427
       427
       -
                 instead.

     

       428
       428
       -
               ''

     

       429
       429
       -
             ];

     

       232
       232
       +
           services.displayManager.sessionData.wrapper = xsessionWrapper;

     

       430
       233
        
       

     

       431
       234
        
           services.xserver.displayManager.xserverBin = "${xorg.xorgserver.out}/bin/X";

     

       432
       235
        
       

     
···

       449
       252
        
       

     

       450
       253
        
           # Create desktop files and scripts for starting sessions for WMs/DMs

     

       451
       254
        
           # that do not have upstream session files (those defined using services.{display,desktop,window}Manager.session options).

     

       452
       452
       -
           services.xserver.displayManager.sessionPackages =

     

       255
       255
       +
           services.displayManager.sessionPackages =

     

       453
       256
        
             let

     

       454
       257
        
               dms = filter (s: s.manage == "desktop") cfg.displayManager.session;

     

       455
       258
        
               wms = filter (s: s.manage == "window") cfg.displayManager.session;

     
···

       511
       314
        
                   )

     

       512
       315
        
                   (cartesianProductOfSets { dm = dms; wm = wms; })

     

       513
       316
        
                 );

     

       514
       514
       -
       

     

       515
       515
       -
           # Make xsessions and wayland sessions available in XDG_DATA_DIRS

     

       516
       516
       -
           # as some programs have behavior that depends on them being present

     

       517
       517
       -
           environment.sessionVariables.XDG_DATA_DIRS = lib.mkIf (cfg.displayManager.sessionPackages != [ ]) [

     

       518
       518
       -
             "${cfg.displayManager.sessionData.desktops}/share"

     

       519
       519
       -
           ];

     

       520
       317
        
         };

     

       521
       318
        
       

     

       522
       319
        
         imports = [

     

       523
       320
        
           (mkRemovedOptionModule [ "services" "xserver" "displayManager" "desktopManagerHandlesLidAndPower" ]

     

       524
       321
        
            "The option is no longer necessary because all display managers have already delegated lid management to systemd.")

     

       525
       525
       -
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "logsXsession" ] [ "services" "xserver" "displayManager" "job" "logToFile" ])

     

       526
       526
       -
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "logToJournal" ] [ "services" "xserver" "displayManager" "job" "logToJournal" ])

     

       527
       527
       -
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "extraSessionFilesPackages" ] [ "services" "xserver" "displayManager" "sessionPackages" ])

     

       322
       322
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "job" "logsXsession" ] [ "services" "displayManager" "logToFile" ])

     

       323
       323
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "logToJournal" ] [ "services" "displayManager" "logToJournal" ])

     

       324
       324
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "extraSessionFilesPackages" ] [ "services" "displayManager" "sessionPackages" ])

     

       528
       325
        
         ];

     

       529
       326
        
       

     

       530
       327
        
       }

+9 -11

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

···

       32
       32
        
           load-module module-position-event-sounds

     

       33
       33
        
         '';

     

       34
       34
        
       

     

       35
       35
       -
         defaultSessionName = config.services.xserver.displayManager.defaultSession;

     

       35
       35
       +
         defaultSessionName = config.services.displayManager.defaultSession;

     

       36
       36
        
       

     

       37
       37
        
         setSessionScript = pkgs.callPackage ./account-service-util.nix { };

     

       38
       38
        
       in

     
···

       41
       41
        
         imports = [

     

       42
       42
        
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "gdm" "autoLogin" "enable" ] [

     

       43
       43
        
             "services"

     

       44
       44
       -
             "xserver"

     

       45
       44
        
             "displayManager"

     

       46
       45
        
             "autoLogin"

     

       47
       46
        
             "enable"

     

       48
       47
        
           ])

     

       49
       48
        
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "gdm" "autoLogin" "user" ] [

     

       50
       49
        
             "services"

     

       51
       51
       -
             "xserver"

     

       52
       50
        
             "displayManager"

     

       53
       51
        
             "autoLogin"

     

       54
       52
        
             "user"

     
···

       148
       146
        
           services.xserver.display = null;

     

       149
       147
        
           services.xserver.verbose = null;

     

       150
       148
        
       

     

       151
       151
       -
           services.xserver.displayManager.job =

     

       149
       149
       +
           services.displayManager =

     

       152
       150
        
             {

     

       153
       151
        
               environment = {

     

       154
       152
        
                 GDM_X_SERVER_EXTRA_ARGS = toString

     

       155
       153
        
                   (filter (arg: arg != "-terminate") cfg.xserverArgs);

     

       156
       154
        
                 XDG_DATA_DIRS = lib.makeSearchPath "share" [

     

       157
       155
        
                   gdm # for gnome-login.session

     

       158
       158
       -
                   cfg.sessionData.desktops

     

       156
       156
       +
                   config.services.displayManager.sessionData.desktops

     

       159
       157
        
                   pkgs.gnome.gnome-control-center # for accessibility icon

     

       160
       158
        
                   pkgs.gnome.adwaita-icon-theme

     

       161
       159
        
                   pkgs.hicolor-icon-theme # empty icon theme as a base

     
···

       169
       167
        
               execCmd = "exec ${gdm}/bin/gdm";

     

       170
       168
        
               preStart = optionalString (defaultSessionName != null) ''

     

       171
       169
        
                 # Set default session in session chooser to a specified values – basically ignore session history.

     

       172
       172
       -
                 ${setSessionScript}/bin/set-session ${cfg.sessionData.autologinSession}

     

       170
       170
       +
                 ${setSessionScript}/bin/set-session ${config.services.displayManager.sessionData.autologinSession}

     

       173
       171
        
               '';

     

       174
       172
        
             };

     

       175
       173
        
       

     
···

       265
       263
        
             daemon = mkMerge [

     

       266
       264
        
               { WaylandEnable = cfg.gdm.wayland; }

     

       267
       265
        
               # nested if else didn't work

     

       268
       268
       -
               (mkIf (cfg.autoLogin.enable && cfg.gdm.autoLogin.delay != 0 ) {

     

       266
       266
       +
               (mkIf (config.services.displayManager.autoLogin.enable && cfg.gdm.autoLogin.delay != 0 ) {

     

       269
       267
        
                 TimedLoginEnable = true;

     

       270
       270
       -
                 TimedLogin = cfg.autoLogin.user;

     

       268
       268
       +
                 TimedLogin = config.services.displayManager.autoLogin.user;

     

       271
       269
        
                 TimedLoginDelay = cfg.gdm.autoLogin.delay;

     

       272
       270
        
               })

     

       273
       273
       -
               (mkIf (cfg.autoLogin.enable && cfg.gdm.autoLogin.delay == 0 ) {

     

       271
       271
       +
               (mkIf (config.services.displayManager.autoLogin.enable && cfg.gdm.autoLogin.delay == 0 ) {

     

       274
       272
        
                 AutomaticLoginEnable = true;

     

       275
       275
       -
                 AutomaticLogin = cfg.autoLogin.user;

     

       273
       273
       +
                 AutomaticLogin = config.services.displayManager.autoLogin.user;

     

       276
       274
        
               })

     

       277
       275
        
             ];

     

       278
       276
        
             debug = mkIf cfg.gdm.debug {

     
···

       282
       280
        
       

     

       283
       281
        
           environment.etc."gdm/custom.conf".source = configFile;

     

       284
       282
        
       

     

       285
       285
       -
           environment.etc."gdm/Xsession".source = config.services.xserver.displayManager.sessionData.wrapper;

     

       283
       283
       +
           environment.etc."gdm/Xsession".source = config.services.displayManager.sessionData.wrapper;

     

       286
       284
        
       

     

       287
       285
        
           # GDM LFS PAM modules, adapted somehow to NixOS

     

       288
       286
        
           security.pam.services = {

+1 -1

nixos/modules/services/x11/display-managers/lightdm-greeters/mini.nix

···

       60
       60
        
       

     

       61
       61
        
                 Note that this greeter starts only the default X session.

     

       62
       62
        
                 You can configure the default X session using

     

       63
       63
       -
                 [](#opt-services.xserver.displayManager.defaultSession).

     

       63
       63
       +
                 [](#opt-services.displayManager.defaultSession).

     

       64
       64
        
               '';

     

       65
       65
        
             };

     

       66
       66

+2 -2

nixos/modules/services/x11/display-managers/lightdm-greeters/tiny.nix

···

       22
       22
        
       

     

       23
       23
        
                 Note that this greeter starts only the default X session.

     

       24
       24
        
                 You can configure the default X session using

     

       25
       25
       -
                 [](#opt-services.xserver.displayManager.defaultSession).

     

       25
       25
       +
                 [](#opt-services.displayManager.defaultSession).

     

       26
       26
        
               '';

     

       27
       27
        
             };

     

       28
       28
        
       

     
···

       81
       81
        
             {

     

       82
       82
        
               assertion = dmcfg.defaultSession != null;

     

       83
       83
        
               message = ''

     

       84
       84
       -
                 Please set: services.xserver.displayManager.defaultSession

     

       84
       84
       +
                 Please set: services.displayManager.defaultSession

     

       85
       85
        
               '';

     

       86
       86
        
             }

     

       87
       87
        
           ];

+9 -11

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

···

       5
       5
        
       let

     

       6
       6
        
       

     

       7
       7
        
         xcfg = config.services.xserver;

     

       8
       8
       -
         dmcfg = xcfg.displayManager;

     

       8
       8
       +
         dmcfg = config.services.displayManager;

     

       9
       9
        
         xEnv = config.systemd.services.display-manager.environment;

     

       10
       10
       -
         cfg = dmcfg.lightdm;

     

       10
       10
       +
         cfg = xcfg.displayManager.lightdm;

     

       11
       11
        
         sessionData = dmcfg.sessionData;

     

       12
       12
        
       

     

       13
       13
        
         setSessionScript = pkgs.callPackage ./account-service-util.nix { };

     
···

       26
       26
        
             else additionalArgs="-logfile /var/log/X.$display.log"

     

       27
       27
        
             fi

     

       28
       28
        
       

     

       29
       29
       -
             exec ${dmcfg.xserverBin} ${toString dmcfg.xserverArgs} $additionalArgs "$@"

     

       29
       29
       +
             exec ${xcfg.displayManager.xserverBin} ${toString xcfg.displayManager.xserverArgs} $additionalArgs "$@"

     

       30
       30
        
           '';

     

       31
       31
        
       

     

       32
       32
        
         usersConf = writeText "users.conf"

     
···

       58
       58
        
               autologin-user-timeout = ${toString cfg.autoLogin.timeout}

     

       59
       59
        
               autologin-session = ${sessionData.autologinSession}

     

       60
       60
        
             ''}

     

       61
       61
       -
             ${optionalString (dmcfg.setupCommands != "") ''

     

       61
       61
       +
             ${optionalString (xcfg.displayManager.setupCommands != "") ''

     

       62
       62
        
               display-setup-script=${pkgs.writeScript "lightdm-display-setup" ''

     

       63
       63
        
                 #!${pkgs.bash}/bin/bash

     

       64
       64
       -
                 ${dmcfg.setupCommands}

     

       64
       64
       +
                 ${xcfg.displayManager.setupCommands}

     

       65
       65
        
               ''}

     

       66
       66
        
             ''}

     

       67
       67
        
             ${cfg.extraSeatDefaults}

     
···

       86
       86
        
           ./lightdm-greeters/mobile.nix

     

       87
       87
        
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "lightdm" "autoLogin" "enable" ] [

     

       88
       88
        
             "services"

     

       89
       89
       -
             "xserver"

     

       90
       89
        
             "displayManager"

     

       91
       90
        
             "autoLogin"

     

       92
       91
        
             "enable"

     

       93
       92
        
           ])

     

       94
       93
        
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "lightdm" "autoLogin" "user" ] [

     

       95
       94
        
            "services"

     

       96
       96
       -
            "xserver"

     

       97
       95
        
            "displayManager"

     

       98
       96
        
            "autoLogin"

     

       99
       97
        
            "user"

     
···

       187
       185
        
             }

     

       188
       186
        
             { assertion = dmcfg.autoLogin.enable -> sessionData.autologinSession != null;

     

       189
       187
        
               message = ''

     

       190
       190
       -
                 LightDM auto-login requires that services.xserver.displayManager.defaultSession is set.

     

       188
       188
       +
                 LightDM auto-login requires that services.displayManager.defaultSession is set.

     

       191
       189
        
               '';

     

       192
       190
        
             }

     

       193
       191
        
             { assertion = !cfg.greeter.enable -> (dmcfg.autoLogin.enable && cfg.autoLogin.timeout == 0);

     
···

       203
       201
        
       

     

       204
       202
        
           # Set default session in session chooser to a specified values – basically ignore session history.

     

       205
       203
        
           # Auto-login is already covered by a config value.

     

       206
       206
       -
           services.xserver.displayManager.job.preStart = optionalString (!dmcfg.autoLogin.enable && dmcfg.defaultSession != null) ''

     

       204
       204
       +
           services.displayManager.preStart = optionalString (!dmcfg.autoLogin.enable && dmcfg.defaultSession != null) ''

     

       207
       205
        
             ${setSessionScript}/bin/set-session ${dmcfg.defaultSession}

     

       208
       206
        
           '';

     

       209
       207
        
       

     

       210
       208
        
           # setSessionScript needs session-files in XDG_DATA_DIRS

     

       211
       211
       -
           services.xserver.displayManager.job.environment.XDG_DATA_DIRS = "${dmcfg.sessionData.desktops}/share/";

     

       209
       209
       +
           services.displayManager.environment.XDG_DATA_DIRS = "${dmcfg.sessionData.desktops}/share/";

     

       212
       210
        
       

     

       213
       211
        
           # setSessionScript wants AccountsService

     

       214
       212
        
           systemd.services.display-manager.wants = [

     
···

       216
       214
        
           ];

     

       217
       215
        
       

     

       218
       216
        
           # lightdm relaunches itself via just `lightdm`, so needs to be on the PATH

     

       219
       219
       -
           services.xserver.displayManager.job.execCmd = ''

     

       217
       217
       +
           services.displayManager.execCmd = ''

     

       220
       218
        
             export PATH=${lightdm}/sbin:$PATH

     

       221
       219
        
             exec ${lightdm}/sbin/lightdm

     

       222
       220
        
           '';

+36 -19

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

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         xcfg = config.services.xserver;

     

       5
       5
       -
         dmcfg = xcfg.displayManager;

     

       6
       6
       -
         cfg = dmcfg.sddm;

     

       5
       5
       +
         dmcfg = config.services.displayManager;

     

       6
       6
       +
         cfg = config.services.displayManager.sddm;

     

       7
       7
        
         xEnv = config.systemd.services.display-manager.environment;

     

       8
       8
        
       

     

       9
       9
        
         sddm = cfg.package.override (old: {

     
···

       21
       21
        
       

     

       22
       22
        
         xserverWrapper = pkgs.writeShellScript "xserver-wrapper" ''

     

       23
       23
        
           ${concatMapStrings (n: "export ${n}=\"${getAttr n xEnv}\"\n") (attrNames xEnv)}

     

       24
       24
       -
           exec systemd-cat -t xserver-wrapper ${dmcfg.xserverBin} ${toString dmcfg.xserverArgs} "$@"

     

       24
       24
       +
           exec systemd-cat -t xserver-wrapper ${xcfg.displayManager.xserverBin} ${toString xcfg.displayManager.xserverArgs} "$@"

     

       25
       25
        
         '';

     

       26
       26
        
       

     

       27
       27
        
         Xsetup = pkgs.writeShellScript "Xsetup" ''

     

       28
       28
        
           ${cfg.setupScript}

     

       29
       29
       -
           ${dmcfg.setupCommands}

     

       29
       29
       +
           ${xcfg.displayManager.setupCommands}

     

       30
       30
        
         '';

     

       31
       31
        
       

     

       32
       32
        
         Xstop = pkgs.writeShellScript "Xstop" ''

     
···

       40
       40
        
             Numlock = if cfg.autoNumlock then "on" else "none"; # on, off none

     

       41
       41
        
       

     

       42
       42
        
             # Implementation is done via pkgs/applications/display-managers/sddm/sddm-default-session.patch

     

       43
       43
       -
             DefaultSession = optionalString (dmcfg.defaultSession != null) "${dmcfg.defaultSession}.desktop";

     

       43
       43
       +
             DefaultSession = optionalString (config.services.displayManager.defaultSession != null) "${config.services.displayManager.defaultSession}.desktop";

     

       44
       44
        
       

     

       45
       45
        
             DisplayServer = if cfg.wayland.enable then "wayland" else "x11";

     

       46
       46
        
           } // optionalAttrs (cfg.wayland.compositor == "kwin") {

     
···

       128
       128
        
       in

     

       129
       129
        
       {

     

       130
       130
        
         imports = [

     

       131
       131
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "autoLogin" "minimumUid" ] [ "services" "displayManager" "sddm" "autoLogin" "minimumUid" ])

     

       132
       132
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "autoLogin" "relogin" ] [ "services" "displayManager" "sddm" "autoLogin" "relogin" ])

     

       133
       133
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "autoNumlock" ] [ "services" "displayManager" "sddm" "autoNumlock" ])

     

       134
       134
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "enable" ]      [ "services" "displayManager" "sddm" "enable" ])

     

       135
       135
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "enableHidpi" ] [ "services" "displayManager" "sddm" "enableHidpi" ])

     

       136
       136
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "extraPackages" ] [ "services" "displayManager" "sddm" "extraPackages" ])

     

       137
       137
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "package" ]     [ "services" "displayManager" "sddm" "package" ])

     

       138
       138
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "settings" ]    [ "services" "displayManager" "sddm" "settings" ])

     

       139
       139
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "setupScript" ] [ "services" "displayManager" "sddm" "setupScript" ])

     

       140
       140
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "stopScript" ]  [ "services" "displayManager" "sddm" "stopScript" ])

     

       141
       141
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "theme" ]       [ "services" "displayManager" "sddm" "theme" ])

     

       142
       142
       +
           (mkRenamedOptionModule [ "services" "xserver" "displayManager" "sddm" "wayland" "enable" ] [ "services" "displayManager" "sddm" "wayland" "enable" ])

     

       143
       143
       +
       

     

       131
       144
        
           (mkRemovedOptionModule

     

       132
       132
       -
             [ "services" "xserver" "displayManager" "sddm" "themes" ]

     

       133
       133
       -
             "Set the option `services.xserver.displayManager.sddm.package' instead.")

     

       145
       145
       +
             [ "services" "displayManager" "sddm" "themes" ]

     

       146
       146
       +
             "Set the option `services.displayManager.sddm.package' instead.")

     

       134
       147
        
           (mkRenamedOptionModule

     

       135
       135
       -
             [ "services" "xserver" "displayManager" "sddm" "autoLogin" "enable" ]

     

       136
       136
       -
             [ "services" "xserver" "displayManager" "autoLogin" "enable" ])

     

       148
       148
       +
             [ "services" "displayManager" "sddm" "autoLogin" "enable" ]

     

       149
       149
       +
             [ "services" "displayManager" "autoLogin" "enable" ])

     

       137
       150
        
           (mkRenamedOptionModule

     

       138
       138
       -
             [ "services" "xserver" "displayManager" "sddm" "autoLogin" "user" ]

     

       139
       139
       -
             [ "services" "xserver" "displayManager" "autoLogin" "user" ])

     

       151
       151
       +
             [ "services" "displayManager" "sddm" "autoLogin" "user" ]

     

       152
       152
       +
             [ "services" "displayManager" "autoLogin" "user" ])

     

       140
       153
        
           (mkRemovedOptionModule

     

       141
       141
       -
             [ "services" "xserver" "displayManager" "sddm" "extraConfig" ]

     

       142
       142
       -
             "Set the option `services.xserver.displayManager.sddm.settings' instead.")

     

       154
       154
       +
             [ "services" "displayManager" "sddm" "extraConfig" ]

     

       155
       155
       +
             "Set the option `services.displayManager.sddm.settings' instead.")

     

       143
       156
        
         ];

     

       144
       157
        
       

     

       145
       158
        
         options = {

     

       146
       159
        
       

     

       147
       147
       -
           services.xserver.displayManager.sddm = {

     

       160
       160
       +
           services.displayManager.sddm = {

     

       148
       161
        
             enable = mkOption {

     

       149
       162
        
               type = types.bool;

     

       150
       163
        
               default = false;

     
···

       268
       281
        
       

     

       269
       282
        
           assertions = [

     

       270
       283
        
             {

     

       271
       271
       -
               assertion = xcfg.enable;

     

       284
       284
       +
               assertion = xcfg.enable || cfg.wayland.enable;

     

       272
       285
        
               message = ''

     

       273
       273
       -
                 SDDM requires services.xserver.enable to be true

     

       286
       286
       +
                 SDDM requires either services.xserver.enable or services.displayManager.sddm.wayland.enable to be true

     

       274
       287
        
               '';

     

       275
       288
        
             }

     

       276
       289
        
             {

     

       277
       277
       -
               assertion = dmcfg.autoLogin.enable -> autoLoginSessionName != null;

     

       290
       290
       +
               assertion = config.services.displayManager.autoLogin.enable -> autoLoginSessionName != null;

     

       278
       291
        
               message = ''

     

       279
       279
       -
                 SDDM auto-login requires that services.xserver.displayManager.defaultSession is set.

     

       292
       292
       +
                 SDDM auto-login requires that services.displayManager.defaultSession is set.

     

       280
       293
        
               '';

     

       281
       294
        
             }

     

       282
       295
        
           ];

     

       296
       296
       +
       

     

       297
       297
       +
           services.displayManager = {

     

       298
       298
       +
             enable = true;

     

       299
       299
       +
             execCmd = "exec /run/current-system/sw/bin/sddm";

     

       300
       300
       +
           };

     

       283
       301
        
       

     

       284
       302
        
           security.pam.services = {

     

       285
       303
        
             sddm.text = ''

     
···

       338
       356
        
           services = {

     

       339
       357
        
             dbus.packages = [ sddm ];

     

       340
       358
        
             xserver = {

     

       341
       341
       -
               displayManager.job.execCmd = "exec /run/current-system/sw/bin/sddm";

     

       342
       359
        
               # To enable user switching, allow sddm to allocate TTYs/displays dynamically.

     

       343
       360
        
               tty = null;

     

       344
       361
        
               display = null;

+1 -1

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

···

       226
       226
        
             VideoRam 192000

     

       227
       227
        
           '';

     

       228
       228
        
       

     

       229
       229
       -
           services.xserver.displayManager.job.execCmd = ''

     

       229
       229
       +
           services.displayManager.execCmd = ''

     

       230
       230
        
             ${optionalString (cfg.pulseaudio)

     

       231
       231
        
               "export PULSE_COOKIE=/run/pulse/.config/pulse/cookie"}

     

       232
       232
        
             exec ${pkgs.xpra}/bin/xpra ${if cfg.desktop == null then "start" else "start-desktop --start=${cfg.desktop}"} \

+1 -1

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

···

       77
       77
        
               default = null;

     

       78
       78
        
               example = "wmii";

     

       79
       79
        
               description = lib.mdDoc ''

     

       80
       80
       -
                 **Deprecated**, please use [](#opt-services.xserver.displayManager.defaultSession) instead.

     

       80
       80
       +
                 **Deprecated**, please use [](#opt-services.displayManager.defaultSession) instead.

     

       81
       81
        
       

     

       82
       82
        
                 Default window manager loaded if none have been chosen.

     

       83
       83
        
               '';

+1 -1

nixos/modules/services/x11/window-managers/ragnarwm.nix

···

       18
       18
        
         ###### implementation

     

       19
       19
        
       

     

       20
       20
        
         config = mkIf cfg.enable {

     

       21
       21
       -
           services.xserver.displayManager.sessionPackages = [ cfg.package ];

     

       21
       21
       +
           services.displayManager.sessionPackages = [ cfg.package ];

     

       22
       22
        
           environment.systemPackages = [ cfg.package ];

     

       23
       23
        
         };

     

       24
       24

+5 -48

nixos/modules/services/x11/xserver.nix

···

       639
       639
        
         ###### implementation

     

       640
       640
        
       

     

       641
       641
        
         config = mkIf cfg.enable {

     

       642
       642
       +
           services.displayManager.enable = true;

     

       642
       643
        
       

     

       643
       644
        
           services.xserver.displayManager.lightdm.enable =

     

       644
       645
        
             let dmConf = cfg.displayManager;

     

       645
       646
        
                 default = !(dmConf.gdm.enable

     

       646
       646
       -
                           || dmConf.sddm.enable

     

       647
       647
       +
                           || config.services.displayManager.sddm.enable

     

       647
       648
        
                           || dmConf.xpra.enable

     

       648
       649
        
                           || dmConf.sx.enable

     

       649
       650
        
                           || dmConf.startx.enable

     

       650
       651
        
                           || config.services.greetd.enable);

     

       651
       652
        
             in mkIf (default) (mkDefault true);

     

       652
       652
       -
       

     

       653
       653
       -
           # so that the service won't be enabled when only startx is used

     

       654
       654
       -
           systemd.services.display-manager.enable  =

     

       655
       655
       -
             let dmConf = cfg.displayManager;

     

       656
       656
       -
                 noDmUsed = !(dmConf.gdm.enable

     

       657
       657
       -
                           || dmConf.sddm.enable

     

       658
       658
       -
                           || dmConf.xpra.enable

     

       659
       659
       -
                           || dmConf.lightdm.enable);

     

       660
       660
       -
             in mkIf (noDmUsed) (mkDefault false);

     

       661
       661
       -
       

     

       662
       662
       -
           hardware.opengl.enable = mkDefault true;

     

       663
       653
        
       

     

       664
       654
        
           services.xserver.videoDrivers = mkIf (cfg.videoDriver != null) [ cfg.videoDriver ];

     

       665
       655
        
       

     
···

       694
       684
        
                 # -xkbdir command line option does not seems to be passed to xkbcomp.

     

       695
       685
        
                 "X11/xkb".source = "${cfg.xkb.dir}";

     

       696
       686
        
               })

     

       697
       697
       -
             # localectl looks into 00-keyboard.conf

     

       698
       698
       -
             //{

     

       699
       699
       -
                 "X11/xorg.conf.d/00-keyboard.conf".text = ''

     

       700
       700
       -
                   Section "InputClass"

     

       701
       701
       -
                     Identifier "Keyboard catchall"

     

       702
       702
       -
                     MatchIsKeyboard "on"

     

       703
       703
       -
                     Option "XkbModel" "${cfg.xkb.model}"

     

       704
       704
       -
                     Option "XkbLayout" "${cfg.xkb.layout}"

     

       705
       705
       -
                     Option "XkbOptions" "${cfg.xkb.options}"

     

       706
       706
       -
                     Option "XkbVariant" "${cfg.xkb.variant}"

     

       707
       707
       -
                   EndSection

     

       708
       708
       -
                 '';

     

       709
       709
       -
               }

     

       710
       687
        
             # Needed since 1.18; see https://bugs.freedesktop.org/show_bug.cgi?id=89023#c5

     

       711
       688
        
             // (let cfgPath = "X11/xorg.conf.d/10-evdev.conf"; in

     

       712
       689
        
               {

     
···

       726
       703
        
               xorg.xprop

     

       727
       704
        
               xorg.xauth

     

       728
       705
        
               pkgs.xterm

     

       729
       729
       -
               pkgs.xdg-utils

     

       730
       706
        
               xorg.xf86inputevdev.out # get evdev.4 man page

     

       731
       731
       -
               pkgs.nixos-icons # needed for gnome and pantheon about dialog, nixos-manual and maybe more

     

       732
       707
        
             ] config.services.xserver.excludePackages

     

       733
       708
        
             ++ optional (elem "virtualbox" cfg.videoDrivers) xorg.xrefresh;

     

       734
       709
        
       

     

       735
       710
        
           environment.pathsToLink = [ "/share/X11" ];

     

       736
       711
        
       

     

       737
       737
       -
           xdg = {

     

       738
       738
       -
             autostart.enable = true;

     

       739
       739
       -
             menus.enable = true;

     

       740
       740
       -
             mime.enable = true;

     

       741
       741
       -
             icons.enable = true;

     

       742
       742
       -
           };

     

       743
       743
       -
       

     

       744
       744
       -
           # The default max inotify watches is 8192.

     

       745
       745
       -
           # Nowadays most apps require a good number of inotify watches,

     

       746
       746
       -
           # the value below is used by default on several other distros.

     

       747
       747
       -
           boot.kernel.sysctl."fs.inotify.max_user_instances" = mkDefault 524288;

     

       748
       748
       -
           boot.kernel.sysctl."fs.inotify.max_user_watches" = mkDefault 524288;

     

       749
       749
       -
       

     

       750
       750
       -
           programs.gnupg.agent.pinentryPackage = lib.mkOverride 1100 pkgs.pinentry-gnome3;

     

       751
       751
       -
       

     

       752
       752
       -
           systemd.defaultUnit = mkIf cfg.autorun "graphical.target";

     

       753
       753
       -
       

     

       754
       712
        
           systemd.services.display-manager =

     

       755
       713
        
             { description = "Display Manager";

     

       756
       714
        
       

     
···

       761
       719
        
               environment =

     

       762
       720
        
                 optionalAttrs config.hardware.opengl.setLdLibraryPath

     

       763
       721
        
                   { LD_LIBRARY_PATH = lib.makeLibraryPath [ pkgs.addOpenGLRunpath.driverLink ]; }

     

       764
       764
       -
                 // cfg.displayManager.job.environment;

     

       722
       722
       +
                 // config.services.displayManager.environment;

     

       765
       723
        
       

     

       766
       724
        
               preStart =

     

       767
       725
        
                 ''

     

       768
       768
       -
                   ${cfg.displayManager.job.preStart}

     

       726
       726
       +
                   ${config.services.displayManager.preStart}

     

       769
       727
        
       

     

       770
       728
        
                   rm -f /tmp/.X0-lock

     

       771
       729
        
                 '';

     

       772
       730
        
       

     

       773
       731
        
               # TODO: move declaring the systemd service to its own mkIf

     

       774
       774
       -
               script = mkIf (config.systemd.services.display-manager.enable == true) "${cfg.displayManager.job.execCmd}";

     

       732
       732
       +
               script = mkIf (config.systemd.services.display-manager.enable == true) "${config.services.displayManager.execCmd}";

     

       775
       733
        
       

     

       776
       734
        
               # Stop restarting if the display manager stops (crashes) 2 times

     

       777
       735
        
               # in one minute. Starting X typically takes 3-4s.

     
···

       910
       868
        
               ${cfg.extraConfig}

     

       911
       869
        
             '';

     

       912
       870
        
       

     

       913
       913
       -
           fonts.enableDefaultPackages = mkDefault true;

     

       914
       871
        
           fonts.packages = [

     

       915
       872
        
             (if cfg.upscaleDefaultCursor then fontcursormisc_hidpi else pkgs.xorg.fontcursormisc)

     

       916
       873
        
             pkgs.xorg.fontmiscmisc

+1 -1

nixos/modules/testing/test-instrumentation.nix

···

       216
       216
        
           # uses credentials to set passwords on users.

     

       217
       217
        
           users.users.root.hashedPasswordFile = mkOverride 150 "${pkgs.writeText "hashed-password.root" ""}";

     

       218
       218
        
       

     

       219
       219
       -
           services.xserver.displayManager.job.logToJournal = true;

     

       219
       219
       +
           services.displayManager.logToJournal = true;

     

       220
       220
        
       

     

       221
       221
        
           # Make sure we use the Guest Agent from the QEMU package for testing

     

       222
       222
        
           # to reduce the closure size required for the tests.

+1 -1

nixos/release.nix

···

       441
       441
        
       

     

       442
       442
        
           kde = makeClosure ({ ... }:

     

       443
       443
        
             { services.xserver.enable = true;

     

       444
       444
       -
               services.xserver.displayManager.sddm.enable = true;

     

       444
       444
       +
               services.displayManager.sddm.enable = true;

     

       445
       445
        
               services.xserver.desktopManager.plasma5.enable = true;

     

       446
       446
        
             });

     

       447
       447

+1 -1

nixos/tests/ayatana-indicators.nix

···

       21
       21
        
           services.xserver = {

     

       22
       22
        
             enable = true;

     

       23
       23
        
             desktopManager.mate.enable = true;

     

       24
       24
       -
             displayManager.defaultSession = lib.mkForce "mate";

     

       25
       24
        
           };

     

       25
       25
       +
           services.displayManager.defaultSession = lib.mkForce "mate";

     

       26
       26
        
       

     

       27
       27
        
           services.ayatana-indicators = {

     

       28
       28
        
             enable = true;

+1 -1

nixos/tests/cinnamon-wayland.nix

···

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

     

       8
       8
        
           services.xserver.enable = true;

     

       9
       9
        
           services.xserver.desktopManager.cinnamon.enable = true;

     

       10
       10
       -
           services.xserver.displayManager = {

     

       10
       10
       +
           services.displayManager = {

     

       11
       11
        
             autoLogin.enable = true;

     

       12
       12
        
             autoLogin.user = nodes.machine.users.users.alice.name;

     

       13
       13
        
             defaultSession = "cinnamon-wayland";

+4 -6

nixos/tests/common/auto.nix

···

       30
       30
        
         ###### implementation

     

       31
       31
        
       

     

       32
       32
        
         config = lib.mkIf cfg.enable {

     

       33
       33
       -
           services.xserver.displayManager = {

     

       34
       34
       -
             lightdm.enable = true;

     

       35
       35
       -
             autoLogin = {

     

       36
       36
       -
               enable = true;

     

       37
       37
       -
               user = cfg.user;

     

       38
       38
       -
             };

     

       33
       33
       +
           services.xserver.displayManager.lightdm.enable = true;

     

       34
       34
       +
           services.displayManager.autoLogin = {

     

       35
       35
       +
             enable = true;

     

       36
       36
       +
             user = cfg.user;

     

       39
       37
        
           };

     

       40
       38
        
       

     

       41
       39
        
           # lightdm by default doesn't allow auto login for root, which is

+1 -1

nixos/tests/common/x11.nix

···

       12
       12
        
       

     

       13
       13
        
         # Use IceWM as the window manager.

     

       14
       14
        
         # Don't use a desktop manager.

     

       15
       15
       -
         services.xserver.displayManager.defaultSession = lib.mkDefault "none+icewm";

     

       15
       15
       +
         services.displayManager.defaultSession = lib.mkDefault "none+icewm";

     

       16
       16
        
         services.xserver.windowManager.icewm.enable = true;

     

       17
       17
        
       }

+6 -5

nixos/tests/gnome-flashback.nix

···

       14
       14
        
             services.xserver.displayManager = {

     

       15
       15
        
               gdm.enable = true;

     

       16
       16
        
               gdm.debug = true;

     

       17
       17
       -
               autoLogin = {

     

       18
       18
       -
                 enable = true;

     

       19
       19
       -
                 user = user.name;

     

       20
       20
       -
               };

     

       17
       17
       +
             };

     

       18
       18
       +
       

     

       19
       19
       +
             services.displayManager.autoLogin = {

     

       20
       20
       +
               enable = true;

     

       21
       21
       +
               user = user.name;

     

       21
       22
        
             };

     

       22
       23
        
       

     

       23
       24
        
             services.xserver.desktopManager.gnome.enable = true;

     

       24
       25
        
             services.xserver.desktopManager.gnome.debug = true;

     

       25
       26
        
             services.xserver.desktopManager.gnome.flashback.enableMetacity = true;

     

       26
       26
       -
             services.xserver.displayManager.defaultSession = "gnome-flashback-metacity";

     

       27
       27
       +
             services.displayManager.defaultSession = "gnome-flashback-metacity";

     

       27
       28
        
           };

     

       28
       29
        
       

     

       29
       30
        
         testScript = { nodes, ... }: let

+6 -5

nixos/tests/gnome-xorg.nix

···

       15
       15
        
             services.xserver.displayManager = {

     

       16
       16
        
               gdm.enable = true;

     

       17
       17
        
               gdm.debug = true;

     

       18
       18
       -
               autoLogin = {

     

       19
       19
       -
                 enable = true;

     

       20
       20
       -
                 user = user.name;

     

       21
       21
       -
               };

     

       18
       18
       +
             };

     

       19
       19
       +
       

     

       20
       20
       +
             services.displayManager.autoLogin = {

     

       21
       21
       +
               enable = true;

     

       22
       22
       +
               user = user.name;

     

       22
       23
        
             };

     

       23
       24
        
       

     

       24
       25
        
             services.xserver.desktopManager.gnome.enable = true;

     

       25
       26
        
             services.xserver.desktopManager.gnome.debug = true;

     

       26
       26
       -
             services.xserver.displayManager.defaultSession = "gnome-xorg";

     

       27
       27
       +
             services.displayManager.defaultSession = "gnome-xorg";

     

       27
       28
        
       

     

       28
       29
        
             systemd.user.services = {

     

       29
       30
        
               "org.gnome.Shell@x11" = {

+5 -4

nixos/tests/gnome.nix

···

       12
       12
        
             services.xserver.displayManager = {

     

       13
       13
        
               gdm.enable = true;

     

       14
       14
        
               gdm.debug = true;

     

       15
       15
       -
               autoLogin = {

     

       16
       16
       -
                 enable = true;

     

       17
       17
       -
                 user = "alice";

     

       18
       18
       -
               };

     

       15
       15
       +
             };

     

       16
       16
       +
       

     

       17
       17
       +
             services.displayManager.autoLogin = {

     

       18
       18
       +
               enable = true;

     

       19
       19
       +
               user = "alice";

     

       19
       20
        
             };

     

       20
       21
        
       

     

       21
       22
        
             services.xserver.desktopManager.gnome.enable = true;

+1 -1

nixos/tests/herbstluftwm.nix

···

       8
       8
        
         nodes.machine = { pkgs, lib, ... }: {

     

       9
       9
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       10
       10
        
           test-support.displayManager.auto.user = "alice";

     

       11
       11
       -
           services.xserver.displayManager.defaultSession = lib.mkForce "none+herbstluftwm";

     

       11
       11
       +
           services.displayManager.defaultSession = lib.mkForce "none+herbstluftwm";

     

       12
       12
        
           services.xserver.windowManager.herbstluftwm.enable = true;

     

       13
       13
        
           environment.systemPackages = [ pkgs.dzen2 ]; # needed for upstream provided panel

     

       14
       14
        
         };

+1 -1

nixos/tests/i3wm.nix

···

       7
       7
        
         nodes.machine = { lib, ... }: {

     

       8
       8
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       9
       9
        
           test-support.displayManager.auto.user = "alice";

     

       10
       10
       -
           services.xserver.displayManager.defaultSession = lib.mkForce "none+i3";

     

       10
       10
       +
           services.displayManager.defaultSession = lib.mkForce "none+i3";

     

       11
       11
        
           services.xserver.windowManager.i3.enable = true;

     

       12
       12
        
         };

     

       13
       13

+1 -1

nixos/tests/lightdm.nix

···

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

     

       9
       9
        
           services.xserver.enable = true;

     

       10
       10
        
           services.xserver.displayManager.lightdm.enable = true;

     

       11
       11
       -
           services.xserver.displayManager.defaultSession = "none+icewm";

     

       11
       11
       +
           services.displayManager.defaultSession = "none+icewm";

     

       12
       12
        
           services.xserver.windowManager.icewm.enable = true;

     

       13
       13
        
         };

     

       14
       14

+6 -3

nixos/tests/maestral.nix

···

       29
       29
        
             gui = { ... }: common {

     

       30
       30
        
               services.xserver = {

     

       31
       31
        
                 enable = true;

     

       32
       32
       -
                 displayManager.sddm.enable = true;

     

       33
       33
       -
                 displayManager.defaultSession = "plasma";

     

       34
       32
        
                 desktopManager.plasma5.enable = true;

     

       35
       33
        
                 desktopManager.plasma5.runUsingSystemd = true;

     

       36
       36
       -
                 displayManager.autoLogin = {

     

       34
       34
       +
               };

     

       35
       35
       +
       

     

       36
       36
       +
               services.displayManager = {

     

       37
       37
       +
                 sddm.enable = true;

     

       38
       38
       +
                 defaultSession = "plasma";

     

       39
       39
       +
                 autoLogin = {

     

       37
       40
        
                   enable = true;

     

       38
       41
        
                   user = "alice";

     

       39
       42
        
                 };

+1 -1

nixos/tests/mate-wayland.nix

···

       9
       9
        
           ];

     

       10
       10
        
       

     

       11
       11
        
           services.xserver.enable = true;

     

       12
       12
       -
           services.xserver.displayManager = {

     

       12
       12
       +
           services.displayManager = {

     

       13
       13
        
             sddm.enable = true; # https://github.com/canonical/lightdm/issues/63

     

       14
       14
        
             sddm.wayland.enable = true;

     

       15
       15
        
             defaultSession = "MATE";

+2 -4

nixos/tests/miriway.nix

···

       19
       19
        
             user = "alice";

     

       20
       20
        
           };

     

       21
       21
        
       

     

       22
       22
       -
           services.xserver = {

     

       23
       23
       -
             enable = true;

     

       24
       24
       -
             displayManager.defaultSession = lib.mkForce "miriway";

     

       25
       25
       -
           };

     

       22
       22
       +
           services.xserver.enable = true;

     

       23
       23
       +
           services.displayManager.defaultSession = lib.mkForce "miriway";

     

       26
       24
        
       

     

       27
       25
        
           programs.miriway = {

     

       28
       26
        
             enable = true;

+1 -1

nixos/tests/nimdow.nix

···

       7
       7
        
         nodes.machine = { lib, ... }: {

     

       8
       8
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       9
       9
        
           test-support.displayManager.auto.user = "alice";

     

       10
       10
       -
           services.xserver.displayManager.defaultSession = lib.mkForce "none+nimdow";

     

       10
       10
       +
           services.displayManager.defaultSession = lib.mkForce "none+nimdow";

     

       11
       11
        
           services.xserver.windowManager.nimdow.enable = true;

     

       12
       12
        
         };

     

       13
       13

+3 -3

nixos/tests/plasma-bigscreen.nix

···

       11
       11
        
         {

     

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

     

       13
       13
        
           services.xserver.enable = true;

     

       14
       14
       -
           services.xserver.displayManager.sddm.enable = true;

     

       15
       15
       -
           services.xserver.displayManager.defaultSession = "plasma-bigscreen-x11";

     

       14
       14
       +
           services.displayManager.sddm.enable = true;

     

       15
       15
       +
           services.displayManager.defaultSession = "plasma-bigscreen-x11";

     

       16
       16
        
           services.xserver.desktopManager.plasma5.bigscreen.enable = true;

     

       17
       17
       -
           services.xserver.displayManager.autoLogin = {

     

       17
       17
       +
           services.displayManager.autoLogin = {

     

       18
       18
        
             enable = true;

     

       19
       19
        
             user = "alice";

     

       20
       20
        
           };

+6 -3

nixos/tests/plasma5-systemd-start.nix

···

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

     

       13
       13
        
           services.xserver = {

     

       14
       14
        
             enable = true;

     

       15
       15
       -
             displayManager.sddm.enable = true;

     

       16
       16
       -
             displayManager.defaultSession = "plasma";

     

       17
       15
        
             desktopManager.plasma5.enable = true;

     

       18
       16
        
             desktopManager.plasma5.runUsingSystemd = true;

     

       19
       19
       -
             displayManager.autoLogin = {

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
           services.displayManager = {

     

       20
       20
       +
             sddm.enable = true;

     

       21
       21
       +
             defaultSession = "plasma";

     

       22
       22
       +
             autoLogin = {

     

       20
       23
        
               enable = true;

     

       21
       24
        
               user = "alice";

     

       22
       25
        
             };

+3 -3

nixos/tests/plasma5.nix

···

       11
       11
        
         {

     

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

     

       13
       13
        
           services.xserver.enable = true;

     

       14
       14
       -
           services.xserver.displayManager.sddm.enable = true;

     

       15
       15
       -
           services.xserver.displayManager.defaultSession = "plasma";

     

       14
       14
       +
           services.displayManager.sddm.enable = true;

     

       15
       15
       +
           services.displayManager.defaultSession = "plasma";

     

       16
       16
        
           services.xserver.desktopManager.plasma5.enable = true;

     

       17
       17
        
           environment.plasma5.excludePackages = [ pkgs.plasma5Packages.elisa ];

     

       18
       18
       -
           services.xserver.displayManager.autoLogin = {

     

       18
       18
       +
           services.displayManager.autoLogin = {

     

       19
       19
        
             enable = true;

     

       20
       20
        
             user = "alice";

     

       21
       21
        
           };

+4 -4

nixos/tests/plasma6.nix

···

       11
       11
        
         {

     

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

     

       13
       13
        
           services.xserver.enable = true;

     

       14
       14
       -
           services.xserver.displayManager.sddm.enable = true;

     

       14
       14
       +
           services.displayManager.sddm.enable = true;

     

       15
       15
        
           # FIXME: this should be testing Wayland

     

       16
       16
       -
           services.xserver.displayManager.defaultSession = "plasmax11";

     

       17
       17
       -
           services.xserver.desktopManager.plasma6.enable = true;

     

       16
       16
       +
           services.displayManager.defaultSession = "plasmax11";

     

       17
       17
       +
           services.desktopManager.plasma6.enable = true;

     

       18
       18
        
           environment.plasma6.excludePackages = [ pkgs.kdePackages.elisa ];

     

       19
       19
       -
           services.xserver.displayManager.autoLogin = {

     

       19
       19
       +
           services.displayManager.autoLogin = {

     

       20
       20
        
             enable = true;

     

       21
       21
        
             user = "alice";

     

       22
       22
        
           };

+1 -1

nixos/tests/ragnarwm.nix

···

       8
       8
        
         nodes.machine = { pkgs, lib, ... }: {

     

       9
       9
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       10
       10
        
           test-support.displayManager.auto.user = "alice";

     

       11
       11
       -
           services.xserver.displayManager.defaultSession = lib.mkForce "ragnar";

     

       11
       11
       +
           services.displayManager.defaultSession = lib.mkForce "ragnar";

     

       12
       12
        
           services.xserver.windowManager.ragnarwm.enable = true;

     

       13
       13
        
       

     

       14
       14
        
           # Setup the default terminal of Ragnar

+4 -4

nixos/tests/sddm.nix

···

       15
       15
        
             nodes.machine = { ... }: {

     

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

     

       17
       17
        
               services.xserver.enable = true;

     

       18
       18
       -
               services.xserver.displayManager.sddm.enable = true;

     

       19
       19
       -
               services.xserver.displayManager.defaultSession = "none+icewm";

     

       18
       18
       +
               services.displayManager.sddm.enable = true;

     

       19
       19
       +
               services.displayManager.defaultSession = "none+icewm";

     

       20
       20
        
               services.xserver.windowManager.icewm.enable = true;

     

       21
       21
        
             };

     

       22
       22
        
       

     
···

       44
       44
        
             nodes.machine = { ... }: {

     

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

     

       46
       46
        
               services.xserver.enable = true;

     

       47
       47
       -
               services.xserver.displayManager = {

     

       47
       47
       +
               services.displayManager = {

     

       48
       48
        
                 sddm.enable = true;

     

       49
       49
        
                 autoLogin = {

     

       50
       50
        
                   enable = true;

     

       51
       51
        
                   user = "alice";

     

       52
       52
        
                 };

     

       53
       53
        
               };

     

       54
       54
       -
               services.xserver.displayManager.defaultSession = "none+icewm";

     

       54
       54
       +
               services.displayManager.defaultSession = "none+icewm";

     

       55
       55
        
               services.xserver.windowManager.icewm.enable = true;

     

       56
       56
        
             };

     

       57
       57

+1 -1

nixos/tests/wmderland.nix

···

       7
       7
        
         nodes.machine = { lib, ... }: {

     

       8
       8
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       9
       9
        
           test-support.displayManager.auto.user = "alice";

     

       10
       10
       -
           services.xserver.displayManager.defaultSession = lib.mkForce "none+wmderland";

     

       10
       10
       +
           services.displayManager.defaultSession = lib.mkForce "none+wmderland";

     

       11
       11
        
           services.xserver.windowManager.wmderland.enable = true;

     

       12
       12
        
       

     

       13
       13
        
           systemd.services.setupWmderlandConfig = {

+4 -6

nixos/tests/xfce.nix

···

       10
       10
        
             ];

     

       11
       11
        
       

     

       12
       12
        
             services.xserver.enable = true;

     

       13
       13
       +
             services.xserver.displayManager.lightdm.enable = true;

     

       13
       14
        
       

     

       14
       14
       -
             services.xserver.displayManager = {

     

       15
       15
       -
               lightdm.enable = true;

     

       16
       16
       -
               autoLogin = {

     

       17
       17
       -
                 enable = true;

     

       18
       18
       -
                 user = "alice";

     

       19
       19
       -
               };

     

       15
       15
       +
             services.displayManager.autoLogin = {

     

       16
       16
       +
               enable = true;

     

       17
       17
       +
               user = "alice";

     

       20
       18
        
             };

     

       21
       19
        
       

     

       22
       20
        
             services.xserver.desktopManager.xfce.enable = true;

+1 -1

nixos/tests/xmonad-xdg-autostart.nix

···

       5
       5
        
         nodes.machine = { pkgs, config, ... }: {

     

       6
       6
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       7
       7
        
           test-support.displayManager.auto.user = "alice";

     

       8
       8
       -
           services.xserver.displayManager.defaultSession = "none+xmonad";

     

       8
       8
       +
           services.displayManager.defaultSession = "none+xmonad";

     

       9
       9
        
           services.xserver.windowManager.xmonad.enable = true;

     

       10
       10
        
           services.xserver.desktopManager.runXdgAutostartIfNone = true;

     

       11
       11

+1 -1

nixos/tests/xmonad.nix

···

       61
       61
        
         nodes.machine = { pkgs, ... }: {

     

       62
       62
        
           imports = [ ./common/x11.nix ./common/user-account.nix ];

     

       63
       63
        
           test-support.displayManager.auto.user = "alice";

     

       64
       64
       -
           services.xserver.displayManager.defaultSession = "none+xmonad";

     

       64
       64
       +
           services.displayManager.defaultSession = "none+xmonad";

     

       65
       65
        
           services.xserver.windowManager.xmonad = {

     

       66
       66
        
             enable = true;

     

       67
       67
        
             enableConfiguredRecompile = true;