Refactor. Rename StrataState to Strata and StrataComp to Compositor

Signed-off-by: Anant Narayan <anantnrg@gmail.com>

src/backends/winit.rs

@@ -46,8 +46,8 @@ use crate::{
 	decorations::BorderShader,
 	state::{
 		self,
-		StrataComp,
-		StrataState,
+		Compositor,
+		Strata,
 	},
 };
 
@@ -57,7 +57,7 @@ pub struct WinitData {
 }
 
 pub fn init_winit() {
-	let mut event_loop: EventLoop<StrataState> = EventLoop::try_new().unwrap();
+	let mut event_loop: EventLoop<Strata> = EventLoop::try_new().unwrap();
 	let (display, socket) = state::init_wayland_listener(&event_loop);
 	let display_handle = display.handle();
 	let (backend, mut winit) = winit::init().unwrap();
@@ -71,11 +71,11 @@ pub fn init_winit() {
 			model: "Winit".into(),
 		},
 	);
-	let _global = output.create_global::<StrataComp>(&display_handle);
+	let _global = output.create_global::<Compositor>(&display_handle);
 	output.change_current_state(Some(mode), Some(Transform::Flipped180), None, Some((0, 0).into()));
 	output.set_preferred(mode);
 	let damage_tracker = OutputDamageTracker::from_output(&output);
-	let mut comp = StrataComp::new(
+	let mut comp = Compositor::new(
 		&event_loop,
 		&display,
 		socket,
@@ -134,11 +134,11 @@ pub fn init_winit() {
 		println!("{:#?}", e);
 	}
 
-	let mut data = StrataState { lua: lua_vm, comp, display };
+	let mut data = Strata { lua: lua_vm, comp, display };
 	event_loop.run(None, &mut data, move |_| {}).unwrap();
 }
 
-pub fn winit_dispatch(winit: &mut WinitEventLoop, state: &mut StrataState, output: &Output) {
+pub fn winit_dispatch(winit: &mut WinitEventLoop, state: &mut Strata, output: &Output) {
 	// process winit events
 	let res = winit.dispatch_new_events(|event| {
 		match event {

src/bindings.rs

@@ -9,11 +9,11 @@ use std::{
 
 use piccolo as lua;
 
-use crate::state::StrataComp;
+use crate::state::Compositor;
 
 pub mod input;
 
-pub fn register<'gc>(ctx: lua::Context<'gc>, comp: Rc<RefCell<StrataComp>>) -> anyhow::Result<()> {
+pub fn register<'gc>(ctx: lua::Context<'gc>, comp: Rc<RefCell<Compositor>>) -> anyhow::Result<()> {
 	let index = lua::Table::new(&ctx);
 	index.set(ctx, "input", input::module(ctx, comp.clone())?)?;
 	index.set(
@@ -32,7 +32,7 @@ pub fn register<'gc>(ctx: lua::Context<'gc>, comp: Rc<RefCell<StrataComp>>) -> a
 		lua::Callback::from_fn(&ctx, |ctx, _, mut stack| {
 			let comp = stack
 				.consume::<lua::UserData>(ctx)?
-				.downcast_static::<Rc<RefCell<StrataComp>>>()?;
+				.downcast_static::<Rc<RefCell<Compositor>>>()?;
 
 			comp.borrow_mut().quit();
 

src/bindings/input/key.rs

@@ -6,22 +6,21 @@ use std::{
 	rc::Rc,
 };
 
+use lua::FromValue;
+use piccolo as lua;
+
 use crate::{
 	handlers::input::{
 		Key,
 		KeyPattern,
 		ModFlags,
 	},
-	state::StrataComp,
-};
-use lua::FromValue;
-use piccolo::{
-	self as lua,
+	state::Compositor,
 };
 
 pub fn module<'gc>(
 	ctx: lua::Context<'gc>,
-	comp: Rc<RefCell<StrataComp>>,
+	comp: Rc<RefCell<Compositor>>,
 ) -> anyhow::Result<lua::Value<'gc>> {
 	let meta = lua::Table::from_value(ctx, Key::metatable(ctx)?)?;
 
@@ -32,7 +31,7 @@ pub fn module<'gc>(
 		lua::Callback::from_fn(&ctx, |ctx, _, mut stack| {
 			let (comp, mods, key, cb) =
 				stack.consume::<(lua::UserData, ModFlags, Key, lua::Function)>(ctx)?;
-			let comp = comp.downcast_static::<Rc<RefCell<StrataComp>>>()?;
+			let comp = comp.downcast_static::<Rc<RefCell<Compositor>>>()?;
 
 			let keypat = KeyPattern { mods, key };
 

src/bindings/input/mod.rs

@@ -1,22 +1,21 @@
 // Copyright 2023 the Strata authors
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-mod key;
-mod modflags;
-
 use std::{
 	cell::RefCell,
 	rc::Rc,
 };
 
-use crate::state::StrataComp;
-use piccolo::{
-	self as lua,
-};
+use piccolo as lua;
+
+use crate::state::Compositor;
+
+mod key;
+mod modflags;
 
 pub fn module<'gc>(
 	ctx: lua::Context<'gc>,
-	comp: Rc<RefCell<StrataComp>>,
+	comp: Rc<RefCell<Compositor>>,
 ) -> anyhow::Result<lua::Value<'gc>> {
 	let ud = lua::UserData::new_static(&ctx, comp.clone());
 	let meta = lua::Table::new(&ctx);

src/bindings/input/modflags.rs

@@ -14,7 +14,7 @@ use piccolo::{
 
 use crate::{
 	handlers::input::ModFlags,
-	state::StrataComp,
+	state::Compositor,
 };
 
 impl<'gc> FromValue<'gc> for ModFlags {
@@ -47,7 +47,7 @@ impl<'gc> FromValue<'gc> for ModFlags {
 
 pub fn module<'gc>(
 	ctx: lua::Context<'gc>,
-	comp: Rc<RefCell<StrataComp>>,
+	comp: Rc<RefCell<Compositor>>,
 ) -> anyhow::Result<lua::Value<'gc>> {
 	let meta = lua::Table::new(&ctx);
 

src/handlers/compositor.rs

@@ -67,13 +67,13 @@ use crate::{
 	handlers::xdg_shell::handle_commit,
 	state::{
 		ClientState,
-		StrataComp,
+		Compositor,
 	},
 	tiling::refresh_geometry,
 	workspaces::FocusTarget,
 };
 
-impl CompositorHandler for StrataComp {
+impl CompositorHandler for Compositor {
 	fn compositor_state(&mut self) -> &mut CompositorState {
 		&mut self.compositor_state
 	}
@@ -100,29 +100,29 @@ impl CompositorHandler for StrataComp {
 	}
 }
 
-delegate_compositor!(StrataComp);
+delegate_compositor!(Compositor);
 
-impl BufferHandler for StrataComp {
+impl BufferHandler for Compositor {
 	fn buffer_destroyed(
 		&mut self,
 		_buffer: &smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer,
 	) {
 	}
 }
 
-impl ShmHandler for StrataComp {
+impl ShmHandler for Compositor {
 	fn shm_state(&self) -> &ShmState {
 		&self.shm_state
 	}
 }
 
-delegate_shm!(StrataComp);
+delegate_shm!(Compositor);
 
-impl SeatHandler for StrataComp {
+impl SeatHandler for Compositor {
 	type KeyboardFocus = FocusTarget;
 	type PointerFocus = FocusTarget;
 
-	fn seat_state(&mut self) -> &mut SeatState<StrataComp> {
+	fn seat_state(&mut self) -> &mut SeatState<Compositor> {
 		&mut self.seat_state
 	}
 
@@ -164,35 +164,35 @@ impl SeatHandler for StrataComp {
 	}
 }
 
-delegate_seat!(StrataComp);
+delegate_seat!(Compositor);
 
-impl SelectionHandler for StrataComp {
+impl SelectionHandler for Compositor {
 	type SelectionUserData = ();
 }
 
-impl DataDeviceHandler for StrataComp {
+impl DataDeviceHandler for Compositor {
 	fn data_device_state(&self) -> &smithay::wayland::selection::data_device::DataDeviceState {
 		&self.data_device_state
 	}
 }
 
-impl ClientDndGrabHandler for StrataComp {}
-impl ServerDndGrabHandler for StrataComp {}
+impl ClientDndGrabHandler for Compositor {}
+impl ServerDndGrabHandler for Compositor {}
 
-delegate_data_device!(StrataComp);
+delegate_data_device!(Compositor);
 
-impl PrimarySelectionHandler for StrataComp {
+impl PrimarySelectionHandler for Compositor {
 	fn primary_selection_state(
 		&self,
 	) -> &smithay::wayland::selection::primary_selection::PrimarySelectionState {
 		&self.primary_selection_state
 	}
 }
 
-delegate_primary_selection!(StrataComp);
-delegate_output!(StrataComp);
+delegate_primary_selection!(Compositor);
+delegate_output!(Compositor);
 
-impl WlrLayerShellHandler for StrataComp {
+impl WlrLayerShellHandler for Compositor {
 	fn shell_state(&mut self) -> &mut WlrLayerShellState {
 		&mut self.layer_shell_state
 	}
@@ -233,4 +233,4 @@ impl WlrLayerShellHandler for StrataComp {
 	}
 }
 
-delegate_layer_shell!(StrataComp);
+delegate_layer_shell!(Compositor);