leyoda/cosmic-greeter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: leyoda:local/yoda-main
Branches Tags
leyoda:local/yoda-main
leyoda:post-1.9-merge-20260924
leyoda:pre-1.9-merge-20260924
leyoda:post-1.8-merge-20260910
leyoda:pre-1.8-merge-20260910
leyoda:post-1.7-merge-20260827
leyoda:pre-1.7-merge-20260827
leyoda:post-1.6-merge-20260819
leyoda:pre-1.6-merge-20260819
..
compare: leyoda:pre-1.6-merge-20260819
Branches Tags
leyoda:local/yoda-main
leyoda:post-1.9-merge-20260924
leyoda:pre-1.9-merge-20260924
leyoda:post-1.8-merge-20260910
leyoda:pre-1.8-merge-20260910
leyoda:post-1.7-merge-20260827
leyoda:pre-1.7-merge-20260827
leyoda:post-1.6-merge-20260819
leyoda:pre-1.6-merge-20260819

No commits in common. "local/yoda-main" and "pre-1.6-merge-20260819" have entirely different histories.
local/yoda ... pre-1.6-me

36 changed files with 1275 additions and 2629 deletions
Download patch file Download diff file Expand all files Collapse all files

15
.zed/settings.json Normal file
View file

@ -0,0 +1,15 @@
{
"format_on_save": "on",
"lsp": {
"rust-analyzer": {
"initialization_options": {
"check": {
"command": "clippy",
},
"rustfmt": {
"extraArgs": ["+nightly"],
},
},
},
},
}

2342
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

11
Cargo.toml
View file

@ -18,7 +18,6 @@ cosmic-comp-config.workspace = true
cosmic-config = { workspace = true, features = ["calloop", "macro"] }
cosmic-greeter-config.workspace = true
cosmic-greeter-daemon = { path = "daemon" }
cosmic-osk-config = { git = "https://github.com/pop-os/cosmic-osk" }
dirs = "6"
cosmic = { package = "libcosmic-yoda", path = "../libcosmic", default-features = false, features = [
"advanced-shaping",
@ -81,16 +80,12 @@ cosmic-randr-shell = { workspace = true }
kdl.workspace = true
color-eyre.workspace = true
image = { version = "0.25", default-features = false, features = [
"avif-native",
"jpeg",
"png",
"rayon",
"webp",
"hdr",
] }
# JPEG-XL support
jxl-oxide = { version = "0.12.6", features = ["image"] }
enumflags2 = "0.7.12"
[dependencies.greetd_ipc]
version = "0.10.3"
@ -173,8 +168,8 @@ iced_widget = { path = "../libcosmic/iced/widget" }
iced_winit = { path = "../libcosmic/iced/winit" }
[patch."https://github.com/pop-os/cosmic-protocols"]
cosmic-client-toolkit = { path = "../cosmic-protocols/client-toolkit" }
cosmic-protocols = { path = "../cosmic-protocols" }
cosmic-client-toolkit = { path = "../cosmic-protocols/client-toolkit" }
[patch."https://github.com/pop-os/cosmic-settings-daemon"]
cosmic-settings-config = { path = "../cosmic-settings-daemon/config" }
@ -189,7 +184,3 @@ dnd = { path = "../window_clipboard/dnd" }
mime = { path = "../window_clipboard/mime" }
clipboard_wayland = { path = "../window_clipboard/wayland" }
clipboard_macos = { path = "../window_clipboard/macos" }
# Yoda: cosmic-osk-config depuis le checkout local (meme source que le paquet cosmic-osk).
[patch."https://github.com/pop-os/cosmic-osk"]
cosmic-osk-config = { path = "../cosmic-osk/config" }

3
daemon/Cargo.toml
View file

@ -28,8 +28,7 @@ whitespace-conf = "1"
#TODO: reduce features
tokio = { workspace = true, features = ["full"] }
xdg = "3.0"
zbus_systemd = { version = "0.26000.0", features = ["home1"], optional = true }
[features]
default = ["systemd"]
systemd = ["tracing-journald", "zbus_systemd"]
systemd = ["tracing-journald"]

127
daemon/src/lib.rs
View file

@ -1,12 +1,11 @@
use cosmic_comp_config::output::randr;
use cosmic_config::CosmicConfigEntry;
use kdl::KdlDocument;
use std::collections::{BTreeMap, BTreeSet};
use std::collections::BTreeMap;
use std::fs;
use std::io::Read;
use std::os::unix::fs::OpenOptionsExt;
use std::path::{Path, PathBuf};
use zbus::Connection;
pub use cosmic_applets_config::time::TimeAppletConfig;
pub use cosmic_bg_config::state::State as BgState;
@ -17,41 +16,12 @@ pub use cosmic_theme::{Theme, ThemeBuilder};
pub struct UserFilter {
uid_min: u32,
uid_max: u32,
homed_uids: BTreeSet<u32>,
}
impl UserFilter {
#[cfg(feature = "systemd")]
async fn get_homed_uids() -> Result<BTreeSet<u32>, zbus::Error> {
use zbus_systemd::home1;
let connection = Connection::system().await?;
let homed = home1::ManagerProxy::new(&connection).await?;
let homed_uids = homed
.list_homes()
.await?
.iter()
.map(|(_, uid, ..)| *uid)
.collect();
Ok(homed_uids)
}
pub async fn new() -> Self {
impl Default for UserFilter {
fn default() -> Self {
let login_defs_data = fs::read_to_string("/etc/login.defs").unwrap_or_default();
let login_defs = whitespace_conf::parse(&login_defs_data);
#[cfg(feature = "systemd")]
let homed_uids = Self::get_homed_uids()
.await
.inspect_err(|e| {
tracing::warn!("failed to list dynamic UIDs from systemd-homed: {e:?}")
})
.unwrap_or_default();
#[cfg(not(feature = "systemd"))]
let homed_uids = BTreeSet::new();
Self {
uid_min: login_defs
.get("UID_MIN")
@ -61,14 +31,17 @@ impl UserFilter {
.get("UID_MAX")
.and_then(|x| x.parse::<u32>().ok())
.unwrap_or(65000),
homed_uids,
}
}
}
impl UserFilter {
pub fn new() -> Self {
Self::default()
}
pub fn filter(&self, user: &pwd::Passwd) -> bool {
if (user.uid < self.uid_min || user.uid > self.uid_max)
&& !self.homed_uids.contains(&user.uid)
{
if user.uid < self.uid_min || user.uid > self.uid_max {
// Skip system accounts
return false;
}
@ -128,48 +101,6 @@ impl UserData {
}
}
fn load_icon_as_user(&mut self) {
//TODO: use accountsservice?
let icon_paths = [
//IMPORTANT: This file is owned by root and safe to read (it won't be a link to /etc/shadow for example)
// It may not exist if the user uses one of the system icons. In that case, we should read the
// information in /var/lib/AccountsService/users, and then read the icon path as the user
Path::new("/var/lib/AccountsService/icons").join(&self.name),
// systemd-homed cache
Path::new("/var/cache/systemd/home")
.join(&self.name)
.join("avatar"),
];
for icon_path in icon_paths {
match fs::OpenOptions::new()
.read(true)
// Do not follow symlinks
.custom_flags(libc::O_NOFOLLOW)
.open(&icon_path)
{
Ok(mut icon_file) => {
let mut icon_data = Vec::new();
match icon_file.read_to_end(&mut icon_data) {
Ok(count) => {
icon_data.truncate(count);
self.icon_opt = Some(icon_data);
return;
}
Err(err) => {
tracing::error!("failed to read icon data {:?}: {:?}", icon_path, err);
}
}
}
Err(err) => {
tracing::warn!("failed to open icon {:?}: {:?}", icon_path, err);
}
}
}
tracing::error!("failed to load icon for user {:?}", self.name)
}
pub fn load_config_as_user(&mut self) {
self.icon_opt = None;
self.theme_opt = None;
@ -178,7 +109,33 @@ impl UserData {
self.xkb_config_opt = None;
self.time_applet_config = Default::default();
self.load_icon_as_user();
//TODO: use accountsservice?
//IMPORTANT: This file is owned by root and safe to read (it won't be a link to /etc/shadow for example)
// It may not exist if the user uses one of the system icons. In that case, we should read the
// information in /var/lib/AccountsService/users, and then read the icon path as the user
let icon_path = Path::new("/var/lib/AccountsService/icons").join(&self.name);
match fs::OpenOptions::new()
.read(true)
// Do not follow symlinks
.custom_flags(libc::O_NOFOLLOW)
.open(&icon_path)
{
Ok(mut icon_file) => {
let mut icon_data = Vec::new();
match icon_file.read_to_end(&mut icon_data) {
Ok(count) => {
icon_data.truncate(count);
self.icon_opt = Some(icon_data);
}
Err(err) => {
tracing::error!("failed to read icon data {:?}: {:?}", icon_path, err);
}
}
}
Err(err) => {
tracing::error!("failed to open icon {:?}: {:?}", icon_path, err);
}
}
let mut is_dark = true;
match cosmic_theme::ThemeMode::config() {
@ -252,16 +209,6 @@ impl UserData {
tracing::error!("failed to create cosmic-bg state helper: {:?}", err);
}
}
if self.bg_state.wallpapers.is_empty() {
self.bg_state.wallpapers.push((
String::new(),
BgSource::Path(
Path::new("/var/cache/systemd/home")
.join(&self.name)
.join("login-background"),
),
));
}
self.load_wallpapers_as_user();
match cosmic_config::Config::new("com.system76.CosmicComp", CosmicCompConfig::VERSION) {

4
daemon/src/main.rs
View file

@ -70,8 +70,8 @@ struct GreeterProxy;
#[zbus::interface(name = "com.system76.CosmicGreeter")]
impl GreeterProxy {
async fn get_user_data(&mut self) -> Result<String, GreeterError> {
let user_filter = UserFilter::new().await;
fn get_user_data(&mut self) -> Result<String, GreeterError> {
let user_filter = UserFilter::new();
// The pwd::Passwd method is unsafe (but not labelled as such) due to using global state (libc pwent functions).
// To prevent issues, this should only be called once in the entire process space at a time

1
debian/control vendored
View file

@ -7,7 +7,6 @@ Build-Depends:
git,
just (>= 1.13.0),
libclang-dev,
libdav1d-dev,
libinput-dev,
libpam-dev,
libwayland-dev,

37
default.nix
View file

@ -1,37 +0,0 @@
{
rust-overlay ? import (import ./nix/flake-parse.nix "rust-overlay"),
pkgs ? import (import ./nix/flake-parse.nix "nixpkgs") {
system = builtins.currentSystem;
overlays = [ rust-overlay ];
},
}:
let
rustToolchain = pkgs.rust-bin.stable.latest.default.override {
extensions = [
"rust-analyzer"
"rust-src"
"llvm-tools"
];
};
in
{
shell = import ./nix/shell.nix {
inherit pkgs rustToolchain;
};
formatter = import ./nix/formatter.nix { inherit pkgs rustToolchain; };
packages =
let
rustPlatform = pkgs.makeRustPlatform {
cargo = rustToolchain;
rustc = rustToolchain;
};
in
rec {
default = pkgs.callPackage ./nix/package.nix {
inherit rustPlatform;
};
sessiond-seat = default;
};
}

45
flake.lock generated
View file

@ -1,45 +0,0 @@
{
"nodes": {
"nixpkgs": {
"locked": {
"lastModified": 1788881743,
"narHash": "sha256-151taSq/21cxagiIu7hyMVl68+FbHfwBP4lh6TB6KOM=",
"rev": "d6524aaca2ff07876657ae2b323f24be4874944b",
"type": "tarball",
"url": "https://releases.nixos.org/nixos/unstable/nixos-26.11pre1069856.d6524aaca2ff/nixexprs.tar.xz"
},
"original": {
"type": "tarball",
"url": "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz"
}
},
"root": {
"inputs": {
"nixpkgs": "nixpkgs",
"rust-overlay": "rust-overlay"
}
},
"rust-overlay": {
"inputs": {
"nixpkgs": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1788851328,
"narHash": "sha256-YOwlUD0Lt/3SulKhZ7z0Jmgbq/DWh8SjnGwUlFSw+YM=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "6ae57a71bcb0bebc7a66cc2bd76942c4cf649167",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

84
flake.nix
View file

@ -1,84 +0,0 @@
{
inputs = {
nixpkgs.url = "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz";
rust-overlay = {
url = "github:oxalica/rust-overlay";
inputs.nixpkgs.follows = "nixpkgs";
};
};
outputs =
{
self,
nixpkgs,
rust-overlay,
...
}:
let
systems = [
"x86_64-linux"
"aarch64-linux"
];
pkgsFor =
system:
import nixpkgs {
inherit system;
overlays = [ rust-overlay.overlays.default ];
};
forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f (pkgsFor system));
in
{
devShells = forAllSystems (pkgs: {
default =
let
rustToolchain = pkgs.rust-bin.stable.latest.default.override {
extensions = [
"rust-analyzer"
"rust-src"
"llvm-tools"
];
};
in
import ./nix/shell.nix { inherit pkgs rustToolchain; };
});
packages = forAllSystems (
pkgs:
let
rustToolchain = pkgs.rust-bin.stable.latest.default.override {
extensions = [
"rust-analyzer"
"rust-src"
"llvm-tools"
];
};
rustPlatform = pkgs.makeRustPlatform {
cargo = rustToolchain;
rustc = rustToolchain;
};
in
{
cosmic-greeter = pkgs.callPackage ./nix/package.nix {
inherit rustPlatform;
};
default = self.packages.${pkgs.stdenv.hostPlatform.system}.cosmic-greeter;
}
);
formatter = forAllSystems (
pkgs:
let
rustToolchain = pkgs.rust-bin.stable.latest.default.override {
extensions = [
"rust-analyzer"
"rust-src"
"llvm-tools"
];
};
in
import ./nix/formatter.nix { inherit pkgs rustToolchain; }
);
};
}

2
i18n/cs/cosmic_greeter.ftl
View file

@ -2,7 +2,7 @@ accessibility = Přístupnost
.screen-reader = Čtečka obrazovky
.magnifier = Lupa
.high-contrast = Vysoký kontrast
.invert-colors = Inverze barev
.invert-colors = Převrátit barvy
cancel = Zrušit
caps-lock = Caps Lock je aktivní.
enter-user = Zadat jméno ručně...

37
i18n/da/cosmic_greeter.ftl
View file

@ -1,37 +0,0 @@
cancel = Afbryd
restart = Genstart
caps-lock = Skiftelås er aktiv.
enter-user = Indtast navn manuelt...
type-username = Brugernavn:
keyboard-layout = Tastaturopsætning
restart-now = Genstart nu?
session = Session
shutdown = Luk ned
shutdown-now = Luk ned nu?
user = Bruger
suspend = Slumre
auth-error-default = Godkendelse fejlede. Prøv venligst igen.
auth-error-credentials = Ukorrekt adgangskode. Kontrollér venligst din tastaturopsætning og prøv igen.
auth-error-denied = Adgang nægtet.
auth-error-maxtries = For mange mislykkede godkendelsesforsøg.
auth-error-account = Konto er utilgængelig eller deaktiveret.
accessibility = Accessibility
.screen-reader = Skærmlæser
.magnifier = Forstørrelsesglas
.high-contrast = Høj kontrast
.invert-colors = Invertér Farver
authenticating = Godkender...
restart-timeout =
The system will restart automatically
{ $seconds ->
[0] now.
[1] in 1 second.
*[other] in { $seconds } seconds.
}
shutdown-timeout =
Systemet lukker automatisk ned
{ $seconds ->
[0] nu.
[1] om 1 sekund.
*[other] om { $seconds } sekunder.
}

4
i18n/de/cosmic_greeter.ftl
View file

@ -27,11 +27,11 @@ accessibility = Barrierefreiheit
.magnifier = Vergrößerungsglas
.high-contrast = Hoher Kontrast
.invert-colors = Farben invertieren
enter-user = Name manuell eingeben ...
enter-user = Name manuell eingeben…
type-username = Benutzername:
auth-error-default = Authentifizierung fehlgeschlagen. Bitte versuche es erneut.
auth-error-credentials = Falsches Passwort. Bitte überprüfe deine Tastaturbelegung und versuche es erneut.
auth-error-denied = Zugriff verweigert.
auth-error-maxtries = Zu viele fehlgeschlagene Authentifizierungsversuche.
auth-error-account = Konto ist nicht verfügbar oder deaktiviert.
authenticating = Authentifizierung ...
authenticating = Authentifizierung...

1
i18n/en-GB/cosmic_greeter.ftl
View file

@ -1 +0,0 @@
cancel = Cancel

1
i18n/en/cosmic_greeter.ftl
View file

@ -9,7 +9,6 @@ caps-lock = Caps Lock is active.
enter-user = Enter name manually...
type-username = Username:
keyboard-layout = Keyboard layout
on-screen-keyboard = On-screen keyboard
restart = Restart
restart-now = Restart now?
restart-timeout = The system will restart automatically

1
i18n/fa/cosmic_greeter.ftl
View file

@ -1 +0,0 @@
cancel = لغو

0
i18n/fil/cosmic_greeter.ftl
View file

37
i18n/gl/cosmic_greeter.ftl
View file

@ -1,37 +0,0 @@
cancel = Cancelar
accessibility = Accesibilidade
.screen-reader = Lector de pantalla
.magnifier = Lupa
.high-contrast = Alto contraste
.invert-colors = Inverter cores
authenticating = Autentificando...
caps-lock = Bloqueo de Maiúsculas activo.
enter-user = Introducir nome manualmente...
type-username = Nome de usuario:
keyboard-layout = Distribución do teclado
restart = Reiniciar
restart-now = Reiniciar agora?
restart-timeout =
O sistema reiniciarase automaticamente
{ $seconds ->
[0] agora.
[1] dentro de 1 segundo.
*[other] dentro de { $seconds } segundos.
}
session = Sesión
shutdown = Apagar
shutdown-now = Apagar agora?
shutdown-timeout =
O sistema apagarase automaticamente
{ $seconds ->
[0] agora.
[1] dentro de 1 segundo.
*[other] dentro de { $seconds } segundos.
}
suspend = Suspender
user = Usuario
auth-error-default = A autenticación fallou. Téntao de novo.
auth-error-credentials = Contrasinal incorrecto. Comproba a distribución do teclado e téntao de novo.
auth-error-denied = Acceso denegado.
auth-error-maxtries = Demasiados intentos de autenticación.
auth-error-account = A conta non estña dispoñible ou está deshabilitada.

2
i18n/kab/cosmic_greeter.ftl
View file

@ -1,4 +1,4 @@
cancel = Semmet
cancel = Sefsex
restart-timeout =
Anagraw ad yales tanekra s wudem awurman
{ $seconds ->

17
i18n/oc/cosmic_greeter.ftl
View file

@ -1,17 +0,0 @@
shutdown = Atudar
restart-timeout =
Lo sistèma reaviarà automaticament
{ $seconds ->
[0] ara.
[1] d’aquí 1 segondas.
*[other] d’aquí { $seconds } segondas.
}
shutdown-timeout =
Lo sistèma s'atudarà automaticament
{ $seconds ->
[0] ara.
[1] d’aquí 1 segondas.
*[other] d’aquí { $seconds } segondas.
}
cancel = Anullar
user = Utilizaire

2
i18n/pt-BR/cosmic_greeter.ftl
View file

@ -29,7 +29,7 @@ shutdown-timeout =
}
suspend = Suspender
user = Usuário
authenticating = Autenticando...
authenticating = Autenticando…
auth-error-default = A autenticação falhou. Tente novamente.
auth-error-credentials = Senha incorreta. Verifique o layout do seu teclado e tente novamente.
auth-error-denied = Acesso negado.

1
i18n/sat/cosmic_greeter.ftl
View file

@ -1 +0,0 @@
cancel = ᱵᱟᱹᱛᱤᱞ

4
i18n/th/cosmic_greeter.ftl
View file

@ -2,10 +2,10 @@ cancel = ยกเลิก
keyboard-layout = ผังคีย์บอร์ด
restart = รีสตาร์ท
restart-now = รีสตาร์ทตอนนี้เลยหรือไม่
restart-timeout = ระบบจะรีสตาร์ทโดยอัตโนมัติภายใน { $seconds } วินาที
restart-timeout = ระบบจะรีสตาร์ทโดยอัตโนมัติภายใน {$seconds} วินาที
session = เซสชั่น
shutdown = ปิดระบบ
shutdown-now = ปิดระบบตอนนี้เลยหรือไม่
shutdown-timeout = ระบบจะปิดลงโดยอัตโนมัติภายใน { $seconds } วินาที
shutdown-timeout = ระบบจะปิดลงโดยอัตโนมัติภายใน {$seconds} วินาที
suspend = ระงับ
user = ผู้ใช้

12
nix/flake-parse.nix
View file

@ -1,12 +0,0 @@
inputName:
let
lock = builtins.fromJSON (builtins.readFile ../flake.lock);
namedNode = lock.nodes.${lock.nodes.root.inputs.${inputName}}.locked;
githubTarball = fetchTarball {
url =
namedNode.url
or "https://github.com/${namedNode.owner}/${namedNode.repo}/archive/${namedNode.rev}.tar.gz";
sha256 = namedNode.narHash;
};
in
githubTarball

17
nix/formatter.nix
View file

@ -1,17 +0,0 @@
{ pkgs, rustToolchain }:
pkgs.writeShellApplication {
name = "nix3-fmt-wrapper";
runtimeInputs = builtins.attrValues {
inherit (pkgs)
nixfmt
taplo
fd
;
inherit rustToolchain;
};
text = ''
fd "$@" -t f -e nix -x nixfmt -q '{}'
fd "$@" -t f -e toml -x taplo format '{}'
cargo fmt
'';
}

108
nix/package.nix
View file

@ -1,108 +0,0 @@
{
lib,
stdenv,
fetchFromGitHub,
rustPlatform,
libcosmicAppHook,
cmake,
just,
cosmic-randr,
dav1d,
libinput,
linux-pam,
udev,
coreutils,
xkeyboard_config,
nixosTests,
orca,
withLogind ? true,
withUpower ? true,
withNetworkManager ? true,
}:
rustPlatform.buildRustPackage (finalAttrs: {
pname = "cosmic-greeter";
version = "1.6.0";
src = fetchFromGitHub {
owner = "pop-os";
repo = "cosmic-greeter";
tag = "epoch-${finalAttrs.version}";
hash = "sha256-hDVdl2+7NVLA+YxO2HToni57IEr0i4OGTsYDc3YGTuw=";
};
postPatch = ''
substituteInPlace src/greeter.rs --replace-fail '/usr/bin/env' '${lib.getExe' coreutils "env"}'
substituteInPlace src/greeter.rs --replace-fail '/usr/bin/orca' '${lib.getExe orca}'
'';
cargoHash = "sha256-vHR9go8/iVUT7oBV8h+mmBvhi2oSKNBKtV0uoDOr6go=";
buildNoDefaultFeatures = true;
buildFeatures =
lib.optionals withLogind [ "logind" ]
++ lib.optionals withUpower [ "upower" ]
++ lib.optionals withNetworkManager [ "networkmanager" ];
separateDebugInfo = true;
__structuredAttrs = true;
env.VERGEN_GIT_SHA = finalAttrs.src.tag;
nativeBuildInputs = [
rustPlatform.bindgenHook
cmake
just
libcosmicAppHook
];
buildInputs = [
cosmic-randr
dav1d
libinput
linux-pam
udev
orca
];
dontUseJustBuild = true;
dontUseJustCheck = true;
justFlags = [
"--set"
"prefix"
(placeholder "out")
"--set"
"cargo-target-dir"
"target/${stdenv.hostPlatform.rust.cargoShortTarget}"
];
preFixup = ''
libcosmicAppWrapperArgs+=(
--prefix PATH : ${lib.makeBinPath [ cosmic-randr ]}
--set-default X11_BASE_RULES_XML ${xkeyboard_config}/share/X11/xkb/rules/base.xml
--set-default X11_BASE_EXTRA_RULES_XML ${xkeyboard_config}/share/X11/xkb/rules/extra.xml
)
'';
passthru = {
tests = {
inherit (nixosTests)
cosmic
cosmic-autologin
cosmic-noxwayland
cosmic-autologin-noxwayland
;
};
};
meta = {
homepage = "https://github.com/pop-os/cosmic-greeter";
description = "Greeter for the COSMIC Desktop Environment";
mainProgram = "cosmic-greeter";
license = lib.licenses.gpl3Only;
teams = [ lib.teams.cosmic ];
platforms = lib.platforms.linux;
};
})

31
nix/shell.nix
View file

@ -1,31 +0,0 @@
{ pkgs, rustToolchain }:
pkgs.mkShell {
name = "cosmic-greeter-devshell";
packages = builtins.attrValues {
inherit
rustToolchain
;
inherit (pkgs)
rust-analyzer-unwrapped
nixd
libxkbcommon
dav1d
libinput
linux-pam
gcc
glibc
cmake
;
inherit (pkgs.llvmPackages)
libclang
llvm
;
};
nativeBuildInputs = [ pkgs.pkg-config ];
RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
LLVM_CONFIG_PATH = "${pkgs.llvmPackages.llvm}/bin/llvm-config";
LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
BINDGEN_EXTRA_CLANG_ARGS = "-I${pkgs.linux-pam}/include -I${pkgs.glibc.dev}/include";
}

1
rustfmt.toml Normal file
View file

@ -0,0 +1 @@
imports_granularity = "Module"

192
src/common.rs
View file

@ -3,24 +3,15 @@ use cosmic::iced::core::SmolStr;
use cosmic::iced::event::wayland::{Event as WaylandEvent, OutputEvent, SessionLockEvent};
use cosmic::iced::event::{self};
use cosmic::iced::keyboard::{Event as KeyEvent, Key, Modifiers};
use cosmic::iced::platform_specific::shell::commands::blur::blur;
use cosmic::iced::runtime::core::window::Id as SurfaceId;
use cosmic::iced::runtime::platform_specific::wayland::CornerRadius;
use cosmic::iced::{self, Rectangle, Size, Subscription};
use cosmic::surface::corner_radius::rounded_rect_strips;
use cosmic::widget::rectangle_tracker::{RectangleUpdate, rectangle_tracker_subscription};
use cosmic::widget::{self, RectangleTracker};
use cosmic_config::CosmicConfigEntry;
use cosmic_greeter_daemon::{BgSource, UserData};
use cosmic_protocols::keyboard_layout::v1::client::zcosmic_keyboard_layout_v1::ZcosmicKeyboardLayoutV1;
use std::collections::{HashMap, HashSet};
use cosmic::widget;
use cosmic_config::{ConfigSet, CosmicConfigEntry};
use cosmic_greeter_daemon::{BgSource, CosmicCompConfig, UserData};
use std::collections::HashMap;
use std::sync::Arc;
use wayland_client::protocol::wl_output::WlOutput;
use wayland_client::{Connection, Proxy};
use crate::keyboard_layout_wayland;
pub const MAX_WIDTH: f32 = 866.;
pub const DEFAULT_MENU_ITEM_HEIGHT: f32 = 36.;
#[derive(Debug, Clone, Eq, PartialEq)]
@ -30,28 +21,14 @@ pub struct ActiveLayout {
pub variant: String,
}
impl ActiveLayout {
pub fn name(&self) -> String {
let mut name = self.layout.clone();
if !self.variant.is_empty() {
name.push_str(" (");
name.push_str(&self.variant);
name.push_str(")");
}
name
}
}
pub struct Common<M> {
pub wayland_connection: Option<Connection>,
pub keyboard_layout: Option<ZcosmicKeyboardLayoutV1>,
pub current_keyboard_layout: usize,
pub active_layouts: Vec<ActiveLayout>,
pub active_surface_id_opt: Option<SurfaceId>,
pub on_battery: bool,
pub battery_percent: f64,
pub charging_limit: Option<bool>,
pub caps_lock: bool,
pub comp_config_handler: Option<cosmic_config::Config>,
pub core: Core,
pub error_opt: Option<String>,
pub fallback_background: widget::image::Handle,
@ -62,12 +39,8 @@ pub struct Common<M> {
pub output_names: HashMap<WlOutput, String>,
pub power_info_opt: Option<(widget::Icon, f64)>,
pub prompt_opt: Option<(String, bool, Option<String>)>,
pub rectangle_tracker: Option<RectangleTracker<(SurfaceId, bool)>>,
pub rectangles: HashMap<(SurfaceId, bool), iced::Rectangle>,
pub include_menu: bool,
pub subsurface_rects: HashMap<WlOutput, Rectangle>,
pub surface_ids: HashMap<WlOutput, SurfaceId>,
pub subsurface_outputs: HashMap<SurfaceId, WlOutput>,
pub surface_images: HashMap<SurfaceId, widget::image::Handle>,
pub surface_names: HashMap<SurfaceId, String>,
pub text_input_ids: HashMap<String, widget::Id>,
@ -81,16 +54,12 @@ pub enum Message {
Focus(SurfaceId),
Key(Modifiers, Key, Option<SmolStr>),
NetworkIcon(Option<&'static str>),
OnScreenKeyboard,
SubsurfaceOpened(SurfaceId),
OutputEvent(OutputEvent, WlOutput),
PowerInfo(Option<(f64, bool, bool)>),
Prompt(String, bool, Option<String>),
SessionLockEvent(SessionLockEvent),
Tick,
Tz(jiff::tz::TimeZone),
Rectangle(RectangleUpdate<(SurfaceId, bool)>),
KeyboardLayoutWayland(keyboard_layout_wayland::Event),
}
impl<M: From<Message> + Send + 'static> Common<M> {
@ -103,6 +72,17 @@ impl<M: From<Message> + Send + 'static> Common<M> {
core.window.show_minimize = false;
core.window.use_template = false;
let comp_config_handler = match cosmic_config::Config::new(
"com.system76.CosmicComp",
CosmicCompConfig::VERSION,
) {
Ok(config_handler) => Some(config_handler),
Err(err) => {
tracing::error!("failed to create cosmic-comp config handler: {}", err);
None
}
};
let layouts_opt = match xkb_data::all_keyboard_layouts() {
Ok(ok) => Some(Arc::new(ok)),
Err(err) => {
@ -112,12 +92,10 @@ impl<M: From<Message> + Send + 'static> Common<M> {
};
let app = Self {
wayland_connection: None,
keyboard_layout: None,
current_keyboard_layout: 0,
active_layouts: Vec::new(),
active_surface_id_opt: None,
caps_lock: false,
comp_config_handler,
core,
error_opt: None,
fallback_background: widget::image::Handle::from_bytes(
@ -140,10 +118,6 @@ impl<M: From<Message> + Send + 'static> Common<M> {
battery_percent: 0.0,
on_battery: false,
charging_limit: None,
subsurface_outputs: HashMap::new(),
rectangle_tracker: None,
rectangles: HashMap::new(),
include_menu: false,
};
(
app,
@ -154,6 +128,27 @@ impl<M: From<Message> + Send + 'static> Common<M> {
)
}
pub fn set_xkb_config(&self, user_data: &UserData) {
if let Some(mut xkb_config) = user_data.xkb_config_opt.clone() {
xkb_config.layout = String::new();
xkb_config.variant = String::new();
for (i, layout) in self.active_layouts.iter().enumerate() {
if i > 0 {
xkb_config.layout.push(',');
xkb_config.variant.push(',');
}
xkb_config.layout.push_str(&layout.layout);
xkb_config.variant.push_str(&layout.variant);
}
if let Some(comp_config_handler) = &self.comp_config_handler {
match comp_config_handler.set("xkb_config", xkb_config) {
Ok(()) => tracing::info!("updated cosmic-comp xkb_config"),
Err(err) => tracing::error!("failed to update cosmic-comp xkb_config: {}", err),
}
}
}
}
pub fn update_wallpapers(&mut self, user_data: &UserData) {
for (_output, surface_id) in self.surface_ids.iter() {
if self.surface_images.contains_key(surface_id) {
@ -291,32 +286,7 @@ impl<M: From<Message> + Send + 'static> Common<M> {
self.network_icon_opt =
network_icon_opt.map(|name| widget::icon::from_name(name).into());
}
Message::OnScreenKeyboard => {
use cosmic_osk_config::Config;
match Config::handler() {
Ok(handler) => {
let mut config = match Config::get_entry(&handler) {
Ok(config) => config,
Err((errs, config)) => {
tracing::warn!("failed to parse OSK config: {:?}", errs);
config
}
};
if let Err(err) = config.set_always_shown(&handler, !config.always_shown) {
tracing::error!("failed to set OSK always_shown config: {}", err);
}
}
Err(err) => {
tracing::error!("failed to create OSK config handler: {}", err);
}
}
}
Message::OutputEvent(output_event, output) => {
if self.wayland_connection.is_none() {
if let Some(backend) = output.backend().upgrade() {
self.wayland_connection = Some(Connection::from_backend(backend));
}
}
if let Some(on_output_event) = &self.on_output_event {
return Task::done(cosmic::Action::App(on_output_event(output_event, output)));
}
@ -352,88 +322,13 @@ impl<M: From<Message> + Send + 'static> Common<M> {
Message::Tz(tz) => {
self.time.set_tz(tz);
}
Message::SubsurfaceOpened(id) => {
return self.blur_rects(id);
}
Message::Rectangle(u) => match u {
RectangleUpdate::Rectangle(r) => {
self.rectangles.insert(r.0, r.1);
return self.blur_rects(r.0.0);
}
RectangleUpdate::Init(tracker) => {
self.rectangle_tracker.replace(tracker);
}
},
Message::KeyboardLayoutWayland(w) => match w {
keyboard_layout_wayland::Event::KeyboardLayout(keyboard_layout) => {
self.keyboard_layout = Some(keyboard_layout);
}
keyboard_layout_wayland::Event::Group(group) => {
self.current_keyboard_layout = group;
}
},
}
Task::none()
}
pub(crate) fn dropdown_blur_rects(&mut self, enable: bool) -> Task<M> {
let mut ids = HashSet::new();
for r in self.rectangles.keys() {
ids.insert(r.0);
}
self.include_menu = enable;
Task::batch(
ids.into_iter()
.map(|i| self.blur_rects(i))
.collect::<Vec<_>>(),
)
}
pub fn blur_rects(&mut self, id: SurfaceId) -> Task<M> {
if let Some(output) = self.subsurface_outputs.get(&id) {
if let Some(rect) = self.subsurface_rects.get(output) {
let x = rect.x;
let y = rect.y;
if let Some(rect) = self.rectangles.get(&(id, false)) {
let mut offset_rect = *rect;
offset_rect.x += x;
offset_rect.y += y;
let rad = CornerRadius {
top_left: 16,
top_right: 16,
bottom_left: 16,
bottom_right: 16,
};
let mut rects = rounded_rect_strips(offset_rect, rad);
if let Some(other_rect) = self.rectangles.get(&(id, true))
&& self.include_menu
{
let mut other = *other_rect;
other.x += x;
other.y += y;
let rad = CornerRadius {
top_left: 8,
top_right: 8,
bottom_left: 8,
bottom_right: 8,
};
rects.append(&mut rounded_rect_strips(other, rad));
}
return blur(id, Some(rects)).discard();
} else {
tracing::error!("no rectangle for surface {id:?}");
}
}
}
Task::none()
}
pub fn subscription(&self) -> Subscription<Message> {
let mut subscriptions = Vec::with_capacity(3);
subscriptions
.push(rectangle_tracker_subscription(0).map(|update| Message::Rectangle(update.1)));
subscriptions.push(event::listen_with(|event, status, id| match event {
iced::Event::Keyboard(KeyEvent::KeyPressed {
key,
@ -456,21 +351,12 @@ impl<M: From<Message> + Send + 'static> Common<M> {
WaylandEvent::SessionLock(lock_event) => {
Some(Message::SessionLockEvent(lock_event))
}
iced::event::wayland::Event::Subsurface(
iced::event::wayland::SubsurfaceEvent::Created,
) => Some(Message::SubsurfaceOpened(id)),
_ => None,
},
iced::Event::Window(iced::window::Event::Focused) => Some(Message::Focus(id)),
_ => None,
}));
if let Some(conn) = self.wayland_connection.clone() {
subscriptions.push(
keyboard_layout_wayland::subscription(conn).map(Message::KeyboardLayoutWayland),
);
}
#[cfg(feature = "networkmanager")]
{
subscriptions.push(crate::networkmanager::subscription().map(Message::NetworkIcon));

325
src/greeter.rs
View file

@ -11,7 +11,6 @@ use cosmic::cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Gravity
use cosmic::cosmic_config::{self, ConfigSet};
use cosmic::cosmic_theme::{self, CosmicPalette};
use cosmic::desktop::fde::{DesktopEntry, get_languages_from_env};
use cosmic::iced::core::text::{Ellipsize, EllipsizeHeightLimit};
use cosmic::iced::event::listen_with;
use cosmic::iced::event::wayland::OutputEvent;
use cosmic::iced::futures::SinkExt;
@ -19,15 +18,14 @@ use cosmic::iced::platform_specific::runtime::wayland::layer_surface::{
IcedMargin, IcedOutput, SctkLayerSurfaceSettings,
};
use cosmic::iced::platform_specific::shell::wayland::commands::layer_surface::{
Anchor, KeyboardInteractivity, Layer, destroy_layer_surface,
Anchor, KeyboardInteractivity, Layer, destroy_layer_surface, get_layer_surface,
};
use cosmic::iced::platform_specific::shell::wayland::commands::subsurface::reposition_subsurface;
use cosmic::iced::runtime::core::window::Id as SurfaceId;
use cosmic::iced::runtime::platform_specific::wayland::subsurface::SctkSubsurfaceSettings;
use cosmic::iced::{
self, Alignment, Background, Border, Length, Point, Rectangle, Size, Subscription, window,
self, Alignment, Background, Border, Length, Point, Size, Subscription, window,
};
use cosmic::surface::action::{LiveSettings, app_layer_shell};
use cosmic::widget::{id_container, text};
use cosmic::{Element, executor, surface, theme, widget};
use cosmic_greeter_config::Config as CosmicGreeterConfig;
@ -42,7 +40,7 @@ use std::num::NonZeroU32;
use std::process::Stdio;
use std::sync::{Arc, LazyLock};
use std::time::{Duration, Instant};
use std::{fs, io, process, thread};
use std::{fs, io, process};
use tokio::process::Child;
use tokio::time;
use tracing::metadata::LevelFilter;
@ -53,7 +51,7 @@ use wayland_client::Proxy;
use wayland_client::protocol::wl_output::WlOutput;
use zbus::{Connection, proxy};
use crate::common::{self, Common, DEFAULT_MENU_ITEM_HEIGHT, MAX_WIDTH};
use crate::common::{self, Common, DEFAULT_MENU_ITEM_HEIGHT};
use crate::fl;
static USERNAME_ID: LazyLock<iced::id::Id> = LazyLock::new(|| iced::id::Id::new("username-id"));
@ -78,8 +76,8 @@ async fn user_data_dbus() -> Result<Vec<UserData>, Box<dyn Error>> {
Ok(user_datas)
}
async fn user_data_fallback() -> Vec<UserData> {
let user_filter = UserFilter::new().await;
fn user_data_fallback() -> Vec<UserData> {
let user_filter = UserFilter::new();
// The pwd::Passwd method is unsafe (but not labelled as such) due to using global state (libc pwent functions).
/* unsafe */
@ -131,7 +129,7 @@ pub fn main() -> Result<(), Box<dyn Error>> {
Ok(ok) => ok,
Err(err) => {
tracing::error!("failed to load user data from daemon: {}", err);
runtime.block_on(user_data_fallback())
user_data_fallback()
}
};
@ -281,22 +279,6 @@ pub fn main() -> Result<(), Box<dyn Error>> {
sessions
};
match process::Command::new("cosmic-osk")
.arg("overlay")
.env("RUST_LOG", "cosmic_osk=info")
.spawn()
{
Ok(mut child) => {
thread::spawn(move || match child.wait() {
Ok(status) => tracing::warn!("cosmic-osk exited: {}", status),
Err(err) => tracing::error!("failed to wait on cosmic-osk: {}", err),
});
}
Err(err) => {
tracing::error!("failed to spawn cosmic-osk: {}", err);
}
}
let flags = Flags {
user_icons: user_datas
.iter_mut()
@ -306,10 +288,6 @@ pub fn main() -> Result<(), Box<dyn Error>> {
sessions,
greeter_config,
greeter_config_handler,
#[cfg(feature = "logind")]
logind_available: crate::logind::is_available(),
#[cfg(not(feature = "logind"))]
logind_available: false,
};
let settings = Settings::default().no_main_window(true);
@ -326,7 +304,6 @@ pub struct Flags {
sessions: HashMap<String, (Vec<String>, Vec<String>)>,
greeter_config: CosmicGreeterConfig,
greeter_config_handler: Option<cosmic_config::Config>,
logind_available: bool,
}
#[derive(Clone, Debug)]
@ -381,9 +358,6 @@ pub enum Message {
Common(common::Message),
OutputEvent(OutputEvent, WlOutput),
Auth(Option<String>),
/// Non-fatal error message from PAM (`PAM_ERROR_MSG`), reported by greetd as an auth
/// message of type `Error`. Unlike [`Message::Error`] the conversation stays alive.
AuthError(String),
ConfigUpdateUser,
DialogCancel,
DialogConfirm,
@ -407,7 +381,7 @@ pub enum Message {
Session(String),
Shutdown,
Socket(SocketState),
Surface(surface::Action<Message>),
Surface(surface::Action),
Suspend,
Username(String),
EnterUser(bool, String),
@ -499,9 +473,9 @@ impl App {
.window_size
.get(&id)
.map(|s| s.width)
.unwrap_or(MAX_WIDTH);
let menu_width = if window_width > MAX_WIDTH {
MAX_WIDTH
.unwrap_or(800.);
let menu_width = if window_width > 800. {
800.
} else {
window_width
};
@ -563,7 +537,7 @@ impl App {
let dropdown_menu = |items: Vec<_>| {
let item_cnt = items.len();
let items = widget::menu::menu_column::MenuColumn::with_children(items);
let items = widget::column::with_children(items);
let items = if item_cnt > 7 {
Element::from(
widget::scrollable(items)
@ -573,12 +547,12 @@ impl App {
Element::from(items)
};
let menu = widget::container(items)
widget::container(items)
.padding(1)
//TODO: move style to libcosmic
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background(theme.transparent).component;
let component = &cosmic.background(false).component;
widget::container::Style {
icon_color: Some(component.on.into()),
text_color: Some(component.on.into()),
@ -591,29 +565,13 @@ impl App {
..Default::default()
}
}))
.width(Length::Fixed(240.0));
if let Some(t) = self.common.rectangle_tracker.as_ref() {
Element::from(t.container((id, true), menu))
} else {
menu.into()
}
.width(Length::Fixed(240.0))
};
let mut input_button = widget::popover(
widget::container(
widget::button::custom(
widget::text(
self.common.active_layouts[self.common.current_keyboard_layout].name(),
)
.ellipsize(Ellipsize::End(EllipsizeHeightLimit::Lines(1)))
.height(16)
.center(),
)
widget::button::custom(widget::icon::from_name("input-keyboard-symbolic"))
.padding(12.0)
.on_press(Message::DropdownToggle(Dropdown::Keyboard)),
)
.max_width(80),
)
.position(widget::popover::Position::Bottom);
if matches!(self.dropdown_opt, Some(Dropdown::Keyboard)) {
@ -621,7 +579,7 @@ impl App {
for (i, layout) in self.common.active_layouts.iter().enumerate() {
items.push(menu_checklist(
&layout.description,
i == self.common.current_keyboard_layout,
i == 0,
Message::KeyboardLayout(i),
));
}
@ -723,19 +681,12 @@ impl App {
let accessibility_button = accessibility_dropdown;
let mut button_row = iced::widget::row![
let button_row = iced::widget::row![
widget::tooltip(
accessibility_button,
text(fl!("accessibility")),
widget::tooltip::Position::Top
),
widget::tooltip(
widget::button::custom(widget::icon::from_name("input-keyboard-symbolic"))
.padding(12.0)
.on_press(Message::Common(common::Message::OnScreenKeyboard)),
text(fl!("on-screen-keyboard")),
widget::tooltip::Position::Top,
),
widget::tooltip(
input_button,
text(fl!("keyboard-layout")),
@ -751,32 +702,30 @@ impl App {
text(fl!("session")),
widget::tooltip::Position::Top
),
];
if self.flags.logind_available {
button_row = button_row
.push(widget::tooltip(
widget::button::custom(widget::icon::from_name("system-suspend-symbolic"))
.padding(12.0)
.on_press(Message::Suspend),
text(fl!("suspend")),
widget::tooltip::Position::Top,
))
.push(widget::tooltip(
widget::button::custom(widget::icon::from_name("system-reboot-symbolic"))
.padding(12.0)
.on_press(Message::Restart),
text(fl!("restart")),
widget::tooltip::Position::Top,
))
.push(widget::tooltip(
widget::button::custom(widget::icon::from_name("system-shutdown-symbolic"))
.padding(12.0)
.on_press(Message::Shutdown),
text(fl!("shutdown")),
widget::tooltip::Position::Top,
));
}
let button_row = button_row.padding([16.0, 0.0, 0.0, 0.0]).spacing(8.0);
widget::tooltip(
widget::button::custom(widget::icon::from_name("system-suspend-symbolic"))
.padding(12.0)
.on_press(Message::Suspend),
text(fl!("suspend")),
widget::tooltip::Position::Top
),
widget::tooltip(
widget::button::custom(widget::icon::from_name("system-reboot-symbolic"))
.padding(12.0)
.on_press(Message::Restart),
text(fl!("restart")),
widget::tooltip::Position::Top
),
widget::tooltip(
widget::button::custom(widget::icon::from_name("system-shutdown-symbolic"))
.padding(12.0)
.on_press(Message::Shutdown),
text(fl!("shutdown")),
widget::tooltip::Position::Top
)
]
.padding([16.0, 0.0, 0.0, 0.0])
.spacing(8.0);
widget::container(iced::widget::column![
date_time_column,
@ -979,37 +928,29 @@ impl App {
},
)
};
let menu = widget::layer_container(
iced::widget::row![left_element, right_element].align_y(Alignment::Start),
)
.layer(cosmic::cosmic_theme::Layer::Background)
.padding(16)
.class(cosmic::theme::Container::Custom(Box::new(
|theme: &cosmic::Theme| {
// Use background appearance as the base
let mut appearance =
widget::container::Catalog::style(theme, &cosmic::theme::Container::Background);
appearance.background = Some(iced::Background::Color(
// TODO if we can use popups instead of subsurfaces for the greeter and the lockscreen
// then we can allow transparency
theme.cosmic().background(theme.transparent).base.into(),
));
appearance.border = iced::Border::default().rounded(16);
appearance
},
)))
.width(Length::Fixed(MAX_WIDTH));
let menu = if let Some(t) = self.common.rectangle_tracker.as_ref() {
Element::from(t.container((id, false), menu))
} else {
menu.into()
};
let menu = widget::container(widget::column::with_children(vec![
widget::space::vertical()
.height(Length::FillPortion(1))
.into(),
menu,
widget::layer_container(
iced::widget::row![left_element, right_element].align_y(Alignment::Start),
)
.layer(cosmic::cosmic_theme::Layer::Background)
.padding(16)
.class(cosmic::theme::Container::Custom(Box::new(
|theme: &cosmic::Theme| {
// Use background appearance as the base
let mut appearance = widget::container::Catalog::style(
theme,
&cosmic::theme::Container::Background,
);
appearance.border = iced::Border::default().rounded(16);
appearance
},
)))
.class(cosmic::theme::Container::Background)
.width(Length::Fixed(800.0))
.into(),
widget::space::vertical()
.height(Length::FillPortion(4))
.into(),
@ -1018,7 +959,6 @@ impl App {
.height(Length::Fill)
.align_x(Alignment::Center);
// TODO make these opaque?
let popover = widget::popover(menu).modal(true);
match self.dialog_page_opt {
Some(DialogPage::Restart(instant)) => {
@ -1073,6 +1013,19 @@ impl App {
}
}
fn set_xkb_config(&self) {
let user_data = match self
.selected_username
.data_idx
.and_then(|i| self.flags.user_datas.get(i))
{
Some(some) => some,
None => return,
};
self.common.set_xkb_config(user_data);
}
fn update_user_data(&mut self) -> Task<Message> {
let user_data = match self
.selected_username
@ -1087,6 +1040,9 @@ impl App {
self.common.update_user_data(user_data);
// Ensure that user's xkb config is used
self.common.set_xkb_config(user_data);
if let Some(builder) = &user_data.theme_builder_opt {
self.theme_builder = builder.clone();
}
@ -1134,8 +1090,7 @@ impl cosmic::Application for App {
}
/// Creates the application, and optionally emits command on initialize.
fn init(mut core: Core, flags: Self::Flags) -> (Self, Task<Message>) {
core.set_app_type(cosmic::core::AppType::System);
fn init(core: Core, flags: Self::Flags) -> (Self, Task<Message>) {
let mut tasks = Vec::new();
let (mut common, common_task) = Common::init(core);
common.on_output_event = Some(Box::new(|output_event, output| {
@ -1216,12 +1171,6 @@ impl cosmic::Application for App {
fn update(&mut self, message: Self::Message) -> Task<Message> {
match message {
Message::Common(common_message) => {
if matches!(&common_message, common::Message::Prompt(_, _, Some(_)))
&& self.authenticating
{
self.authenticating = false;
self.common.prompt_opt = None;
}
// In greetd's IPC protocol, the greeter must acknowledge auth messages by
// sending PostAuthMessageResponse. For non-interactive "info" messages
// (fingerprint prompts typically come through here), the correct response
@ -1287,10 +1236,10 @@ impl cosmic::Application for App {
let unwrapped_size = size
.map(|s| (s.0.unwrap_or(1920), s.1.unwrap_or(1080)))
.unwrap_or((1920, 1080));
let (loc, sub_size) = if unwrapped_size.0 as f32 > MAX_WIDTH {
let (loc, sub_size) = if unwrapped_size.0 > 800 {
(
Point::new((unwrapped_size.0 as f32 - MAX_WIDTH) / 2., 32.),
Size::new(MAX_WIDTH, unwrapped_size.1 as f32 - 32.),
Point::new(unwrapped_size.0 as f32 / 2. - 400., 32.),
Size::new(800., unwrapped_size.1 as f32 - 32.),
)
} else {
(
@ -1302,12 +1251,7 @@ impl cosmic::Application for App {
surface_id,
Size::new(unwrapped_size.0 as f32, unwrapped_size.1 as f32),
);
self.common
.subsurface_rects
.insert(output.clone(), Rectangle::new(loc, sub_size));
self.common
.subsurface_outputs
.insert(subsurface_id, output.clone());
let msg = cosmic::surface::action::subsurface(
move |_: &mut App| SctkSubsurfaceSettings {
parent: surface_id,
@ -1326,41 +1270,27 @@ impl cosmic::Application for App {
);
return Task::batch([
self.update_user_data(),
cosmic::surface::surface_task(app_layer_shell(
|_: &App| LiveSettings {
padding: None,
corners: None,
blur: Some(false),
get_layer_surface(SctkLayerSurfaceSettings {
id: surface_id,
layer: Layer::Overlay,
keyboard_interactivity: KeyboardInteractivity::Exclusive,
input_zone: None,
anchor: Anchor::TOP | Anchor::LEFT | Anchor::BOTTOM | Anchor::RIGHT,
output: IcedOutput::Output(output),
namespace: "cosmic-locker".into(),
size: Some((None, None)),
margin: IcedMargin {
top: 0,
bottom: 0,
left: 0,
right: 0,
},
move |_: &mut App| {
let output = output.clone();
SctkLayerSurfaceSettings {
id: surface_id,
layer: Layer::Top,
keyboard_interactivity: KeyboardInteractivity::Exclusive,
input_zone: None,
anchor: Anchor::TOP
| Anchor::LEFT
| Anchor::BOTTOM
| Anchor::RIGHT,
output: IcedOutput::Output(output),
namespace: "cosmic-greeter".into(),
size: Some((None, None)),
margin: IcedMargin {
top: 0,
bottom: 0,
left: 0,
right: 0,
},
exclusive_zone: -1,
size_limits: iced::Limits::NONE
.min_width(1.0)
.min_height(1.0),
}
},
None,
exclusive_zone: -1,
size_limits: iced::Limits::NONE.min_width(1.0).min_height(1.0),
}),
cosmic::task::message(cosmic::Action::Cosmic(
cosmic::app::Action::Surface(msg),
)),
cosmic::task::message(cosmic::Action::Surface(msg)),
]);
}
OutputEvent::Removed => {
@ -1400,7 +1330,6 @@ impl cosmic::Application for App {
self.selected_session = selected_session;
if self.dropdown_opt == Some(Dropdown::Session) {
self.dropdown_opt = None;
return self.common.dropdown_blur_rects(false);
}
}
Message::EnterUser(focus_input, username) => {
@ -1417,10 +1346,7 @@ impl cosmic::Application for App {
username,
};
if focus_input {
return Task::batch([
self.common.dropdown_blur_rects(false),
widget::text_input::focus(USERNAME_ID.clone()),
]);
return widget::text_input::focus(USERNAME_ID.clone());
}
}
Message::Username(username) => {
@ -1458,12 +1384,9 @@ impl cosmic::Application for App {
self.send_request(Request::CancelSession);
}
if let Some(randr_list) = self.randr_list.as_ref() {
return Task::batch([
self.common.dropdown_blur_rects(false),
self.update(Message::RandrUpdate {
randr: Arc::new(Ok(randr_list.clone())),
}),
]);
return self.update(Message::RandrUpdate {
randr: Arc::new(Ok(randr_list.clone())),
});
}
}
}
@ -1544,20 +1467,10 @@ impl cosmic::Application for App {
}
}
Message::Auth(response) => {
if response.as_deref() == Some("") {
return Task::none();
}
self.common.error_opt = None;
self.authenticating = true;
self.send_request(Request::PostAuthMessageResponse { response });
}
Message::AuthError(error) => {
// The conversation continues, so acknowledge like any other
// non-interactive auth message rather than cancelling the session.
self.common.error_opt = Some(error);
self.authenticating = false;
self.send_request(Request::PostAuthMessageResponse { response: None });
}
Message::Login => {
self.common.prompt_opt = None;
self.common.error_opt = None;
@ -1585,9 +1498,6 @@ impl cosmic::Application for App {
if let Some(handle) = self.heartbeat_handle.take() {
handle.abort();
}
if self.dropdown_opt.is_some() {
return self.common.dropdown_blur_rects(true);
}
}
Message::DialogConfirm => match self.dialog_page_opt.take() {
Some(DialogPage::Restart(_)) => {
@ -1614,26 +1524,20 @@ impl cosmic::Application for App {
})
.discard();
}
None => {
if self.dropdown_opt.is_some() {
return self.common.dropdown_blur_rects(true);
}
}
None => {}
},
Message::DropdownToggle(dropdown) => {
if self.dropdown_opt == Some(dropdown) {
self.dropdown_opt = None;
return self.common.dropdown_blur_rects(false);
} else {
self.dropdown_opt = Some(dropdown);
return self.common.dropdown_blur_rects(true);
}
}
Message::KeyboardLayout(layout_i) => {
if let Some(keyboard_layout) = &self.common.keyboard_layout {
keyboard_layout.set_group(layout_i as u32);
if layout_i < self.common.active_layouts.len() {
self.common.active_layouts.swap(0, layout_i);
self.set_xkb_config();
}
self.common.current_keyboard_layout = layout_i;
if self.dropdown_opt == Some(Dropdown::Keyboard) {
self.dropdown_opt = None
}
@ -1679,8 +1583,7 @@ impl cosmic::Application for App {
.abortable();
self.heartbeat_handle = Some(handle);
self.common.include_menu = false;
return Task::batch(vec![self.common.dropdown_blur_rects(false), heartbeat]);
return heartbeat;
}
}
Message::Heartbeat => match self.dialog_page_opt {
@ -1708,7 +1611,9 @@ impl cosmic::Application for App {
self.greetd_sender = Some(sender);
}
Message::Surface(a) => {
return cosmic::task::message(cosmic::Action::Surface(a));
return cosmic::task::message(cosmic::Action::Cosmic(
cosmic::app::Action::Surface(a),
));
}
Message::ScreenReader(enabled) => {
if enabled
@ -1906,8 +1811,8 @@ impl cosmic::Application for App {
tracing::error!("Failed to find subsurface menu id");
return Task::none();
};
let loc = if size.width > MAX_WIDTH {
Point::new((size.width - MAX_WIDTH) / 2., 32.)
let loc = if size.width > 800. {
Point::new(size.width / 2. - 400., 32.)
} else {
Point::new(0., 32.)
};

3
src/greeter/ipc.rs
View file

@ -115,8 +115,7 @@ pub fn subscription() -> Subscription<Message> {
.await;
}
greetd_ipc::AuthMessageType::Error => {
// PAM_ERROR_MSG: a failed attempt, not a dead session.
_ = sender.send(Message::AuthError(auth_message)).await;
_ = sender.send(Message::Error(auth_message)).await;
}
},
greetd_ipc::Response::Error {

157
src/keyboard_layout_wayland.rs
View file

@ -1,157 +0,0 @@
use cctk::{
cosmic_protocols::keyboard_layout::v1::client::zcosmic_keyboard_layout_v1::ZcosmicKeyboardLayoutV1,
keyboard_layout::{KeyboardLayoutHandler, KeyboardLayoutState},
sctk::{
self,
registry::{ProvidesRegistryState, RegistryState},
seat::{Capability, SeatHandler, SeatState},
},
wayland_client::{
Connection, QueueHandle, delegate_noop,
globals::registry_queue_init,
protocol::{wl_keyboard, wl_seat},
},
};
use cosmic::iced;
use cosmic::iced::futures::{SinkExt, channel::mpsc, executor::block_on};
use std::{hash::Hash, thread};
#[derive(Clone, Debug)]
pub enum Event {
KeyboardLayout(ZcosmicKeyboardLayoutV1),
Group(usize),
}
pub fn subscription(connection: Connection) -> iced::Subscription<Event> {
#[derive(Clone)]
struct WaylandSubscription(Connection);
impl Hash for WaylandSubscription {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.0.backend().display_id().hash(state);
}
}
iced::Subscription::run_with(
WaylandSubscription(connection),
|WaylandSubscription(connection)| {
let connection = connection.clone();
iced::stream::channel(8, move |sender| async move {
thread::spawn(move || thread(connection, sender));
})
},
)
}
struct Keyboard {
seat: wl_seat::WlSeat,
keyboard_layout: ZcosmicKeyboardLayoutV1,
}
impl Drop for Keyboard {
fn drop(&mut self) {
self.keyboard_layout.destroy();
}
}
struct AppData {
seat_state: SeatState,
registry_state: RegistryState,
keyboard_layout_state: KeyboardLayoutState,
keyboard: Option<Keyboard>,
sender: mpsc::Sender<Event>,
}
impl KeyboardLayoutHandler for AppData {
fn group(
&mut self,
_conn: &Connection,
_qh: &QueueHandle<Self>,
_keyboard: &wl_keyboard::WlKeyboard,
_keyboard_layout: &ZcosmicKeyboardLayoutV1,
group: u32,
) {
let _ = block_on(self.sender.send(Event::Group(group as usize)));
}
}
impl ProvidesRegistryState for AppData {
fn registry(&mut self) -> &mut RegistryState {
&mut self.registry_state
}
sctk::registry_handlers![SeatState,];
}
impl SeatHandler for AppData {
fn seat_state(&mut self) -> &mut SeatState {
&mut self.seat_state
}
fn new_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_seat::WlSeat) {}
fn new_capability(
&mut self,
_conn: &Connection,
qh: &QueueHandle<Self>,
seat: wl_seat::WlSeat,
capability: Capability,
) {
if capability == Capability::Keyboard && self.keyboard.is_none() {
let keyboard = seat.get_keyboard(qh, ());
let keyboard_layout = self
.keyboard_layout_state
.get_keyboard_layout(&keyboard, qh);
keyboard.release();
if let Some(keyboard_layout) = keyboard_layout {
let _ = block_on(
self.sender
.send(Event::KeyboardLayout(keyboard_layout.clone())),
);
self.keyboard = Some(Keyboard {
seat,
keyboard_layout,
});
} else {
keyboard.release();
}
}
}
fn remove_capability(
&mut self,
_conn: &Connection,
_: &QueueHandle<Self>,
seat: wl_seat::WlSeat,
_capability: Capability,
) {
self.keyboard.take_if(|x| x.seat == seat);
}
fn remove_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, seat: wl_seat::WlSeat) {
self.keyboard.take_if(|x| x.seat == seat);
}
}
fn thread(conn: Connection, sender: mpsc::Sender<Event>) {
let (globals, mut event_queue) = registry_queue_init(&conn).unwrap();
let qh = event_queue.handle();
let registry_state = RegistryState::new(&globals);
let seat_state = SeatState::new(&globals, &qh);
let keyboard_layout_state = KeyboardLayoutState::new(&registry_state, &qh);
let mut app_data = AppData {
seat_state,
registry_state,
keyboard_layout_state,
keyboard: None,
sender,
};
loop {
event_queue.blocking_dispatch(&mut app_data).unwrap();
}
}
sctk::delegate_registry!(AppData);
sctk::delegate_seat!(AppData);
cctk::delegate_keyboard_layout!(AppData);
delegate_noop!(AppData: ignore wl_keyboard::WlKeyboard);

2
src/lib.rs
View file

@ -8,8 +8,6 @@ mod wayland;
mod common;
mod keyboard_layout_wayland;
mod localize;
#[cfg(feature = "logind")]

254
src/locker.rs
View file

@ -4,18 +4,16 @@
use color_eyre::eyre::WrapErr;
use cosmic::app::{Core, Settings, Task};
use cosmic::cctk::wayland_protocols::xdg::shell::client::xdg_positioner::Gravity;
use cosmic::iced::core::text::{Ellipsize, EllipsizeHeightLimit};
use cosmic::iced::event::wayland::{OutputEvent, SessionLockEvent};
use cosmic::iced::futures::{self, SinkExt};
use cosmic::iced::platform_specific::shell::wayland::commands::session_lock::{
destroy_lock_surface, lock, unlock,
destroy_lock_surface, get_lock_surface, lock, unlock,
};
use cosmic::iced::runtime::core::window::Id as SurfaceId;
use cosmic::iced::runtime::platform_specific::wayland::subsurface::SctkSubsurfaceSettings;
use cosmic::iced::{
self, Alignment, Background, Border, Length, Point, Rectangle, Size, Subscription,
};
use cosmic::surface::action::LiveSettings;
use cosmic::{Element, executor, surface, theme, widget};
use cosmic_config::CosmicConfigEntry;
use cosmic_greeter_daemon::{TimeAppletConfig, UserData};
@ -35,7 +33,7 @@ use tracing_subscriber::{EnvFilter, fmt};
use wayland_client::Proxy;
use wayland_client::protocol::wl_output::WlOutput;
use crate::common::{self, Common, DEFAULT_MENU_ITEM_HEIGHT, MAX_WIDTH};
use crate::common::{self, Common, DEFAULT_MENU_ITEM_HEIGHT};
use crate::fl;
fn lockfile_opt() -> Option<PathBuf> {
@ -88,10 +86,6 @@ pub fn main(user: pwd::Passwd) -> Result<(), Box<dyn std::error::Error>> {
.map(widget::image::Handle::from_bytes),
user_data,
lockfile_opt: lockfile_opt(),
#[cfg(feature = "logind")]
logind_available: crate::logind::is_available(),
#[cfg(not(feature = "logind"))]
logind_available: false,
};
let settings = Settings::default().no_main_window(true);
@ -253,7 +247,6 @@ pub struct Flags {
user_data: UserData,
user_icon: Option<widget::image::Handle>,
lockfile_opt: Option<PathBuf>,
logind_available: bool,
}
///TODO: this is custom code that should be better handled by libcosmic
@ -275,7 +268,7 @@ pub enum Message {
KeyboardLayout(usize),
Inhibit(Arc<OwnedFd>),
Submit(String),
Surface(surface::Action<Message>),
Surface(surface::Action),
Suspend,
TimeAppletConfig(TimeAppletConfig),
Error(String),
@ -327,9 +320,9 @@ impl App {
.window_size
.get(&surface_id)
.map(|s| s.width)
.unwrap_or(MAX_WIDTH);
let menu_width = if window_width > MAX_WIDTH {
MAX_WIDTH
.unwrap_or(800.);
let menu_width = if window_width > 800. {
800.
} else {
window_width
};
@ -379,7 +372,7 @@ impl App {
let dropdown_menu = |items: Vec<_>| {
let item_cnt = items.len();
let items = widget::menu::menu_column::MenuColumn::with_children(items);
let items = widget::column::with_children(items);
let items = if item_cnt > 7 {
Element::from(
widget::scrollable(items)
@ -389,48 +382,31 @@ impl App {
Element::from(items)
};
let menu: widget::Container<'_, Message, cosmic::prelude::Theme> =
widget::container(items)
.padding(1)
//TODO: move style to libcosmic
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background(theme.transparent).component;
widget::container::Style {
icon_color: Some(component.on.into()),
text_color: Some(component.on.into()),
background: Some(Background::Color(component.base.into())),
border: Border {
radius: 8.0.into(),
width: 1.0,
color: component.divider.into(),
},
..Default::default()
}
}))
.width(Length::Fixed(240.0));
if let Some(t) = self.common.rectangle_tracker.as_ref() {
Element::from(t.container((surface_id, true), menu))
} else {
menu.into()
}
widget::container(items)
.padding(1)
//TODO: move style to libcosmic
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background(false).component;
widget::container::Style {
icon_color: Some(component.on.into()),
text_color: Some(component.on.into()),
background: Some(Background::Color(component.base.into())),
border: Border {
radius: 8.0.into(),
width: 1.0,
color: component.divider.into(),
},
..Default::default()
}
}))
.width(Length::Fixed(240.0))
};
let mut input_button = widget::popover(
widget::container(
widget::button::custom(
widget::text(
self.common.active_layouts[self.common.current_keyboard_layout].name(),
)
.ellipsize(Ellipsize::End(EllipsizeHeightLimit::Lines(1)))
.height(16)
.center(),
)
widget::button::custom(widget::icon::from_name("input-keyboard-symbolic"))
.padding(12.0)
.on_press(Message::DropdownToggle(Dropdown::Keyboard)),
)
.max_width(80),
)
.position(widget::popover::Position::Bottom);
if matches!(self.dropdown_opt, Some(Dropdown::Keyboard)) {
@ -438,7 +414,7 @@ impl App {
for (i, layout) in self.common.active_layouts.iter().enumerate() {
items.push(menu_checklist(
&layout.description,
i == self.common.current_keyboard_layout,
i == 0,
Message::KeyboardLayout(i),
));
}
@ -446,7 +422,7 @@ impl App {
}
//TODO: implement these buttons
let mut button_row = iced::widget::row![
let button_row = iced::widget::row![
/*TODO: greeter accessibility options
widget::button::custom(widget::icon::from_name(
"applications-accessibility-symbolic"
@ -454,29 +430,21 @@ impl App {
.padding(12.0)
.on_press(Message::None),
*/
widget::tooltip(
widget::button::custom(widget::icon::from_name("input-keyboard-symbolic"))
.padding(12.0)
.on_press(Message::Common(common::Message::OnScreenKeyboard)),
widget::text(fl!("on-screen-keyboard")),
widget::tooltip::Position::Top,
),
widget::tooltip(
input_button,
widget::text(fl!("keyboard-layout")),
widget::tooltip::Position::Top
),
];
if cfg!(feature = "logind") && self.flags.logind_available {
button_row = button_row.push(widget::tooltip(
widget::tooltip(
widget::button::custom(widget::icon::from_name("system-suspend-symbolic"))
.padding(12.0)
.on_press(Message::Suspend),
widget::text(fl!("suspend")),
widget::tooltip::Position::Top,
));
}
let button_row = button_row.padding([16.0, 0.0, 0.0, 0.0]).spacing(8.0);
widget::tooltip::Position::Top
),
]
.padding([16.0, 0.0, 0.0, 0.0])
.spacing(8.0);
widget::container(iced::widget::column![
date_time_column,
@ -617,34 +585,30 @@ impl App {
.align_x(Alignment::Center)
.width(Length::Fill)
};
let menu = widget::layer_container(
iced::widget::row![left_element, right_element].align_y(Alignment::Start),
)
.layer(cosmic::cosmic_theme::Layer::Background)
.padding(16)
.class(cosmic::theme::Container::Custom(Box::new(
|theme: &cosmic::Theme| {
// Use background appearance as the base
let mut appearance =
widget::container::Catalog::style(theme, &cosmic::theme::Container::Background);
let c: iced::Color = theme.cosmic().background(theme.transparent).base.into();
appearance.background = Some(iced::Background::Color(c));
appearance.border = iced::Border::default().rounded(16.0);
appearance
},
)))
.width(Length::Fill)
.height(Length::Shrink);
let menu = if let Some(t) = self.common.rectangle_tracker.as_ref() {
Element::from(t.container((surface_id, false), menu))
} else {
menu.into()
};
widget::container(widget::column::with_children(vec![
widget::space::vertical()
.height(Length::FillPortion(1))
.into(),
menu,
widget::layer_container(
iced::widget::row![left_element, right_element].align_y(Alignment::Start),
)
.layer(cosmic::cosmic_theme::Layer::Background)
.padding(16)
.class(cosmic::theme::Container::Custom(Box::new(
|theme: &cosmic::Theme| {
// Use background appearance as the base
let mut appearance = widget::container::Catalog::style(
theme,
&cosmic::theme::Container::Background,
);
appearance.border = iced::Border::default().rounded(16.0);
appearance
},
)))
.width(Length::Fill)
.height(Length::Shrink)
.into(),
widget::space::vertical()
.height(Length::FillPortion(4))
.into(),
@ -680,9 +644,7 @@ impl cosmic::Application for App {
}
/// Creates the application, and optionally emits command on initialize.
fn init(mut core: Core, flags: Self::Flags) -> (Self, Task<Self::Message>) {
core.set_app_type(cosmic::core::AppType::System);
fn init(core: Core, flags: Self::Flags) -> (Self, Task<Self::Message>) {
let (mut common, common_task) = Common::init(core);
common.on_output_event = Some(Box::new(|output_event, output| {
Message::OutputEvent(output_event, output)
@ -705,18 +667,18 @@ impl cosmic::Application for App {
authenticating: false,
};
let task = if cfg!(feature = "logind") && app.flags.logind_available {
let task = if cfg!(feature = "logind") {
if already_locked {
// Recover previously locked state
tracing::info!("recovering previous locked state");
app.state = State::Locking;
lock()
} else {
// When logind is available, wait for lock signal
// When logind feature is used, wait for lock signal
Task::none()
}
} else {
// When logind is not available, lock immediately
// When logind feature not used, lock immediately
tracing::info!("locking immediately");
app.state = State::Locking;
lock()
@ -730,12 +692,6 @@ impl cosmic::Application for App {
match message {
Message::None => {}
Message::Common(common_message) => {
if matches!(&common_message, common::Message::Prompt(_, _, Some(_)))
&& self.authenticating
{
self.authenticating = false;
self.common.prompt_opt = None;
}
return self.common.update(common_message);
}
Message::OutputEvent(output_event, output) => {
@ -758,10 +714,6 @@ impl cosmic::Application for App {
return Task::none();
}
self.common
.subsurface_outputs
.insert(subsurface_id, output.clone());
let size = if let Some((w, h)) =
output_info_opt.as_ref().and_then(|info| info.logical_size)
{
@ -801,10 +753,10 @@ impl cosmic::Application for App {
let unwrapped_size = size
.map(|s| (s.0.unwrap_or(1920), s.1.unwrap_or(1080)))
.unwrap_or((1920, 1080));
let (loc, sub_size) = if unwrapped_size.0 as f32 > MAX_WIDTH {
let (loc, sub_size) = if unwrapped_size.0 > 800 {
(
Point::new(unwrapped_size.0 as f32 / 2. - 400., 32.),
Size::new(MAX_WIDTH, unwrapped_size.1 as f32 - 32.),
Size::new(800., unwrapped_size.1 as f32 - 32.),
)
} else {
(
@ -839,19 +791,11 @@ impl cosmic::Application for App {
);
if matches!(self.state, State::Locked { .. }) {
return cosmic::task::message(cosmic::Action::Surface(
cosmic::surface::action::lock(
|| LiveSettings {
padding: None,
corners: None,
blur: Some(false),
},
surface_id,
output,
None::<fn() -> cosmic::Element<'static, cosmic::Action<Message>>>,
),
))
.chain(cosmic::task::message(cosmic::Action::Surface(msg)));
return Task::batch([get_lock_surface(surface_id, output).chain({
cosmic::task::message(cosmic::Action::Cosmic(
cosmic::app::Action::Surface(msg),
))
})]);
}
}
OutputEvent::Removed => {
@ -882,10 +826,10 @@ impl cosmic::Application for App {
let unwrapped_size = size
.map(|s| (s.0.unwrap_or(1920), s.1.unwrap_or(1080)))
.unwrap_or((1920, 1080));
let (loc, sub_size) = if unwrapped_size.0 as f32 > MAX_WIDTH {
let (loc, sub_size) = if unwrapped_size.0 > 800 {
(
Point::new(unwrapped_size.0 as f32 / 2. - 400., 32.),
Size::new(MAX_WIDTH, unwrapped_size.1 as f32 - 32.),
Size::new(800., unwrapped_size.1 as f32 - 32.),
)
} else {
(Point::ORIGIN, Size::new(1920., 1080.))
@ -991,18 +935,7 @@ impl cosmic::Application for App {
// Create lock surfaces
for (output, surface_id) in self.common.surface_ids.iter() {
commands.push(cosmic::task::message(cosmic::Action::Surface(
cosmic::surface::action::lock(
|| LiveSettings {
padding: None,
corners: None,
blur: Some(false),
},
*surface_id,
output.clone(),
None::<fn() -> cosmic::Element<'static, cosmic::Action<Message>>>,
),
)));
commands.push(get_lock_surface(*surface_id, output.clone()));
if let Some((rect, name)) = self
.common
@ -1012,15 +945,11 @@ impl cosmic::Application for App {
.zip(self.common.output_names.get(output))
{
let subsurface_id = SurfaceId::unique();
self.common
.subsurface_outputs
.insert(subsurface_id, output.clone());
let surface_id = *surface_id;
self.common.surface_names.insert(surface_id, name.clone());
self.common
.surface_names
.insert(subsurface_id, name.clone());
let msg = cosmic::surface::action::subsurface(
move |_: &mut App| SctkSubsurfaceSettings {
parent: surface_id,
@ -1037,9 +966,11 @@ impl cosmic::Application for App {
app.menu(subsurface_id).map(cosmic::Action::App)
})),
);
commands.push(cosmic::task::message(cosmic::Action::Surface(msg)));
commands.push(cosmic::task::message(cosmic::Action::Cosmic(
cosmic::app::Action::Surface(msg),
)));
} else {
tracing::error!("no rectangle for subsurface creation...");
tracing::error!("no rectangle for subsurface...");
}
}
return Task::batch(commands);
@ -1054,11 +985,11 @@ impl cosmic::Application for App {
self.common.window_size.remove(surface_id);
commands.push(destroy_lock_surface(*surface_id));
}
if cfg!(feature = "logind") && self.flags.logind_available {
if cfg!(feature = "logind") {
return Task::batch(commands);
// When logind is available, stick around for more lock signals
// When using logind feature, stick around for more lock signals
} else {
// When logind is not available, exit immediately after unlocking
// When not using logind feature, exit immediately after unlocking
//TODO: cleaner method to exit?
process::exit(0);
}
@ -1078,10 +1009,8 @@ impl cosmic::Application for App {
Message::DropdownToggle(dropdown) => {
if self.dropdown_opt == Some(dropdown) {
self.dropdown_opt = None;
return self.common.dropdown_blur_rects(false);
} else {
self.dropdown_opt = Some(dropdown);
return self.common.dropdown_blur_rects(true);
}
}
Message::Inhibit(inhibit) => match self.state {
@ -1093,19 +1022,15 @@ impl cosmic::Application for App {
}
},
Message::KeyboardLayout(layout_i) => {
if let Some(keyboard_layout) = &self.common.keyboard_layout {
keyboard_layout.set_group(layout_i as u32);
if layout_i < self.common.active_layouts.len() {
self.common.active_layouts.swap(0, layout_i);
self.common.set_xkb_config(&self.flags.user_data);
}
self.common.current_keyboard_layout = layout_i;
if self.dropdown_opt == Some(Dropdown::Keyboard) {
self.dropdown_opt = None;
return self.common.dropdown_blur_rects(false);
self.dropdown_opt = None
}
}
Message::Submit(value) => {
if value.is_empty() {
return Task::none();
}
self.common.error_opt = None;
self.authenticating = true;
match self.value_tx_opt.take() {
@ -1202,7 +1127,9 @@ impl cosmic::Application for App {
}
}
Message::Surface(a) => {
return cosmic::task::message(cosmic::Action::Surface(a));
return cosmic::task::message(cosmic::Action::Cosmic(
cosmic::app::Action::Surface(a),
));
}
}
Task::none()
@ -1214,8 +1141,17 @@ impl cosmic::Application for App {
}
/// Creates a view after each update.
fn view_window(&self, _surface_id: SurfaceId) -> Element<'_, Self::Message> {
widget::space::horizontal().into()
fn view_window(&self, surface_id: SurfaceId) -> Element<'_, Self::Message> {
let img = self
.common
.surface_images
.get(&surface_id)
.unwrap_or(&self.common.fallback_background);
widget::image(img)
.content_fit(iced::ContentFit::Cover)
.width(Length::Fill)
.height(Length::Fill)
.into()
}
fn subscription(&self) -> Subscription<Self::Message> {
@ -1254,7 +1190,7 @@ impl cosmic::Application for App {
);
#[cfg(feature = "logind")]
if self.flags.logind_available {
{
subscriptions.push(crate::logind::subscription());
}

21
src/logind.rs
View file

@ -13,27 +13,6 @@ use zbus::Connection;
use crate::common;
use crate::locker::Message;
/// Checks whether logind (either elogind or systemd-logind) is reachable on the system bus.
pub fn is_available() -> bool {
fn ping() -> zbus::Result<()> {
let connection = zbus::blocking::Connection::system()?;
connection.call_method(
Some("org.freedesktop.login1"),
"/org/freedesktop/login1",
Some("org.freedesktop.DBus.Peer"),
"Ping",
&(),
)?;
Ok(())
}
if let Err(err) = ping() {
tracing::info!("logind not available: {}", err);
false
} else {
true
}
}
pub async fn power_off() -> zbus::Result<()> {
let connection = Connection::system().await?;
let manager = ManagerProxy::new(&connection).await?;

3
src/main.rs
View file

@ -28,9 +28,6 @@ fn main() -> Result<(), Box<dyn Error>> {
}
}
// Enable jpeg-xl support for image-rs.
let _ = jxl_oxide::integration::register_image_decoding_hook();
match pwd::Passwd::current_user() {
Some(current_user) => match current_user.name.as_str() {
"cosmic-greeter" => greeter::main(),