use lgwks_std::json::serde::{Deserialize, Serialize};
use super::WidgetSurface;
mod descriptor;
mod error;
mod surface;
mod validate;
pub use descriptor::{WorkspaceSignalPattern, WorkspaceWidgetDescriptor};
pub use error::{WorkspaceLayoutError, WorkspaceLayoutIssue, WorkspaceLoadError};
pub use surface::{WorkspaceChrome, WorkspacePresentation, WorkspaceSurface, WorkspaceTool};
use validate::{
ensure, is_qualified_id, valid_optional_text, valid_text, validate_chrome, validate_surfaces,
validate_tools,
};
pub const WORKSPACE_LAYOUT_SCHEMA_VERSION: u16 = 1;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde", deny_unknown_fields)]
#[non_exhaustive]
pub struct WorkspaceLayout {
schema_version: u16,
layout_id: String,
title: String,
subtitle: String,
chrome: WorkspaceChrome,
surfaces: Vec<WorkspaceSurface>,
tools: Vec<WorkspaceTool>,
}
impl WorkspaceLayout {
#[must_use]
pub fn new(
schema_version: u16,
title: String,
layout_id: String,
subtitle: String,
chrome: WorkspaceChrome,
surfaces: Vec<WorkspaceSurface>,
tools: Vec<WorkspaceTool>,
) -> Self {
Self {
schema_version,
layout_id,
title,
subtitle,
chrome,
surfaces,
tools,
}
}
pub fn validate(&self) -> Result<(), WorkspaceLayoutError> {
ensure(
self.schema_version == WORKSPACE_LAYOUT_SCHEMA_VERSION,
WorkspaceLayoutIssue::UnsupportedSchemaVersion,
"schema_version",
)?;
ensure(
is_qualified_id(&self.layout_id),
WorkspaceLayoutIssue::InvalidLayoutId,
"layout_id",
)?;
ensure(
valid_text(&self.title, 80),
WorkspaceLayoutIssue::InvalidTitle,
"title",
)?;
ensure(
valid_optional_text(&self.subtitle, 120),
WorkspaceLayoutIssue::InvalidSubtitle,
"subtitle",
)?;
validate_chrome(&self.chrome)?;
validate_surfaces(&self.surfaces)?;
validate_tools(&self.tools)
}
pub fn web_renderer_input(&self) -> Result<WorkspaceLayout, WorkspaceLayoutError> {
self.validate()?;
let surfaces: Vec<WorkspaceSurface> = self
.surfaces
.iter()
.filter(|surface| surface.descriptor.surface != WidgetSurface::Native)
.cloned()
.collect();
let projected = WorkspaceLayout::new(
self.schema_version,
self.title.clone(),
self.layout_id.clone(),
self.subtitle.clone(),
self.chrome.clone(),
surfaces,
self.tools.clone(),
);
projected.validate()?;
Ok(projected)
}
#[must_use]
pub const fn schema_version(&self) -> u16 {
self.schema_version
}
pub fn set_schema_version(&mut self, schema_version: u16) {
self.schema_version = schema_version;
}
#[must_use]
pub fn layout_id(&self) -> &str {
&self.layout_id
}
pub fn set_layout_id(&mut self, layout_id: String) {
self.layout_id = layout_id;
}
#[must_use]
pub fn title(&self) -> &str {
&self.title
}
pub fn set_title(&mut self, title: String) {
self.title = title;
}
#[must_use]
pub fn subtitle(&self) -> &str {
&self.subtitle
}
pub fn set_subtitle(&mut self, subtitle: String) {
self.subtitle = subtitle;
}
#[must_use]
pub const fn chrome(&self) -> &WorkspaceChrome {
&self.chrome
}
#[must_use]
pub fn surfaces(&self) -> &[WorkspaceSurface] {
&self.surfaces
}
pub fn surfaces_mut(&mut self) -> &mut Vec<WorkspaceSurface> {
&mut self.surfaces
}
#[must_use]
pub fn tools(&self) -> &[WorkspaceTool] {
&self.tools
}
pub fn tools_mut(&mut self) -> &mut Vec<WorkspaceTool> {
&mut self.tools
}
}
pub fn load_validated(bytes: &[u8]) -> Result<WorkspaceLayout, WorkspaceLoadError> {
let layout: WorkspaceLayout = lgwks_std::json::from_slice(bytes)
.map_err(|error| WorkspaceLoadError::Decode(format!("{error}")))?;
layout.validate().map_err(WorkspaceLoadError::Invalid)?;
Ok(layout)
}