commit b12564cc1b8319b317d98df03fec8ba4bbf71877 · pyrox.dev/nixpkgs

+2 -3

nixos/doc/manual/configuration/modularity.xml

···

       36
       36
        
       { config, pkgs, ... }:

     

       37
       37
        
       

     

       38
       38
        
       { services.xserver.enable = true;

     

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

     

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

     

       41
       41
       -
         environment.systemPackages = [ pkgs.kde4.kscreensaver ];

     

       39
       39
       +
         services.xserver.displayManager.sddm.enable = true;

     

       40
       40
       +
         services.xserver.desktopManager.kde5.enable = true;

     

       42
       41
        
       }

     

       43
       42
        
       </programlisting>

     

       44
       43

+3 -3

nixos/doc/manual/configuration/x-windows.xml

···

       25
       25
        
       <command>xterm</command> window.  Thus you should pick one or more of

     

       26
       26
        
       the following lines:

     

       27
       27
        
       <programlisting>

     

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

     

       28
       28
       +
       services.xserver.desktopManager.kde5.enable = true;

     

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

     

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

     

       31
       31
        
       services.xserver.windowManager.twm.enable = true;

     
···

       35
       35
        
       

     

       36
       36
        
       <para>NixOS’s default <emphasis>display manager</emphasis> (the

     

       37
       37
        
       program that provides a graphical login prompt and manages the X

     

       38
       38
       -
       server) is SLiM.  You can select KDE’s <command>kdm</command> instead:

     

       38
       38
       +
       server) is SLiM.  You can select KDE’s <command>sddm</command> instead:

     

       39
       39
        
       <programlisting>

     

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

     

       40
       40
       +
       services.xserver.displayManager.sddm.enable = true;

     

       41
       41
        
       </programlisting>

     

       42
       42
        
       </para>

     

       43
       43

+2 -2

nixos/doc/manual/configuration/xfce.xml

···

       41
       41
        
       		(DM is the program that provides a graphical login prompt

     

       42
       42
        
       		 and manages the X server.)

     

       43
       43
        
       	   	You can, for example, select KDE’s

     

       44
       44
       -
               <command>kdm</command> instead:

     

       44
       44
       +
               <command>sddm</command> instead:

     

       45
       45
        
               <programlisting>

     

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

     

       46
       46
       +
                   services.xserver.displayManager.sddm.enable = true;

     

       47
       47
        
               </programlisting>

     

       48
       48
        
           </para>

     

       49
       49

+24 -24

nixos/doc/manual/development/option-declarations.xml

···

       65
       65
        
       

     

       66
       66
        
       </para>

     

       67
       67
        
       

     

       68
       68
       -
       <section xml:id="sec-option-declarations-eot"><title>Extensible Option 

     

       68
       68
       +
       <section xml:id="sec-option-declarations-eot"><title>Extensible Option

     

       69
       69
        
           Types</title>

     

       70
       70
        
       

     

       71
       71
       -
         <para>Extensible option types is a feature that allow to extend certain types 

     

       71
       71
       +
         <para>Extensible option types is a feature that allow to extend certain types

     

       72
       72
        
           declaration through multiple module files.

     

       73
       73
       -
           This feature only work with a restricted set of types, namely 

     

       73
       73
       +
           This feature only work with a restricted set of types, namely

     

       74
       74
        
           <literal>enum</literal> and <literal>submodules</literal> and any composed

     

       75
       75
        
           forms of them.</para>

     

       76
       76
        
       

     

       77
       77
       -
         <para>Extensible option types can be used for <literal>enum</literal> options 

     

       78
       78
       -
           that affects multiple modules, or as an alternative to related 

     

       77
       77
       +
         <para>Extensible option types can be used for <literal>enum</literal> options

     

       78
       78
       +
           that affects multiple modules, or as an alternative to related

     

       79
       79
        
           <literal>enable</literal> options.</para>

     

       80
       80
        
       

     

       81
       81
        
         <para>As an example, we will take the case of display managers. There is a

     

       82
       82
        
           central display manager module for generic display manager options and a

     

       83
       83
       -
           module file per display manager backend (slim, kdm, gdm ...).

     

       83
       83
       +
           module file per display manager backend (slim, sddm, gdm ...).

     

       84
       84
        
         </para>

     

       85
       85
        
       

     

       86
       86
        
         <para>There are two approach to this module structure:

     
···

       96
       96
        
         </para>

     

       97
       97
        
       

     

       98
       98
        
         <para>Both approachs have problems.</para>

     

       99
       99
       -
           

     

       99
       99
       +
       

     

       100
       100
        
         <para>Making backends independent can quickly become hard to manage. For

     

       101
       101
        
           display managers, there can be only one enabled at a time, but the type

     

       102
       102
        
           system can not enforce this restriction as there is no relation between

     
···

       108
       108
        
           central module will require to change the central module option every time

     

       109
       109
        
           a new backend is added or removed.</para>

     

       110
       110
        
       

     

       111
       111
       -
         <para>By using extensible option types, it is possible to create a placeholder 

     

       112
       112
       -
           option in the central module (<xref linkend='ex-option-declaration-eot-service' 

     

       113
       113
       -
             />), and to extend it in each backend module (<xref 

     

       114
       114
       -
             linkend='ex-option-declaration-eot-backend-slim' />, <xref 

     

       115
       115
       -
             linkend='ex-option-declaration-eot-backend-kdm' />).</para>

     

       116
       116
       -
        

     

       111
       111
       +
         <para>By using extensible option types, it is possible to create a placeholder

     

       112
       112
       +
           option in the central module (<xref linkend='ex-option-declaration-eot-service'

     

       113
       113
       +
             />), and to extend it in each backend module (<xref

     

       114
       114
       +
             linkend='ex-option-declaration-eot-backend-slim' />, <xref

     

       115
       115
       +
             linkend='ex-option-declaration-eot-backend-sddm' />).</para>

     

       116
       116
       +
       

     

       117
       117
        
         <para>As a result, <literal>displayManager.enable</literal> option values can

     

       118
       118
        
         be added without changing the main service module file and the type system

     

       119
       119
        
         automatically enforce that there can only be a single display manager

     

       120
       120
        
         enabled.</para>

     

       121
       121
        
       

     

       122
       122
       -
       <example xml:id='ex-option-declaration-eot-service'><title>Extensible type 

     

       122
       122
       +
       <example xml:id='ex-option-declaration-eot-service'><title>Extensible type

     

       123
       123
        
           placeholder in the service module</title>

     

       124
       124
        
       <screen>

     

       125
       125
        
       services.xserver.displayManager.enable = mkOption {

     
···

       127
       127
        
         type = with types; nullOr (enum [ ]);

     

       128
       128
        
       };</screen></example>

     

       129
       129
        
       

     

       130
       130
       -
       <example xml:id='ex-option-declaration-eot-backend-slim'><title>Extending 

     

       131
       131
       -
           <literal>services.xserver.displayManager.enable</literal> in the 

     

       130
       130
       +
       <example xml:id='ex-option-declaration-eot-backend-slim'><title>Extending

     

       131
       131
       +
           <literal>services.xserver.displayManager.enable</literal> in the

     

       132
       132
        
           <literal>slim</literal> module</title>

     

       133
       133
        
       <screen>

     

       134
       134
        
       services.xserver.displayManager.enable = mkOption {

     

       135
       135
        
         type = with types; nullOr (enum [ "slim" ]);

     

       136
       136
        
       };</screen></example>

     

       137
       137
        
       

     

       138
       138
       -
       <example xml:id='ex-option-declaration-eot-backend-kdm'><title>Extending 

     

       139
       139
       -
           <literal>services.foo.backend</literal> in the <literal>kdm</literal> 

     

       138
       138
       +
       <example xml:id='ex-option-declaration-eot-backend-sdm'><title>Extending

     

       139
       139
       +
           <literal>services.foo.backend</literal> in the <literal>sdm</literal>

     

       140
       140
        
           module</title>

     

       141
       141
        
       <screen>

     

       142
       142
        
       services.xserver.displayManager.enable = mkOption {

     

       143
       143
       -
         type = with types; nullOr (enum [ "kdm" ]);

     

       143
       143
       +
         type = with types; nullOr (enum [ "sddm" ]);

     

       144
       144
        
       };</screen></example>

     

       145
       145
        
       

     

       146
       146
       -
       <para>The placeholder declaration is a standard <literal>mkOption</literal> 

     

       147
       147
       -
         declaration, but it is important that extensible option declarations only use 

     

       146
       146
       +
       <para>The placeholder declaration is a standard <literal>mkOption</literal>

     

       147
       147
       +
         declaration, but it is important that extensible option declarations only use

     

       148
       148
        
         the <literal>type</literal> argument.</para>

     

       149
       149
        
       

     

       150
       150
       -
       <para>Extensible option types work with any of the composed variants of 

     

       151
       151
       -
         <literal>enum</literal> such as 

     

       152
       152
       -
         <literal>with types; nullOr (enum [ "foo" "bar" ])</literal> 

     

       150
       150
       +
       <para>Extensible option types work with any of the composed variants of

     

       151
       151
       +
         <literal>enum</literal> such as

     

       152
       152
       +
         <literal>with types; nullOr (enum [ "foo" "bar" ])</literal>

     

       153
       153
        
         or <literal>with types; listOf (enum [ "foo" "bar" ])</literal>.</para>

     

       154
       154
        
       

     

       155
       155
        
       </section>

+2 -2

nixos/modules/installer/tools/nixos-generate-config.pl

···

       607
       607
        
         # services.xserver.xkbOptions = "eurosign:e";

     

       608
       608
        
       

     

       609
       609
        
         # Enable the KDE Desktop Environment.

     

       610
       610
       -
         # services.xserver.displayManager.kdm.enable = true;

     

       611
       611
       -
         # services.xserver.desktopManager.kde4.enable = true;

     

       610
       610
       +
         # services.xserver.displayManager.sddm.enable = true;

     

       611
       611
       +
         # services.xserver.desktopManager.kde5.enable = true;

     

       612
       612
        
       

     

       613
       613
        
         # Define a user account. Don't forget to set a password with ‘passwd’.

     

       614
       614
        
         # users.extraUsers.guest = {

+2 -2

nixos/modules/profiles/graphical.nix

···

       6
       6
        
       {

     

       7
       7
        
         services.xserver = {

     

       8
       8
        
           enable = true;

     

       9
       9
       -
           displayManager.kdm.enable = true;

     

       10
       10
       -
           desktopManager.kde4.enable = true;

     

       9
       9
       +
           displayManager.sddm.enable = true;

     

       10
       10
       +
           desktopManager.kde5.enable = true;

     

       11
       11
        
           synaptics.enable = true; # for touchpad support on many laptops

     

       12
       12
        
         };

     

       13
       13

+1 -1

nixos/modules/services/hardware/bluetooth.nix

···

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         ###### implementation

     

       25
       25
       -
         

     

       25
       25
       +
       

     

       26
       26
        
         config = mkIf config.hardware.bluetooth.enable {

     

       27
       27
        
       

     

       28
       28
        
           environment.systemPackages = [ bluez-bluetooth pkgs.openobex pkgs.obexftp ];

+1 -1

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

···

       1
       1
        
       # This module declares the options to define a *display manager*, the

     

       2
       2
       -
       # program responsible for handling X logins (such as xdm, kdm, gdb, or

     

       2
       2
       +
       # program responsible for handling X logins (such as xdm, gdb, or

     

       3
       3
        
       # SLiM).  The display manager allows the user to select a *session

     

       4
       4
        
       # type*.  When the user logs in, the display manager starts the

     

       5
       5
        
       # *session script* ("xsession" below) to launch the selected session

+2 -12

nixos/modules/services/x11/terminal-server.nix

···

       16
       16
        
           services.xserver.enable = true;

     

       17
       17
        
           services.xserver.videoDrivers = [];

     

       18
       18
        
       

     

       19
       19
       -
           # Enable KDM.  Any display manager will do as long as it supports XDMCP.

     

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

     

       21
       21
       -
           services.xserver.displayManager.kdm.enableXDMCP = true;

     

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

     

       23
       23
       -
             ''

     

       24
       24
       -
               [General]

     

       25
       25
       -
               # We're headless, so don't bother starting an X server.

     

       26
       26
       -
               StaticServers=

     

       27
       27
       -
       

     

       28
       28
       -
               [Xdmcp]

     

       29
       29
       -
               Xaccess=${pkgs.writeText "Xaccess" "localhost"}

     

       30
       30
       -
             '';

     

       19
       19
       +
           # Enable GDM.  Any display manager will do as long as it supports XDMCP.

     

       20
       20
       +
           services.xserver.displayManager.gdm.enable = true;

     

       31
       21
        
       

     

       32
       22
        
           systemd.sockets.terminal-server =

     

       33
       23
        
             { description = "Terminal Server Socket";

+2 -2

nixos/release.nix

···

       325
       325
        
       

     

       326
       326
        
           kde = makeClosure ({ pkgs, ... }:

     

       327
       327
        
             { services.xserver.enable = true;

     

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

     

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

     

       328
       328
       +
               services.xserver.displayManager.sddm.enable = true;

     

       329
       329
       +
               services.xserver.desktopManager.kde5.enable = true;

     

       330
       330
        
             });

     

       331
       331
        
       

     

       332
       332
        
           xfce = makeClosure ({ pkgs, ... }:

+1 -1

nixos/tests/phabricator.nix

···

       54
       54
        
           client =

     

       55
       55
        
             { config, pkgs, ... }:

     

       56
       56
        
             { imports = [ ./common/x11.nix ];

     

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

     

       57
       57
       +
               services.xserver.desktopManager.kde5.enable = true;

     

       58
       58
        
             };

     

       59
       59
        
         };

     

       60
       60

+1 -1

nixos/tests/trac.nix

···

       45
       45
        
           client =

     

       46
       46
        
             { config, pkgs, ... }:

     

       47
       47
        
             { imports = [ ./common/x11.nix ];

     

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

     

       48
       48
       +
               services.xserver.desktopManager.kde5.enable = true;

     

       49
       49
        
             };

     

       50
       50
        
         };

     

       51
       51