use crate::canvas_protocol::SessionInvariant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ZoneId {
Header,
Primary,
Secondary,
Tertiary,
Footer,
Overlay,
}
#[derive(Debug, Clone)]
pub struct SessionStore {
invariant: Option<SessionInvariant>,
focused_zone: Option<String>,
active_workspace: Option<String>,
session_started_ms: Option<u64>,
display_name: Option<String>,
governance_visible: bool,
}
impl SessionStore {
#[must_use]
pub fn new() -> Self {
Self {
invariant: None,
focused_zone: None,
active_workspace: None,
session_started_ms: None,
display_name: None,
governance_visible: false,
}
}
pub fn start_session(
&mut self,
invariant: SessionInvariant,
display_name: Option<String>,
now_ms: u64,
) {
if self.invariant.as_ref() != Some(&invariant) {
self.focused_zone = None;
self.active_workspace = None;
self.governance_visible = false;
}
self.invariant = Some(invariant);
self.session_started_ms = Some(now_ms);
self.display_name = display_name;
}
#[must_use]
pub fn invariant(&self) -> Option<&SessionInvariant> {
self.invariant.as_ref()
}
#[must_use]
pub fn focused_zone(&self) -> Option<&str> {
self.focused_zone.as_deref()
}
#[must_use]
pub fn active_workspace(&self) -> Option<&str> {
self.active_workspace.as_deref()
}
#[must_use]
pub const fn session_started_ms(&self) -> Option<u64> {
self.session_started_ms
}
#[must_use]
pub fn display_name(&self) -> Option<&str> {
self.display_name.as_deref()
}
#[must_use]
pub const fn governance_visible(&self) -> bool {
self.governance_visible
}
pub fn set_focus(&mut self, zone: Option<String>) {
self.focused_zone = zone;
}
pub fn set_active_workspace(&mut self, workspace_id: Option<String>) {
self.active_workspace = workspace_id;
}
pub fn set_display_name(&mut self, name: Option<String>) {
self.display_name = name;
}
pub fn set_governance_visible(&mut self, visible: bool) {
self.governance_visible = visible;
}
}
impl Default for SessionStore {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum MountDecision {
Allowed,
Denied(MountDenialReason),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum MountDenialReason {
ZonePinned {
existing: Option<String>,
},
}
impl MountDenialReason {
#[must_use]
pub fn zone_pinned(existing: Option<String>) -> Self {
Self::ZonePinned { existing }
}
#[must_use]
pub fn existing(&self) -> Option<&String> {
match *self {
Self::ZonePinned { ref existing } => existing.as_ref(),
}
}
}
#[derive(Debug, Clone)]
pub struct ZoneContainer {
zone_id: ZoneId,
is_pinned: bool,
current_widget_id: Option<String>,
}
impl ZoneContainer {
#[must_use]
pub const fn new(zone_id: ZoneId) -> Self {
Self {
zone_id,
is_pinned: false,
current_widget_id: None,
}
}
#[must_use]
pub const fn zone_id(&self) -> ZoneId {
self.zone_id
}
#[must_use]
pub const fn is_pinned(&self) -> bool {
self.is_pinned
}
#[must_use]
pub fn current_widget_id(&self) -> Option<&str> {
self.current_widget_id.as_deref()
}
pub fn request_mount(&mut self, widget_id: String) -> MountDecision {
if self.is_pinned {
return MountDecision::Denied(MountDenialReason::zone_pinned(
self.current_widget_id.clone(),
));
}
self.current_widget_id = Some(widget_id);
MountDecision::Allowed
}
pub fn pin(&mut self) {
self.is_pinned = true;
}
pub fn unpin(&mut self) {
self.is_pinned = false;
}
pub fn clear(&mut self) {
self.current_widget_id = None;
}
}