Fix build on wayland and no display backend

crates/eww/src/app.rs

@@ -348,6 +348,7 @@ fn initialize_window(
 }
 
 /// Apply the provided window-positioning rules to the window.
+#[cfg(feature = "x11")]
 fn apply_window_position(
     mut window_geometry: WindowGeometry,
     monitor_geometry: gdk::Rectangle,

crates/eww/src/display_backend.rs

@@ -2,27 +2,27 @@ pub use platform::*;
 
 #[cfg(feature = "no-x11-wayland")]
 mod platform {
-    use crate::config::{EwwWindowDefinition, StrutDefinition, WindowStacking};
-    use anyhow::*;
-    use gtk::{self, prelude::*};
+    use crate::config::EwwWindowDefinition;
 
-    pub fn initialize_window(window_def: &EwwWindowDefinition, _monitor: gdk::Rectangle) -> Option<gtk::Window> {
+    pub fn initialize_window(_window_def: &EwwWindowDefinition, _monitor: gdk::Rectangle) -> Option<gtk::Window> {
         Some(gtk::Window::new(gtk::WindowType::Toplevel))
     }
 }
 
 #[cfg(feature = "wayland")]
 mod platform {
-    use crate::config::{AnchorAlignment, EwwWindowDefinition, WindowStacking};
     use gdk;
     use gtk::prelude::*;
+    use yuck::config::{window_definition::WindowStacking, window_geometry::AnchorAlignment};
+
+    use crate::config::EwwWindowDefinition;
 
     pub fn initialize_window(window_def: &EwwWindowDefinition, monitor: gdk::Rectangle) -> Option<gtk::Window> {
         let window = gtk::Window::new(gtk::WindowType::Toplevel);
         // Initialising a layer shell surface
         gtk_layer_shell::init_for_window(&window);
         // Sets the monitor where the surface is shown
-        match window_def.screen_number {
+        match window_def.monitor_number {
             Some(index) => {
                 if let Some(monitor) = gdk::Display::get_default().expect("could not get default display").get_monitor(index) {
                     gtk_layer_shell::set_monitor(&window, &monitor);

crates/yuck/Cargo.toml

@@ -6,6 +6,12 @@ edition = "2018"
 
 build = "build.rs"
 
+[features]
+default = ["x11"]
+x11 = []
+wayland = []
+no-x11-wayland = []
+
 [dependencies]
 lalrpop-util = "0.19.5"
 regex = "1"

crates/yuck/src/config/backend_window_options.rs

@@ -12,110 +12,123 @@ use eww_shared_util::Span;
 
 use super::{attributes::Attributes, window_definition::EnumParseError};
 
-pub type BackendWindowOptions = X11WindowOptions;
+pub use backend::*;
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
-pub struct X11WindowOptions {
-    pub wm_ignore: bool,
-    pub sticky: bool,
-    pub window_type: WindowType,
-    pub struts: StrutDefinition,
-}
+#[cfg(feature = "x11")]
+mod backend {
+    use super::*;
 
-impl X11WindowOptions {
-    pub fn from_attrs(attrs: &mut Attributes) -> AstResult<Self> {
-        let struts = attrs.ast_optional("reserve")?;
-        let window_type = attrs.primitive_optional("windowtype")?;
-        Ok(X11WindowOptions {
-            wm_ignore: attrs.primitive_optional("wm-ignore")?.unwrap_or(window_type.is_none() && struts.is_none()),
-            window_type: window_type.unwrap_or_default(),
-            sticky: attrs.primitive_optional("sticky")?.unwrap_or(true),
-            struts: struts.unwrap_or_default(),
-        })
+    #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+    pub struct BackendWindowOptions {
+        pub wm_ignore: bool,
+        pub sticky: bool,
+        pub window_type: WindowType,
+        pub struts: StrutDefinition,
     }
-}
 
-#[derive(Debug, Clone, PartialEq, Eq, smart_default::SmartDefault, serde::Serialize)]
-pub enum WindowType {
-    #[default]
-    Dock,
-    Dialog,
-    Toolbar,
-    Normal,
-    Utility,
-}
-impl FromStr for WindowType {
-    type Err = EnumParseError;
+    impl BackendWindowOptions {
+        pub fn from_attrs(attrs: &mut Attributes) -> AstResult<Self> {
+            let struts = attrs.ast_optional("reserve")?;
+            let window_type = attrs.primitive_optional("windowtype")?;
+            Ok(Self {
+                wm_ignore: attrs.primitive_optional("wm-ignore")?.unwrap_or(window_type.is_none() && struts.is_none()),
+                window_type: window_type.unwrap_or_default(),
+                sticky: attrs.primitive_optional("sticky")?.unwrap_or(true),
+                struts: struts.unwrap_or_default(),
+            })
+        }
+    }
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        enum_parse! { "window type", s,
-            "dock" => Self::Dock,
-            "toolbar" => Self::Toolbar,
-            "dialog" => Self::Dialog,
-            "normal" => Self::Normal,
-            "utility" => Self::Utility,
+    #[derive(Debug, Clone, PartialEq, Eq, smart_default::SmartDefault, serde::Serialize)]
+    pub enum WindowType {
+        #[default]
+        Dock,
+        Dialog,
+        Toolbar,
+        Normal,
+        Utility,
+    }
+    impl FromStr for WindowType {
+        type Err = EnumParseError;
+
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            enum_parse! { "window type", s,
+                "dock" => Self::Dock,
+                "toolbar" => Self::Toolbar,
+                "dialog" => Self::Dialog,
+                "normal" => Self::Normal,
+                "utility" => Self::Utility,
+            }
+        }
+    }
+
+    #[derive(Debug, Clone, Copy, Eq, PartialEq, smart_default::SmartDefault, serde::Serialize)]
+    pub enum Side {
+        #[default]
+        Top,
+        Left,
+        Right,
+        Bottom,
+    }
+
+    impl std::str::FromStr for Side {
+        type Err = EnumParseError;
+
+        fn from_str(s: &str) -> Result<Side, Self::Err> {
+            enum_parse! { "side", s,
+                "l" | "left" => Side::Left,
+                "r" | "right" => Side::Right,
+                "t" | "top" => Side::Top,
+                "b" | "bottom" => Side::Bottom,
+            }
+        }
+    }
+
+    // Surface definition if the backend for X11 is enable
+    #[derive(Debug, Clone, Copy, Eq, PartialEq, Default, serde::Serialize)]
+    pub struct StrutDefinition {
+        pub side: Side,
+        pub dist: NumWithUnit,
+    }
+
+    impl FromAstElementContent for StrutDefinition {
+        fn get_element_name() -> &'static str {
+            "struts"
+        }
+
+        fn from_tail<I: Iterator<Item = Ast>>(span: Span, mut iter: AstIterator<I>) -> AstResult<Self> {
+            let mut attrs = iter.expect_key_values()?;
+            Ok(StrutDefinition { side: attrs.primitive_required("side")?, dist: attrs.primitive_required("distance")? })
         }
     }
 }
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq, smart_default::SmartDefault, serde::Serialize)]
-pub enum Side {
-    #[default]
-    Top,
-    Left,
-    Right,
-    Bottom,
-}
-
-impl std::str::FromStr for Side {
-    type Err = EnumParseError;
-
-    fn from_str(s: &str) -> Result<Side, Self::Err> {
-        enum_parse! { "side", s,
-            "l" | "left" => Side::Left,
-            "r" | "right" => Side::Right,
-            "t" | "top" => Side::Top,
-            "b" | "bottom" => Side::Bottom,
+#[cfg(feature = "wayland")]
+mod backend {
+    use super::*;
+    #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+    pub struct BackendWindowOptions {
+        pub exclusive: bool,
+        pub focusable: bool,
+    }
+    impl BackendWindowOptions {
+        pub fn from_attrs(attrs: &mut Attributes) -> AstResult<Self> {
+            Ok(Self {
+                exclusive: attrs.primitive_optional("exclusive")?.unwrap_or(false),
+                focusable: attrs.primitive_optional("focusable")?.unwrap_or(false),
+            })
         }
     }
 }
 
-// Surface definition if the backend for X11 is enable
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Default, serde::Serialize)]
-pub struct StrutDefinition {
-    pub side: Side,
-    pub dist: NumWithUnit,
-}
-
-impl FromAstElementContent for StrutDefinition {
-    fn get_element_name() -> &'static str {
-        "struts"
-    }
-
-    fn from_tail<I: Iterator<Item = Ast>>(span: Span, mut iter: AstIterator<I>) -> AstResult<Self> {
-        let mut attrs = iter.expect_key_values()?;
-        Ok(StrutDefinition { side: attrs.primitive_required("side")?, dist: attrs.primitive_required("distance")? })
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
-pub struct WaylandWindowOptions {
-    pub exclusive: bool,
-    pub focusable: bool,
-}
-impl WaylandWindowOptions {
-    pub fn from_attrs(attrs: &mut Attributes) -> AstResult<Self> {
-        Ok(WaylandWindowOptions {
-            exclusive: attrs.primitive_optional("exclusive")?.unwrap_or(false),
-            focusable: attrs.primitive_optional("focusable")?.unwrap_or(false),
-        })
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
-pub struct NoBackendWindowOptions;
-impl NoBackendWindowOptions {
-    pub fn from_attrs(attrs: &mut Attributes) -> Result<Self> {
-        Ok(NoBackendWindowOptions)
+#[cfg(feature = "no-x11-wayland")]
+mod backend {
+    use super::*;
+    #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+    pub struct BackendWindowOptions;
+    impl BackendWindowOptions {
+        pub fn from_attrs(attrs: &mut Attributes) -> AstResult<Self> {
+            Ok(Self)
+        }
     }
 }