ghostfox/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

push sheeet
Some checks failed
Periodic Merges (6h) / master → staging-nixos (push) Failing after 12m50s
Details
Periodic Merges (6h) / master → staging-next (push) Failing after 12m54s
Details
Periodic Merges (24h) / merge-base(master,staging) → haskell-updates (push) Failing after 11m54s
Details
Periodic Merges (6h) / staging-next → staging (push) Failing after 12m13s
Details
Periodic Merges (24h) / staging-next-25.05 → staging-25.05 (push) Failing after 13m24s
Details
Periodic Merges (24h) / release-25.05 → staging-next-25.05 (push) Failing after 14m28s
Details

Browse Source
This commit is contained in:
Dark Steveneq
2025-10-09 14:15:47 +02:00
commit 646b892680
49168 changed files with 5897842 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
nixos/modules/services/x11/display-managers/account-service-util.nix Normal file
View File

@@ -0,0 +1,45 @@
{
accountsservice,
glib,
gobject-introspection,
python3,
wrapGAppsNoGuiHook,
lib,
}:
python3.pkgs.buildPythonApplication {
name = "set-session";
format = "other";
src = ./set-session.py;
dontUnpack = true;
strictDeps = false;
nativeBuildInputs = [
wrapGAppsNoGuiHook
gobject-introspection
];
buildInputs = [
accountsservice
glib
];
propagatedBuildInputs = with python3.pkgs; [
pygobject3
ordered-set
];
installPhase = ''
mkdir -p $out/bin
cp $src $out/bin/set-session
chmod +x $out/bin/set-session
'';
meta = with lib; {
maintainers = with maintainers; [ ] ++ teams.pantheon.members;
};
}

357
nixos/modules/services/x11/display-managers/default.nix Normal file
View File

@@ -0,0 +1,357 @@
# This module declares the options to define a *display manager*, the
# program responsible for handling X logins (such as LightDM, GDM, or SDDM).
# The display manager allows the user to select a *session
# type*. When the user logs in, the display manager starts the
# *session script* ("xsession" below) to launch the selected session
# type. The session type defines two things: the *desktop manager*
# (e.g., KDE, Gnome or a plain xterm), and optionally the *window
# manager* (e.g. kwin or twm).
{
config,
lib,
options,
pkgs,
...
}:
let
inherit (lib)
mkOption
types
literalExpression
optionalString
;
cfg = config.services.xserver;
xorg = pkgs.xorg;
fontconfig = config.fonts.fontconfig;
xresourcesXft = pkgs.writeText "Xresources-Xft" ''
Xft.antialias: ${if fontconfig.antialias then "1" else "0"}
Xft.rgba: ${fontconfig.subpixel.rgba}
Xft.lcdfilter: lcd${fontconfig.subpixel.lcdfilter}
Xft.hinting: ${if fontconfig.hinting.enable then "1" else "0"}
Xft.autohint: ${if fontconfig.hinting.autohint then "1" else "0"}
Xft.hintstyle: ${fontconfig.hinting.style}
'';
# FIXME: this is an ugly hack.
# Some sessions (read: most WMs) don't activate systemd's `graphical-session.target`.
# Other sessions (read: most non-WMs) expect `graphical-session.target` to be reached
# when the entire session is actually ready. We used to just unconditionally force
# `graphical-session.target` to be activated in the session wrapper so things like
# xdg-autostart-generator work on sessions that are wrong, but this broke sessions
# that do things right. So, preserve this behavior (with some extra steps) by matching
# on XDG_CURRENT_DESKTOP and deliberately ignoring sessions we know can do the right thing.
fakeSession = action: ''
session_is_systemd_aware=$(
IFS=:
for i in $XDG_CURRENT_DESKTOP; do
case $i in
KDE|GNOME|Pantheon|X-NIXOS-SYSTEMD-AWARE) echo "1"; exit; ;;
*) ;;
esac
done
)
if [ -z "$session_is_systemd_aware" ]; then
/run/current-system/systemd/bin/systemctl --user ${action} nixos-fake-graphical-session.target
fi
'';
# file provided by services.xserver.displayManager.sessionData.wrapper
xsessionWrapper = pkgs.writeScript "xsession-wrapper" ''
#! ${pkgs.bash}/bin/bash
# Shared environment setup for graphical sessions.
. /etc/profile
if test -f ~/.profile; then
source ~/.profile
fi
cd "$HOME"
# Allow the user to execute commands at the beginning of the X session.
if test -f ~/.xprofile; then
source ~/.xprofile
fi
${optionalString config.services.displayManager.logToJournal ''
if [ -z "$_DID_SYSTEMD_CAT" ]; then
export _DID_SYSTEMD_CAT=1
exec ${config.systemd.package}/bin/systemd-cat -t xsession "$0" "$@"
fi
''}
${optionalString config.services.displayManager.logToFile ''
exec &> >(tee ~/.xsession-errors)
''}
# Load X defaults. This should probably be safe on wayland too.
${xorg.xrdb}/bin/xrdb -merge ${xresourcesXft}
if test -e ~/.Xresources; then
${xorg.xrdb}/bin/xrdb -merge ~/.Xresources
elif test -e ~/.Xdefaults; then
${xorg.xrdb}/bin/xrdb -merge ~/.Xdefaults
fi
# Import environment variables into the systemd user environment.
${optionalString (cfg.displayManager.importedVariables != [ ]) (
"/run/current-system/systemd/bin/systemctl --user import-environment "
+ toString (lib.unique cfg.displayManager.importedVariables)
)}
# Speed up application start by 50-150ms according to
# https://kdemonkey.blogspot.com/2008/04/magic-trick.html
compose_cache="''${XCOMPOSECACHE:-$HOME/.compose-cache}"
mkdir -p "$compose_cache"
# To avoid accidentally deleting a wrongly set up XCOMPOSECACHE directory,
# defensively try to delete cache *files* only, following the file format specified in
# https://gitlab.freedesktop.org/xorg/lib/libx11/-/blob/master/modules/im/ximcp/imLcIm.c#L353-358
# sprintf (*res, "%s/%c%d_%03x_%08x_%08x", dir, _XimGetMyEndian(), XIM_CACHE_VERSION, (unsigned int)sizeof (DefTree), hash, hash2);
${pkgs.findutils}/bin/find "$compose_cache" -maxdepth 1 -regextype posix-extended -regex '.*/[Bl][0-9]+_[0-9a-f]{3}_[0-9a-f]{8}_[0-9a-f]{8}' -delete
unset compose_cache
# Work around KDE errors when a user first logs in and
# .local/share doesn't exist yet.
mkdir -p "''${XDG_DATA_HOME:-$HOME/.local/share}"
unset _DID_SYSTEMD_CAT
${cfg.displayManager.sessionCommands}
${fakeSession "start"}
# Allow the user to setup a custom session type.
if test -x ~/.xsession; then
eval exec ~/.xsession "$@"
fi
if test "$1"; then
# Run the supplied session command. Remove any double quotes with eval.
eval exec "$@"
else
# TODO: Do we need this? Should not the session always exist?
echo "error: unknown session $1" 1>&2
exit 1
fi
'';
in
{
options = {
services.xserver.displayManager = {
xauthBin = mkOption {
internal = true;
default = "${xorg.xauth}/bin/xauth";
defaultText = literalExpression ''"''${pkgs.xorg.xauth}/bin/xauth"'';
description = "Path to the {command}`xauth` program used by display managers.";
};
xserverBin = mkOption {
type = types.path;
description = "Path to the X server used by display managers.";
};
xserverArgs = mkOption {
type = types.listOf types.str;
default = [ ];
example = [
"-ac"
"-logverbose"
"-verbose"
"-nolisten tcp"
];
description = "List of arguments for the X server.";
};
setupCommands = mkOption {
type = types.lines;
default = "";
description = ''
Shell commands executed just after the X server has started.
This option is only effective for display managers for which this feature
is supported; currently these are LightDM, GDM and SDDM.
'';
};
sessionCommands = mkOption {
type = types.lines;
default = "";
example = ''
xmessage "Hello World!" &
'';
description = ''
Shell commands executed just before the window or desktop manager is
started. These commands are not currently sourced for Wayland sessions.
'';
};
session = mkOption {
default = [ ];
type = types.listOf types.attrs;
example = literalExpression ''
[ { manage = "desktop";
name = "xterm";
start = '''
''${pkgs.xterm}/bin/xterm -ls &
waitPID=$!
''';
}
]
'';
description = ''
List of sessions supported with the command used to start each
session. Each session script can set the
{var}`waitPID` shell variable to make this script
wait until the end of the user session. Each script is used
to define either a window manager or a desktop manager. These
can be differentiated by setting the attribute
{var}`manage` either to `"window"`
or `"desktop"`.
The list of desktop manager and window manager should appear
inside the display manager with the desktop manager name
followed by the window manager name.
'';
};
importedVariables = mkOption {
type = types.listOf (types.strMatching "[a-zA-Z_][a-zA-Z0-9_]*");
visible = false;
description = ''
Environment variables to import into the systemd user environment.
'';
};
};
};
config = {
services.displayManager.sessionData.wrapper = xsessionWrapper;
services.xserver.displayManager.xserverBin = "${xorg.xorgserver.out}/bin/X";
services.xserver.displayManager.importedVariables = [
# This is required by user units using the session bus.
"DBUS_SESSION_BUS_ADDRESS"
# These are needed by the ssh-agent unit.
"DISPLAY"
"XAUTHORITY"
# This is required to specify session within user units (e.g. loginctl lock-session).
"XDG_SESSION_ID"
];
systemd.user.targets.nixos-fake-graphical-session = {
unitConfig = {
Description = "Fake graphical-session target for non-systemd-aware sessions";
BindsTo = "graphical-session.target";
};
};
# Create desktop files and scripts for starting sessions for WMs/DMs
# that do not have upstream session files (those defined using services.{display,desktop,window}Manager.session options).
services.displayManager.sessionPackages =
let
dms = lib.filter (s: s.manage == "desktop") cfg.displayManager.session;
wms = lib.filter (s: s.manage == "window") cfg.displayManager.session;
# Script responsible for starting the window manager and the desktop manager.
xsession =
dm: wm:
pkgs.writeScript "xsession" ''
#! ${pkgs.bash}/bin/bash
# Legacy session script used to construct .desktop files from
# `services.xserver.displayManager.session` entries. Called from
# `sessionWrapper`.
# Start the window manager.
${wm.start}
# Start the desktop manager.
${dm.start}
${optionalString cfg.updateDbusEnvironment ''
${lib.getBin pkgs.dbus}/bin/dbus-update-activation-environment --systemd --all
''}
test -n "$waitPID" && wait "$waitPID"
${fakeSession "stop"}
exit 0
'';
in
# We will generate every possible pair of WM and DM.
lib.concatLists (
lib.mapCartesianProduct
(
{ dm, wm }:
let
sessionName = "${dm.name}${optionalString (wm.name != "none") ("+" + wm.name)}";
prettyName =
if dm.name != "none" then
"${dm.prettyName or dm.name}${
optionalString (wm.name != "none") (" (" + (wm.prettyName or wm.name) + ")")
}"
else
(wm.prettyName or wm.name);
script = xsession dm wm;
desktopNames = if dm ? desktopNames then lib.concatStringsSep ";" dm.desktopNames else sessionName;
in
lib.optional (dm.name != "none" || wm.name != "none") (
pkgs.writeTextFile {
name = "${sessionName}-xsession";
destination = "/share/xsessions/${sessionName}.desktop";
# Desktop Entry Specification:
# - https://standards.freedesktop.org/desktop-entry-spec/latest/
# - https://standards.freedesktop.org/desktop-entry-spec/latest/ar01s06.html
text = ''
[Desktop Entry]
Version=1.0
Type=XSession
TryExec=${script}
Exec=${script}
Name=${prettyName}
DesktopNames=${desktopNames}
'';
}
// {
providedSessions = [ sessionName ];
}
)
)
{
dm = dms;
wm = wms;
}
);
};
imports = [
(lib.mkRemovedOptionModule
[ "services" "xserver" "displayManager" "desktopManagerHandlesLidAndPower" ]
"The option is no longer necessary because all display managers have already delegated lid management to systemd."
)
(lib.mkRenamedOptionModule
[ "services" "xserver" "displayManager" "job" "logsXsession" ]
[ "services" "displayManager" "logToFile" ]
)
(lib.mkRenamedOptionModule
[ "services" "xserver" "displayManager" "logToJournal" ]
[ "services" "displayManager" "logToJournal" ]
)
(lib.mkRenamedOptionModule
[ "services" "xserver" "displayManager" "extraSessionFilesPackages" ]
[ "services" "displayManager" "sessionPackages" ]
)
];
}

122
nixos/modules/services/x11/display-managers/lightdm-greeters/enso-os.nix Normal file
View File

@@ -0,0 +1,122 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
dmcfg = config.services.xserver.displayManager;
ldmcfg = dmcfg.lightdm;
cfg = ldmcfg.greeters.enso;
theme = cfg.theme.package;
icons = cfg.iconTheme.package;
cursors = cfg.cursorTheme.package;
ensoGreeterConf = pkgs.writeText "lightdm-enso-os-greeter.conf" ''
[greeter]
default-wallpaper=${ldmcfg.background}
gtk-theme=${cfg.theme.name}
icon-theme=${cfg.iconTheme.name}
cursor-theme=${cfg.cursorTheme.name}
blur=${toString cfg.blur}
brightness=${toString cfg.brightness}
${cfg.extraConfig}
'';
in
{
options = {
services.xserver.displayManager.lightdm.greeters.enso = {
enable = mkOption {
type = types.bool;
default = false;
description = ''
Whether to enable enso-os-greeter as the lightdm greeter
'';
};
theme = {
package = mkPackageOption pkgs "gnome-themes-extra" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the theme to use for the lightdm-enso-os-greeter
'';
};
};
iconTheme = {
package = mkPackageOption pkgs "papirus-icon-theme" { };
name = mkOption {
type = types.str;
default = "ePapirus";
description = ''
Name of the icon theme to use for the lightdm-enso-os-greeter
'';
};
};
cursorTheme = {
package = mkPackageOption pkgs "capitaine-cursors" { };
name = mkOption {
type = types.str;
default = "capitane-cursors";
description = ''
Name of the cursor theme to use for the lightdm-enso-os-greeter
'';
};
};
blur = mkOption {
type = types.bool;
default = false;
description = ''
Whether or not to enable blur
'';
};
brightness = mkOption {
type = types.int;
default = 7;
description = ''
Brightness
'';
};
extraConfig = mkOption {
type = types.lines;
default = "";
description = ''
Extra configuration that should be put in the greeter.conf
configuration file
'';
};
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
environment.etc."lightdm/greeter.conf".source = ensoGreeterConf;
environment.systemPackages = [
cursors
icons
theme
];
services.xserver.displayManager.lightdm = {
greeter = mkDefault {
package = pkgs.lightdm-enso-os-greeter.xgreeters;
name = "pantheon-greeter";
};
greeters = {
gtk = {
enable = mkDefault false;
};
};
};
};
}

166
nixos/modules/services/x11/display-managers/lightdm-greeters/gtk.nix Normal file
View File

@@ -0,0 +1,166 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
dmcfg = config.services.xserver.displayManager;
ldmcfg = dmcfg.lightdm;
xcfg = config.services.xserver;
cfg = ldmcfg.greeters.gtk;
inherit (pkgs) writeText;
theme = cfg.theme.package;
icons = cfg.iconTheme.package;
cursors = cfg.cursorTheme.package;
gtkGreeterConf = writeText "lightdm-gtk-greeter.conf" ''
[greeter]
theme-name = ${cfg.theme.name}
icon-theme-name = ${cfg.iconTheme.name}
cursor-theme-name = ${cfg.cursorTheme.name}
cursor-theme-size = ${toString cfg.cursorTheme.size}
background = ${ldmcfg.background}
${optionalString (cfg.clock-format != null) "clock-format = ${cfg.clock-format}"}
${optionalString (cfg.indicators != null) "indicators = ${concatStringsSep ";" cfg.indicators}"}
${optionalString (xcfg.dpi != null) "xft-dpi=${toString xcfg.dpi}"}
${cfg.extraConfig}
'';
in
{
options = {
services.xserver.displayManager.lightdm.greeters.gtk = {
enable = mkOption {
type = types.bool;
default = true;
description = ''
Whether to enable lightdm-gtk-greeter as the lightdm greeter.
'';
};
theme = {
package = mkPackageOption pkgs "gnome-themes-extra" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the theme to use for the lightdm-gtk-greeter.
'';
};
};
iconTheme = {
package = mkPackageOption pkgs "adwaita-icon-theme" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the icon theme to use for the lightdm-gtk-greeter.
'';
};
};
cursorTheme = {
package = mkPackageOption pkgs "adwaita-icon-theme" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the cursor theme to use for the lightdm-gtk-greeter.
'';
};
size = mkOption {
type = types.int;
default = 16;
description = ''
Size of the cursor theme to use for the lightdm-gtk-greeter.
'';
};
};
clock-format = mkOption {
type = types.nullOr types.str;
default = null;
example = "%F";
description = ''
Clock format string (as expected by strftime, e.g. "%H:%M")
to use with the lightdm gtk greeter panel.
If set to null the default clock format is used.
'';
};
indicators = mkOption {
type = types.nullOr (types.listOf types.str);
default = null;
example = [
"~host"
"~spacer"
"~clock"
"~spacer"
"~session"
"~language"
"~a11y"
"~power"
];
description = ''
List of allowed indicator modules to use for the lightdm gtk
greeter panel.
Built-in indicators include "~a11y", "~language", "~session",
"~power", "~clock", "~host", "~spacer". Unity indicators can be
represented by short name (e.g. "sound", "power"), service file name,
or absolute path.
If set to null the default indicators are used.
'';
};
extraConfig = mkOption {
type = types.lines;
default = "";
description = ''
Extra configuration that should be put in the lightdm-gtk-greeter.conf
configuration file.
'';
};
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
services.xserver.displayManager.lightdm.greeter = mkDefault {
package = pkgs.lightdm-gtk-greeter.xgreeters;
name = "lightdm-gtk-greeter";
};
environment.systemPackages = [
cursors
icons
theme
];
environment.etc."lightdm/lightdm-gtk-greeter.conf".source = gtkGreeterConf;
};
}

42
nixos/modules/services/x11/display-managers/lightdm-greeters/lomiri.nix Normal file
View File

@@ -0,0 +1,42 @@
{
config,
lib,
pkgs,
...
}:
let
dmcfg = config.services.displayManager;
ldmcfg = config.services.xserver.displayManager.lightdm;
cfg = ldmcfg.greeters.lomiri;
in
{
meta.maintainers = lib.teams.lomiri.members;
options = {
services.xserver.displayManager.lightdm.greeters.lomiri = {
enable = lib.mkEnableOption "lomiri's greeter as the lightdm greeter";
};
};
config = lib.mkIf (ldmcfg.enable && cfg.enable) {
# Lomiri greeter == Lomiri shell in special mode, need some basics setup at least
services.desktopManager.lomiri.basics = true;
services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
services.xserver.displayManager.lightdm.greeter = lib.mkDefault {
package = pkgs.lomiri.lomiri.greeter;
name = "lomiri-greeter";
};
# Greeter needs to be run through its wrapper
# Greeter doesn't work with our set-session.py script, need to set default user-session
services.xserver.displayManager.lightdm.extraSeatDefaults = ''
greeter-wrapper = ${lib.getExe' pkgs.lomiri.lomiri "lomiri-greeter-wrapper"}
user-session = ${dmcfg.defaultSession}
'';
};
}

104
nixos/modules/services/x11/display-managers/lightdm-greeters/mini.nix Normal file
View File

@@ -0,0 +1,104 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
dmcfg = config.services.xserver.displayManager;
ldmcfg = dmcfg.lightdm;
cfg = ldmcfg.greeters.mini;
miniGreeterConf = pkgs.writeText "lightdm-mini-greeter.conf" ''
[greeter]
user = ${cfg.user}
show-password-label = true
password-label-text = Password:
invalid-password-text = Invalid Password
show-input-cursor = true
password-alignment = right
[greeter-hotkeys]
mod-key = meta
shutdown-key = s
restart-key = r
hibernate-key = h
suspend-key = u
[greeter-theme]
font = Sans
font-size = 1em
font-weight = bold
font-style = normal
text-color = "#080800"
error-color = "#F8F8F0"
background-image = "${ldmcfg.background}"
background-color = "#1B1D1E"
window-color = "#F92672"
border-color = "#080800"
border-width = 2px
layout-space = 15
password-color = "#F8F8F0"
password-background-color = "#1B1D1E"
password-border-color = "#080800"
password-border-width = 2px
${cfg.extraConfig}
'';
in
{
options = {
services.xserver.displayManager.lightdm.greeters.mini = {
enable = mkOption {
type = types.bool;
default = false;
description = ''
Whether to enable lightdm-mini-greeter as the lightdm greeter.
Note that this greeter starts only the default X session.
You can configure the default X session using
[](#opt-services.displayManager.defaultSession).
'';
};
user = mkOption {
type = types.str;
default = "root";
description = ''
The user to login as.
'';
};
extraConfig = mkOption {
type = types.lines;
default = "";
description = ''
Extra configuration that should be put in the lightdm-mini-greeter.conf
configuration file.
'';
};
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
services.xserver.displayManager.lightdm.greeter = mkDefault {
package = pkgs.lightdm-mini-greeter.xgreeters;
name = "lightdm-mini-greeter";
};
environment.etc."lightdm/lightdm-mini-greeter.conf".source = miniGreeterConf;
};
}

29
nixos/modules/services/x11/display-managers/lightdm-greeters/mobile.nix Normal file
View File

@@ -0,0 +1,29 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
dmcfg = config.services.xserver.displayManager;
ldmcfg = dmcfg.lightdm;
cfg = ldmcfg.greeters.mobile;
in
{
options = {
services.xserver.displayManager.lightdm.greeters.mobile = {
enable = mkEnableOption "lightdm-mobile-greeter as the lightdm greeter";
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
services.xserver.displayManager.lightdm.greeter = mkDefault {
package = pkgs.lightdm-mobile-greeter.xgreeters;
name = "lightdm-mobile-greeter";
};
};
}

56
nixos/modules/services/x11/display-managers/lightdm-greeters/pantheon.nix Normal file
View File

@@ -0,0 +1,56 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
dmcfg = config.services.xserver.displayManager;
ldmcfg = dmcfg.lightdm;
cfg = ldmcfg.greeters.pantheon;
in
{
meta = with lib; {
maintainers = with maintainers; [ ] ++ teams.pantheon.members;
};
options = {
services.xserver.displayManager.lightdm.greeters.pantheon = {
enable = mkOption {
type = types.bool;
default = false;
description = ''
Whether to enable elementary-greeter as the lightdm greeter.
'';
};
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
services.xserver.displayManager.lightdm.greeter = mkDefault {
package = pkgs.pantheon.elementary-greeter.xgreeters;
name = "io.elementary.greeter";
};
# Show manual login card.
services.xserver.displayManager.lightdm.extraSeatDefaults = "greeter-show-manual-login=true";
environment.etc."lightdm/io.elementary.greeter.conf".source =
"${pkgs.pantheon.elementary-greeter}/etc/lightdm/io.elementary.greeter.conf";
environment.etc."wingpanel.d/io.elementary.greeter.allowed".source =
"${pkgs.pantheon.elementary-default-settings}/etc/wingpanel.d/io.elementary.greeter.allowed";
};
}

126
nixos/modules/services/x11/display-managers/lightdm-greeters/slick.nix Normal file
View File

@@ -0,0 +1,126 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
ldmcfg = config.services.xserver.displayManager.lightdm;
cfg = ldmcfg.greeters.slick;
inherit (pkgs) writeText;
theme = cfg.theme.package;
icons = cfg.iconTheme.package;
font = cfg.font.package;
cursors = cfg.cursorTheme.package;
slickGreeterConf = writeText "slick-greeter.conf" ''
[Greeter]
background=${ldmcfg.background}
theme-name=${cfg.theme.name}
icon-theme-name=${cfg.iconTheme.name}
font-name=${cfg.font.name}
cursor-theme-name=${cfg.cursorTheme.name}
cursor-theme-size=${toString cfg.cursorTheme.size}
draw-user-backgrounds=${boolToString cfg.draw-user-backgrounds}
${cfg.extraConfig}
'';
in
{
options = {
services.xserver.displayManager.lightdm.greeters.slick = {
enable = mkEnableOption "lightdm-slick-greeter as the lightdm greeter";
theme = {
package = mkPackageOption pkgs "gnome-themes-extra" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the theme to use for the lightdm-slick-greeter.
'';
};
};
iconTheme = {
package = mkPackageOption pkgs "adwaita-icon-theme" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the icon theme to use for the lightdm-slick-greeter.
'';
};
};
font = {
package = mkPackageOption pkgs "ubuntu-classic" { };
name = mkOption {
type = types.str;
default = "Ubuntu 11";
description = ''
Name of the font to use.
'';
};
};
cursorTheme = {
package = mkPackageOption pkgs "adwaita-icon-theme" { };
name = mkOption {
type = types.str;
default = "Adwaita";
description = ''
Name of the cursor theme to use for the lightdm-slick-greeter.
'';
};
size = mkOption {
type = types.int;
default = 24;
description = ''
Size of the cursor theme to use for the lightdm-slick-greeter.
'';
};
};
draw-user-backgrounds = mkEnableOption "draw user backgrounds";
extraConfig = mkOption {
type = types.lines;
default = "";
description = ''
Extra configuration that should be put in the lightdm-slick-greeter.conf
configuration file.
'';
};
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
services.xserver.displayManager.lightdm = {
greeters.gtk.enable = false;
greeter = mkDefault {
package = pkgs.lightdm-slick-greeter.xgreeters;
name = "lightdm-slick-greeter";
};
};
environment.systemPackages = [
cursors
icons
theme
];
fonts.packages = [ font ];
environment.etc."lightdm/slick-greeter.conf".source = slickGreeterConf;
};
}

94
nixos/modules/services/x11/display-managers/lightdm-greeters/tiny.nix Normal file
View File

@@ -0,0 +1,94 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
dmcfg = config.services.xserver.displayManager;
ldmcfg = dmcfg.lightdm;
cfg = ldmcfg.greeters.tiny;
in
{
options = {
services.xserver.displayManager.lightdm.greeters.tiny = {
enable = mkOption {
type = types.bool;
default = false;
description = ''
Whether to enable lightdm-tiny-greeter as the lightdm greeter.
Note that this greeter starts only the default X session.
You can configure the default X session using
[](#opt-services.displayManager.defaultSession).
'';
};
label = {
user = mkOption {
type = types.str;
default = "Username";
description = ''
The string to represent the user_text label.
'';
};
pass = mkOption {
type = types.str;
default = "Password";
description = ''
The string to represent the pass_text label.
'';
};
};
extraConfig = mkOption {
type = types.lines;
default = "";
description = ''
Section to describe style and ui.
'';
};
};
};
config = mkIf (ldmcfg.enable && cfg.enable) {
services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
services.xserver.displayManager.lightdm.greeter =
let
configHeader = ''
#include <gtk/gtk.h>
static const char *user_text = "${cfg.label.user}";
static const char *pass_text = "${cfg.label.pass}";
static const char *session = "${dmcfg.defaultSession}";
'';
config = optionalString (cfg.extraConfig != "") (configHeader + cfg.extraConfig);
package = pkgs.lightdm-tiny-greeter.override { conf = config; };
in
mkDefault {
package = package.xgreeters;
name = "lightdm-tiny-greeter";
};
assertions = [
{
assertion = dmcfg.defaultSession != null;
message = ''
Please set: services.displayManager.defaultSession
'';
}
];
};
}

334
nixos/modules/services/x11/display-managers/lightdm.nix Normal file
View File

@@ -0,0 +1,334 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
xcfg = config.services.xserver;
dmcfg = config.services.displayManager;
xEnv = config.systemd.services.display-manager.environment;
cfg = xcfg.displayManager.lightdm;
sessionData = dmcfg.sessionData;
setSessionScript = pkgs.callPackage ./account-service-util.nix { };
inherit (pkgs) lightdm writeScript writeText;
# lightdm runs with clearenv(), but we need a few things in the environment for X to startup
xserverWrapper = writeScript "xserver-wrapper" ''
#! ${pkgs.bash}/bin/bash
${concatMapStrings (n: "export ${n}=\"${getAttr n xEnv}\"\n") (attrNames xEnv)}
display=$(echo "$@" | xargs -n 1 | grep -P ^:\\d\$ | head -n 1 | sed s/^://)
if [ -z "$display" ]
then additionalArgs=":0 -logfile /var/log/X.0.log"
else additionalArgs="-logfile /var/log/X.$display.log"
fi
exec ${xcfg.displayManager.xserverBin} ${toString xcfg.displayManager.xserverArgs} $additionalArgs "$@"
'';
usersConf = writeText "users.conf" ''
[UserList]
minimum-uid=1000
hidden-users=${concatStringsSep " " dmcfg.hiddenUsers}
hidden-shells=/run/current-system/sw/bin/nologin
'';
lightdmConf = writeText "lightdm.conf" ''
[LightDM]
minimum-vt = 1
${optionalString cfg.greeter.enable ''
greeter-user = ${config.users.users.lightdm.name}
greeters-directory = ${cfg.greeter.package}
''}
sessions-directory = ${dmcfg.sessionData.desktops}/share/xsessions:${dmcfg.sessionData.desktops}/share/wayland-sessions
${cfg.extraConfig}
[Seat:*]
xserver-command = ${xserverWrapper}
session-wrapper = ${dmcfg.sessionData.wrapper}
${optionalString cfg.greeter.enable ''
greeter-session = ${cfg.greeter.name}
''}
${optionalString dmcfg.autoLogin.enable ''
autologin-user = ${dmcfg.autoLogin.user}
autologin-user-timeout = ${toString cfg.autoLogin.timeout}
autologin-session = ${sessionData.autologinSession}
''}
${optionalString (xcfg.displayManager.setupCommands != "") ''
display-setup-script=${pkgs.writeScript "lightdm-display-setup" ''
#!${pkgs.bash}/bin/bash
${xcfg.displayManager.setupCommands}
''}
''}
${cfg.extraSeatDefaults}
'';
in
{
meta = with lib; {
maintainers = with maintainers; [ ] ++ teams.pantheon.members;
};
# Note: the order in which lightdm greeter modules are imported
# here determines the default: later modules (if enable) are
# preferred.
imports = [
./lightdm-greeters/gtk.nix
./lightdm-greeters/mini.nix
./lightdm-greeters/enso-os.nix
./lightdm-greeters/pantheon.nix
./lightdm-greeters/lomiri.nix
./lightdm-greeters/tiny.nix
./lightdm-greeters/slick.nix
./lightdm-greeters/mobile.nix
(mkRenamedOptionModule
[ "services" "xserver" "displayManager" "lightdm" "autoLogin" "enable" ]
[
"services"
"displayManager"
"autoLogin"
"enable"
]
)
(mkRenamedOptionModule
[ "services" "xserver" "displayManager" "lightdm" "autoLogin" "user" ]
[
"services"
"displayManager"
"autoLogin"
"user"
]
)
];
options = {
services.xserver.displayManager.lightdm = {
enable = mkOption {
type = types.bool;
default = false;
description = ''
Whether to enable lightdm as the display manager.
'';
};
greeter = {
enable = mkOption {
type = types.bool;
default = true;
description = ''
If set to false, run lightdm in greeterless mode. This only works if autologin
is enabled and autoLogin.timeout is zero.
'';
};
package = mkOption {
type = types.package;
description = ''
The LightDM greeter to login via. The package should be a directory
containing a .desktop file matching the name in the 'name' option.
'';
};
name = mkOption {
type = types.str;
description = ''
The name of a .desktop file in the directory specified
in the 'package' option.
'';
};
};
extraConfig = mkOption {
type = types.lines;
default = "";
example = ''
user-authority-in-system-dir = true
'';
description = "Extra lines to append to LightDM section.";
};
background = mkOption {
type = types.either types.path (types.strMatching "^#[0-9]{6}$");
# Manual cannot depend on packages, we are actually setting the default in config below.
defaultText = literalExpression "pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath";
description = ''
The background image or color to use.
'';
};
extraSeatDefaults = mkOption {
type = types.lines;
default = "";
example = ''
greeter-show-manual-login=true
'';
description = "Extra lines to append to SeatDefaults section.";
};
# Configuration for automatic login specific to LightDM
autoLogin.timeout = mkOption {
type = types.int;
default = 0;
description = ''
Show the greeter for this many seconds before automatic login occurs.
'';
};
};
};
config = mkIf cfg.enable {
assertions = [
{
assertion = xcfg.enable;
message = ''
LightDM requires services.xserver.enable to be true
'';
}
{
assertion = dmcfg.autoLogin.enable -> sessionData.autologinSession != null;
message = ''
LightDM auto-login requires that services.displayManager.defaultSession is set.
'';
}
{
assertion = !cfg.greeter.enable -> (dmcfg.autoLogin.enable && cfg.autoLogin.timeout == 0);
message = ''
LightDM can only run without greeter if automatic login is enabled and the timeout for it
is set to zero.
'';
}
];
# Keep in sync with the defaultText value from the option definition.
services.xserver.displayManager.lightdm.background =
mkDefault pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath;
# Set default session in session chooser to a specified values – basically ignore session history.
# Auto-login is already covered by a config value.
services.displayManager.preStart =
optionalString (!dmcfg.autoLogin.enable && dmcfg.defaultSession != null)
''
${setSessionScript}/bin/set-session ${dmcfg.defaultSession}
'';
# setSessionScript needs session-files in XDG_DATA_DIRS
services.displayManager.environment.XDG_DATA_DIRS = "${dmcfg.sessionData.desktops}/share/";
# setSessionScript wants AccountsService
systemd.services.display-manager.wants = [
"accounts-daemon.service"
];
# lightdm relaunches itself via just `lightdm`, so needs to be on the PATH
services.displayManager.execCmd = ''
export PATH=${lightdm}/sbin:$PATH
exec ${lightdm}/sbin/lightdm
'';
# Pull in dependencies of services we replace.
systemd.services.display-manager.after = [
"rc-local.service"
"systemd-machined.service"
"systemd-user-sessions.service"
"user.slice"
];
# user.slice needs to be present
systemd.services.display-manager.requires = [
"user.slice"
];
# lightdm stops plymouth so when it fails make sure plymouth stops.
systemd.services.display-manager.onFailure = [
"plymouth-quit.service"
];
systemd.services.display-manager.serviceConfig = {
BusName = "org.freedesktop.DisplayManager";
IgnoreSIGPIPE = "no";
# This allows lightdm to pass the LUKS password through to PAM.
# login keyring is unlocked automatic when autologin is used.
KeyringMode = "shared";
KillMode = "mixed";
StandardError = "inherit";
};
environment.etc."lightdm/lightdm.conf".source = lightdmConf;
environment.etc."lightdm/users.conf".source = usersConf;
services.dbus.enable = true;
services.dbus.packages = [ lightdm ];
# lightdm uses the accounts daemon to remember language/window-manager per user
services.accounts-daemon.enable = true;
# Enable the accounts daemon to find lightdm's dbus interface
environment.systemPackages = [ lightdm ];
security.polkit.enable = true;
security.pam.services.lightdm.text = ''
auth substack login
account include login
password substack login
session include login
'';
security.pam.services.lightdm-greeter.text = ''
auth required pam_succeed_if.so audit quiet_success user = lightdm
auth optional pam_permit.so
account required pam_succeed_if.so audit quiet_success user = lightdm
account sufficient pam_unix.so
password required pam_deny.so
session required pam_succeed_if.so audit quiet_success user = lightdm
session required pam_env.so conffile=/etc/pam/environment readenv=0
session optional ${config.systemd.package}/lib/security/pam_systemd.so
session optional pam_keyinit.so force revoke
session optional pam_permit.so
'';
security.pam.services.lightdm-autologin.text = ''
auth requisite pam_nologin.so
auth required pam_succeed_if.so uid >= 1000 quiet
auth required pam_permit.so
account sufficient pam_unix.so
password requisite pam_unix.so nullok yescrypt
session optional pam_keyinit.so revoke
session include login
'';
users.users.lightdm = {
home = "/var/lib/lightdm";
group = "lightdm";
uid = config.ids.uids.lightdm;
};
systemd.tmpfiles.rules = [
"d /run/lightdm 0711 lightdm lightdm -"
"d /var/cache/lightdm 0711 root lightdm -"
"d /var/lib/lightdm 1770 lightdm lightdm -"
"d /var/lib/lightdm-data 1775 lightdm lightdm -"
"d /var/log/lightdm 0711 root lightdm -"
];
users.groups.lightdm.gid = config.ids.gids.lightdm;
services.xserver.display = null; # We specify our own display (and logfile) in xserver-wrapper up there
};
}

89
nixos/modules/services/x11/display-managers/set-session.py Executable file
View File

@@ -0,0 +1,89 @@
#!/usr/bin/env python
import gi, argparse, os, logging, sys
gi.require_version("AccountsService", "1.0")
from gi.repository import AccountsService, GLib
from ordered_set import OrderedSet
def get_session_file(session):
system_data_dirs = GLib.get_system_data_dirs()
session_dirs = OrderedSet(
os.path.join(data_dir, session)
for data_dir in system_data_dirs
for session in {"wayland-sessions", "xsessions"}
)
session_files = OrderedSet(
os.path.join(dir, session + ".desktop")
for dir in session_dirs
if os.path.exists(os.path.join(dir, session + ".desktop"))
)
# Deal with duplicate wayland-sessions and xsessions.
# Needed for the situation in gnome-session, where there's
# a xsession named the same as a wayland session.
if any(map(is_session_wayland, session_files)):
session_files = OrderedSet(
session for session in session_files if is_session_wayland(session)
)
else:
session_files = OrderedSet(
session for session in session_files if is_session_xsession(session)
)
if len(session_files) == 0:
logging.warning("No session files are found.")
sys.exit(0)
else:
return session_files[0]
def is_session_xsession(session_file):
return "/xsessions/" in session_file
def is_session_wayland(session_file):
return "/wayland-sessions/" in session_file
def main():
parser = argparse.ArgumentParser(
description="Set session type for all normal users."
)
parser.add_argument("session", help="Name of session to set.")
args = parser.parse_args()
session = getattr(args, "session")
session_file = get_session_file(session)
user_manager = AccountsService.UserManager.get_default()
users = user_manager.list_users()
for user in users:
if user.is_system_account():
continue
else:
if is_session_wayland(session_file):
logging.debug(
f"Setting session name: {session}, as we found the existing wayland-session: {session_file}"
)
user.set_session(session)
user.set_session_type("wayland")
elif is_session_xsession(session_file):
logging.debug(
f"Setting session name: {session}, as we found the existing xsession: {session_file}"
)
user.set_x_session(session)
user.set_session(session)
user.set_session_type("x11")
else:
logging.error(f"Couldn't figure out session type for {session_file}")
sys.exit(1)
if __name__ == "__main__":
main()

21
nixos/modules/services/x11/display-managers/slim.nix Normal file
View File

@@ -0,0 +1,21 @@
{
config,
lib,
pkgs,
...
}:
with lib;
{
# added 2019-11-11
imports = [
(mkRemovedOptionModule [ "services" "xserver" "displayManager" "slim" ] ''
The SLIM project is abandoned and their last release was in 2013.
Because of this it poses a security risk to your system.
Other issues include it not fully supporting systemd and logind sessions.
Please use a different display manager such as LightDM, SDDM, or GDM.
You can also use the startx module which uses Xinitrc.
'')
];
}

107
nixos/modules/services/x11/display-managers/startx.nix Normal file
View File

@@ -0,0 +1,107 @@
{
config,
lib,
pkgs,
...
}:
let
cfg = config.services.xserver.displayManager.startx;
# WM session script
# Note: this assumes a single WM has been enabled
sessionScript = lib.concatMapStringsSep "\n" (
i: i.start
) config.services.xserver.windowManager.session;
in
{
###### interface
options = {
services.xserver.displayManager.startx = {
enable = lib.mkOption {
type = lib.types.bool;
default = false;
description = ''
Whether to enable the dummy "startx" pseudo-display manager, which
allows users to start X manually via the `startx` command from a
virtual terminal.
::: {.note}
The X server will run under the current user, not as root.
:::
'';
};
generateScript = lib.mkOption {
type = lib.types.bool;
default = false;
description = ''
Whether to generate the system-wide xinitrc script (/etc/X11/xinit/xinitrc).
This script will take care of setting up the session for systemd user
services, running the window manager and cleaning up on exit.
::: {.note}
This script will only be used by `startx` when both `.xinitrc` does not
exists and the `XINITRC` environment variable is unset.
:::
'';
};
extraCommands = lib.mkOption {
type = lib.types.lines;
default = "";
description = ''
Shell commands to be added to the system-wide xinitrc script.
'';
};
};
};
###### implementation
config = lib.mkIf cfg.enable {
services.xserver.exportConfiguration = true;
# Other displayManagers log to /dev/null because they're services and put
# Xorg's stdout in the journal
#
# To send log to Xorg's default log location ($XDG_DATA_HOME/xorg/), we do
# not specify a log file when running X
services.xserver.logFile = lib.mkDefault null;
# Implement xserverArgs via xinit's system-wide xserverrc
environment.etc."X11/xinit/xserverrc".source = pkgs.writeShellScript "xserverrc" ''
exec ${pkgs.xorg.xorgserver}/bin/X \
${toString config.services.xserver.displayManager.xserverArgs} "$@"
'';
# Add a sane system-wide xinitrc script
environment.etc."X11/xinit/xinitrc" = lib.mkIf cfg.generateScript {
source = pkgs.writeShellScript "xinitrc" ''
${cfg.extraCommands}
# start user services
systemctl --user import-environment DISPLAY XDG_SESSION_ID
systemctl --user start nixos-fake-graphical-session.target
# run the window manager script
${sessionScript}
wait $waitPID
# stop services and all subprocesses
systemctl --user stop nixos-fake-graphical-session.target
kill 0
'';
};
environment.systemPackages = with pkgs; [ xorg.xinit ];
};
}

57
nixos/modules/services/x11/display-managers/sx.nix Normal file
View File

@@ -0,0 +1,57 @@
{
config,
lib,
pkgs,
...
}:
let
cfg = config.services.xserver.displayManager.sx;
in
{
options = {
services.xserver.displayManager.sx = {
enable = lib.mkEnableOption "" // {
description = ''
Whether to enable the "sx" pseudo-display manager, which allows users
to start manually via the "sx" command from a vt shell. The X server
runs under the user's id, not as root. The user must provide a
~/.config/sx/sxrc file containing session startup commands, see
{manpage}`sx(1)`. This is not automatically generated from the desktopManager
and windowManager settings. sx doesn't have a way to directly set
X server flags, but it can be done by overriding its xorgserver
dependency.
'';
};
addAsSession = lib.mkEnableOption "" // {
description = ''
Whether to add sx as a display manager session. Keep in mind that sx
expects to be run from a TTY, so it may not work in your display
manager.
'';
};
package = lib.mkPackageOption pkgs "sx" { };
};
};
config = lib.mkIf cfg.enable {
environment.systemPackages = [ cfg.package ];
services = {
displayManager.sessionPackages = lib.optionals cfg.addAsSession [ cfg.package ];
xserver = {
exportConfiguration = true;
logFile = lib.mkDefault null;
};
};
};
meta.maintainers = with lib.maintainers; [
figsoda
thiagokokada
];
}

333
nixos/modules/services/x11/display-managers/xpra.nix Normal file
View File

@@ -0,0 +1,333 @@
{
config,
lib,
pkgs,
...
}:
with lib;
let
cfg = config.services.xserver.displayManager.xpra;
dmcfg = config.services.xserver.displayManager;
in
{
###### interface
options = {
services.xserver.displayManager.xpra = {
enable = mkOption {
type = types.bool;
default = false;
description = "Whether to enable xpra as display manager.";
};
bindTcp = mkOption {
default = "127.0.0.1:10000";
example = "0.0.0.0:10000";
type = types.nullOr types.str;
description = "Bind xpra to TCP";
};
desktop = mkOption {
type = types.nullOr types.str;
default = null;
example = "gnome-shell";
description = "Start a desktop environment instead of seamless mode";
};
auth = mkOption {
type = types.str;
default = "pam";
example = "password:value=mysecret";
description = "Authentication to use when connecting to xpra";
};
pulseaudio = mkEnableOption "pulseaudio audio streaming";
extraOptions = mkOption {
description = "Extra xpra options";
default = [ ];
type = types.listOf types.str;
};
};
};
###### implementation
config = mkIf cfg.enable {
services.xserver.videoDrivers = [ "dummy" ];
services.xserver.monitorSection = ''
HorizSync 1.0 - 2000.0
VertRefresh 1.0 - 200.0
#To add your own modes here, use a modeline calculator, like:
# cvt:
# https://www.x.org/archive/X11R7.5/doc/man/man1/cvt.1.html
# xtiming:
# https://xtiming.sourceforge.net/cgi-bin/xtiming.pl
# gtf:
# https://gtf.sourceforge.net/
#This can be used to get a specific DPI, but only for the default resolution:
#DisplaySize 508 317
#NOTE: the highest modes will not work without increasing the VideoRam
# for the dummy video card.
#Modeline "16000x15000" 300.00 16000 16408 18000 20000 15000 15003 15013 15016
#Modeline "15000x15000" 281.25 15000 15376 16872 18744 15000 15003 15013 15016
#Modeline "16384x8192" 167.75 16384 16800 18432 20480 8192 8195 8205 8208
#Modeline "15360x8640" 249.00 15360 15752 17280 19200 8640 8643 8648 8651
Modeline "8192x4096" 193.35 8192 8224 8952 8984 4096 4196 4200 4301
Modeline "7680x4320" 208.00 7680 7880 8640 9600 4320 4323 4328 4335
Modeline "6400x4096" 151.38 6400 6432 7000 7032 4096 4196 4200 4301
Modeline "6400x2560" 91.59 6400 6432 6776 6808 2560 2623 2626 2689
Modeline "6400x2160" 160.51 6400 6432 7040 7072 2160 2212 2216 2269
Modeline "5760x2160" 149.50 5760 5768 6320 6880 2160 2161 2164 2173
Modeline "5680x1440" 142.66 5680 5712 6248 6280 1440 1474 1478 1513
Modeline "5496x1200" 199.13 5496 5528 6280 6312 1200 1228 1233 1261
Modeline "5280x2560" 75.72 5280 5312 5592 5624 2560 2623 2626 2689
Modeline "5280x1920" 56.04 5280 5312 5520 5552 1920 1967 1969 2017
Modeline "5280x1200" 191.40 5280 5312 6032 6064 1200 1228 1233 1261
Modeline "5280x1080" 169.96 5280 5312 5952 5984 1080 1105 1110 1135
Modeline "5120x3200" 199.75 5120 5152 5904 5936 3200 3277 3283 3361
Modeline "5120x2560" 73.45 5120 5152 5424 5456 2560 2623 2626 2689
Modeline "5120x2880" 185.50 5120 5256 5760 6400 2880 2883 2888 2899
Modeline "4800x1200" 64.42 4800 4832 5072 5104 1200 1229 1231 1261
Modeline "4720x3840" 227.86 4720 4752 5616 5648 3840 3933 3940 4033
Modeline "4400x2560" 133.70 4400 4432 4936 4968 2560 2622 2627 2689
Modeline "4480x1440" 72.94 4480 4512 4784 4816 1440 1475 1478 1513
Modeline "4240x1440" 69.09 4240 4272 4528 4560 1440 1475 1478 1513
Modeline "4160x1440" 67.81 4160 4192 4448 4480 1440 1475 1478 1513
Modeline "4096x2304" 249.25 4096 4296 4720 5344 2304 2307 2312 2333
Modeline "4096x2160" 111.25 4096 4200 4608 5120 2160 2163 2173 2176
Modeline "4000x1660" 170.32 4000 4128 4536 5072 1660 1661 1664 1679
Modeline "4000x1440" 145.00 4000 4088 4488 4976 1440 1441 1444 1457
Modeline "3904x1440" 63.70 3904 3936 4176 4208 1440 1475 1478 1513
Modeline "3840x2880" 133.43 3840 3872 4376 4408 2880 2950 2955 3025
Modeline "3840x2560" 116.93 3840 3872 4312 4344 2560 2622 2627 2689
Modeline "3840x2160" 104.25 3840 3944 4320 4800 2160 2163 2168 2175
Modeline "3840x2048" 91.45 3840 3872 4216 4248 2048 2097 2101 2151
Modeline "3840x1200" 108.89 3840 3872 4280 4312 1200 1228 1232 1261
Modeline "3840x1080" 100.38 3840 3848 4216 4592 1080 1081 1084 1093
Modeline "3864x1050" 94.58 3864 3896 4248 4280 1050 1074 1078 1103
Modeline "3600x1200" 106.06 3600 3632 3984 4368 1200 1201 1204 1214
Modeline "3600x1080" 91.02 3600 3632 3976 4008 1080 1105 1109 1135
Modeline "3520x1196" 99.53 3520 3552 3928 3960 1196 1224 1228 1256
Modeline "3360x2560" 102.55 3360 3392 3776 3808 2560 2622 2627 2689
Modeline "3360x1050" 293.75 3360 3576 3928 4496 1050 1053 1063 1089
Modeline "3288x1080" 39.76 3288 3320 3464 3496 1080 1106 1108 1135
Modeline "3200x1800" 233.00 3200 3384 3720 4240 1800 1803 1808 1834
Modeline "3200x1080" 236.16 3200 3232 4128 4160 1080 1103 1112 1135
Modeline "3120x2560" 95.36 3120 3152 3512 3544 2560 2622 2627 2689
Modeline "3120x1050" 272.75 3120 3320 3648 4176 1050 1053 1063 1089
Modeline "3072x2560" 93.92 3072 3104 3456 3488 2560 2622 2627 2689
Modeline "3008x1692" 130.93 3008 3112 3416 3824 1692 1693 1696 1712
Modeline "3000x2560" 91.77 3000 3032 3376 3408 2560 2622 2627 2689
Modeline "2880x1620" 396.25 2880 3096 3408 3936 1620 1623 1628 1679
Modeline "2728x1680" 148.02 2728 2760 3320 3352 1680 1719 1726 1765
Modeline "2560x2240" 151.55 2560 2688 2952 3344 2240 2241 2244 2266
Modeline "2560x1600" 47.12 2560 2592 2768 2800 1600 1639 1642 1681
Modeline "2560x1440" 42.12 2560 2592 2752 2784 1440 1475 1478 1513
Modeline "2560x1400" 267.86 2560 2592 3608 3640 1400 1429 1441 1471
Modeline "2048x2048" 49.47 2048 2080 2264 2296 2048 2097 2101 2151
Modeline "2048x1536" 80.06 2048 2104 2312 2576 1536 1537 1540 1554
Modeline "2048x1152" 197.97 2048 2184 2408 2768 1152 1153 1156 1192
Modeline "2048x1152" 165.92 2048 2080 2704 2736 1152 1176 1186 1210
Modeline "1920x1440" 69.47 1920 1960 2152 2384 1440 1441 1444 1457
Modeline "1920x1200" 26.28 1920 1952 2048 2080 1200 1229 1231 1261
Modeline "1920x1080" 23.53 1920 1952 2040 2072 1080 1106 1108 1135
Modeline "1728x1520" 205.42 1728 1760 2536 2568 1520 1552 1564 1597
Modeline "1680x1050" 20.08 1680 1712 1784 1816 1050 1075 1077 1103
Modeline "1600x1200" 22.04 1600 1632 1712 1744 1200 1229 1231 1261
Modeline "1600x900" 33.92 1600 1632 1760 1792 900 921 924 946
Modeline "1440x900" 30.66 1440 1472 1584 1616 900 921 924 946
Modeline "1400x900" 103.50 1400 1480 1624 1848 900 903 913 934
ModeLine "1366x768" 72.00 1366 1414 1446 1494 768 771 777 803
Modeline "1360x768" 24.49 1360 1392 1480 1512 768 786 789 807
Modeline "1280x1024" 31.50 1280 1312 1424 1456 1024 1048 1052 1076
Modeline "1280x800" 24.15 1280 1312 1400 1432 800 819 822 841
Modeline "1280x768" 23.11 1280 1312 1392 1424 768 786 789 807
Modeline "1280x720" 59.42 1280 1312 1536 1568 720 735 741 757
Modeline "1024x768" 18.71 1024 1056 1120 1152 768 786 789 807
Modeline "1024x640" 41.98 1024 1056 1208 1240 640 653 659 673
Modeline "1024x576" 46.50 1024 1064 1160 1296 576 579 584 599
Modeline "768x1024" 19.50 768 800 872 904 1024 1048 1052 1076
Modeline "960x540" 40.75 960 992 1088 1216 540 543 548 562
Modeline "864x486" 32.50 864 888 968 1072 486 489 494 506
Modeline "720x405" 22.50 720 744 808 896 405 408 413 422
Modeline "640x360" 14.75 640 664 720 800 360 363 368 374
#common resolutions for android devices (both orientations):
Modeline "800x1280" 25.89 800 832 928 960 1280 1310 1315 1345
Modeline "1280x800" 24.15 1280 1312 1400 1432 800 819 822 841
Modeline "720x1280" 30.22 720 752 864 896 1280 1309 1315 1345
Modeline "1280x720" 27.41 1280 1312 1416 1448 720 737 740 757
Modeline "768x1024" 24.93 768 800 888 920 1024 1047 1052 1076
Modeline "1024x768" 23.77 1024 1056 1144 1176 768 785 789 807
Modeline "600x1024" 19.90 600 632 704 736 1024 1047 1052 1076
Modeline "1024x600" 18.26 1024 1056 1120 1152 600 614 617 631
Modeline "536x960" 16.74 536 568 624 656 960 982 986 1009
Modeline "960x536" 15.23 960 992 1048 1080 536 548 551 563
Modeline "600x800" 15.17 600 632 688 720 800 818 822 841
Modeline "800x600" 14.50 800 832 880 912 600 614 617 631
Modeline "480x854" 13.34 480 512 560 592 854 873 877 897
Modeline "848x480" 12.09 848 880 920 952 480 491 493 505
Modeline "480x800" 12.43 480 512 552 584 800 818 822 841
Modeline "800x480" 11.46 800 832 872 904 480 491 493 505
#resolutions for android devices (both orientations)
#minus the status bar
#38px status bar (and width rounded up)
Modeline "800x1242" 25.03 800 832 920 952 1242 1271 1275 1305
Modeline "1280x762" 22.93 1280 1312 1392 1424 762 780 783 801
Modeline "720x1242" 29.20 720 752 856 888 1242 1271 1276 1305
Modeline "1280x682" 25.85 1280 1312 1408 1440 682 698 701 717
Modeline "768x986" 23.90 768 800 888 920 986 1009 1013 1036
Modeline "1024x730" 22.50 1024 1056 1136 1168 730 747 750 767
Modeline "600x986" 19.07 600 632 704 736 986 1009 1013 1036
Modeline "1024x562" 17.03 1024 1056 1120 1152 562 575 578 591
Modeline "536x922" 16.01 536 568 624 656 922 943 947 969
Modeline "960x498" 14.09 960 992 1040 1072 498 509 511 523
Modeline "600x762" 14.39 600 632 680 712 762 779 783 801
Modeline "800x562" 13.52 800 832 880 912 562 575 578 591
Modeline "480x810" 12.59 480 512 552 584 810 828 832 851
Modeline "848x442" 11.09 848 880 920 952 442 452 454 465
Modeline "480x762" 11.79 480 512 552 584 762 779 783 801
'';
services.xserver.resolutions = [
{
x = "8192";
y = "4096";
}
{
x = "5120";
y = "3200";
}
{
x = "3840";
y = "2880";
}
{
x = "3840";
y = "2560";
}
{
x = "3840";
y = "2048";
}
{
x = "3840";
y = "2160";
}
{
x = "2048";
y = "2048";
}
{
x = "2560";
y = "1600";
}
{
x = "1920";
y = "1440";
}
{
x = "1920";
y = "1200";
}
{
x = "1920";
y = "1080";
}
{
x = "1600";
y = "1200";
}
{
x = "1680";
y = "1050";
}
{
x = "1600";
y = "900";
}
{
x = "1400";
y = "1050";
}
{
x = "1440";
y = "900";
}
{
x = "1280";
y = "1024";
}
{
x = "1366";
y = "768";
}
{
x = "1280";
y = "800";
}
{
x = "1024";
y = "768";
}
{
x = "1024";
y = "600";
}
{
x = "800";
y = "600";
}
{
x = "320";
y = "200";
}
];
services.xserver.serverFlagsSection = ''
Option "DontVTSwitch" "true"
Option "PciForceNone" "true"
Option "AutoEnableDevices" "false"
Option "AutoAddDevices" "false"
'';
services.xserver.deviceSection = ''
VideoRam 192000
'';
services.displayManager.execCmd = ''
${optionalString (cfg.pulseaudio) "export PULSE_COOKIE=/run/pulse/.config/pulse/cookie"}
exec ${pkgs.xpra}/bin/xpra ${
if cfg.desktop == null then "start" else "start-desktop --start=${cfg.desktop}"
} \
--daemon=off \
--log-dir=/var/log \
--log-file=xpra.log \
--opengl=on \
--clipboard=on \
--notifications=on \
--speaker=yes \
--mdns=no \
--pulseaudio=no \
${optionalString (cfg.pulseaudio) "--sound-source=pulse"} \
--socket-dirs=/run/xpra \
--xvfb="xpra_Xdummy ${concatStringsSep " " dmcfg.xserverArgs}" \
${optionalString (cfg.bindTcp != null) "--bind-tcp=${cfg.bindTcp}"} \
--auth=${cfg.auth} \
${concatStringsSep " " cfg.extraOptions}
'';
services.xserver.terminateOnReset = false;
environment.systemPackages = [ pkgs.xpra ];
services.pulseaudio.enable = mkDefault cfg.pulseaudio;
services.pulseaudio.systemWide = mkDefault cfg.pulseaudio;
};
}