accounts are now real

src/bin/client/main.rs

@@ -2,8 +2,9 @@
 
 use crate::{
     app::App,
-    net::{NetCtrlMsg, NetHandle, NetSender, NetState},
+    net::{NetHandle, NetSender},
     rsc::{CLIENT_DATA, ClientData},
+    state::{ClientState, LoggedIn, Login},
     ui::*,
 };
 pub use app::AppHandle;
@@ -11,7 +12,7 @@ use arboard::Clipboard;
 use input::Input;
 use iris::prelude::*;
 use openworm::{
-    net::{ClientMsg, NetMsg, ServerMsg, install_crypto_provider},
+    net::{ClientMsg, ServerMsg, install_crypto_provider},
     rsc::DataDir,
 };
 use render::Renderer;
@@ -28,6 +29,7 @@ mod input;
 mod net;
 mod render;
 mod rsc;
+mod state;
 mod ui;
 
 fn main() {
@@ -35,28 +37,26 @@ fn main() {
     App::run();
 }
 
-pub enum ClientEvent {
-    Connect { send: NetSender, username: String },
-    ServerMsg(ServerMsg),
-    Err(String),
-}
-
 pub struct Client {
     renderer: Renderer,
     input: Input,
     ui: Ui,
     focus: Option<WidgetId<TextEdit>>,
-    channel: Option<WidgetId<Span>>,
-    username: String,
     clipboard: Clipboard,
     dir: DataDir,
     data: ClientData,
     handle: AppHandle,
-    error: Option<WidgetId<WidgetPtr>>,
-    net: NetState,
-    msgs: Vec<NetMsg>,
+    state: ClientState,
     ime: usize,
     last_click: Instant,
+    main_ui: WidgetId<WidgetPtr>,
+    notif: WidgetId<WidgetPtr>,
+}
+
+pub enum ClientEvent {
+    Connect { send: NetSender },
+    ServerMsg(ServerMsg),
+    Err(String),
 }
 
 impl Client {
@@ -70,62 +70,90 @@ impl Client {
         let dir = DataDir::default();
         let handle = AppHandle { proxy, window };
 
+        let mut ui = Ui::new();
+        let notif = WidgetPtr::default().add(&mut ui);
+        let main_ui = WidgetPtr::default().add(&mut ui);
+        (
+            notif.clone().pad(Padding::top(10)).align(Align::TOP_CENTER),
+            main_ui.clone(),
+        )
+            .stack()
+            .set_root(&mut ui);
+
         let mut s = Self {
             handle,
             renderer,
             input: Input::default(),
-            ui: Ui::new(),
+            ui,
             data: dir.load(CLIENT_DATA),
+            state: Default::default(),
             dir,
-            channel: None,
             focus: None,
-            net: Default::default(),
-            username: "<unknown>".to_string(),
             clipboard: Clipboard::new().unwrap(),
-            error: None,
             ime: 0,
             last_click: Instant::now(),
-            msgs: Vec::new(),
+            main_ui: main_ui.clone(),
+            notif,
         };
-        ui::init(&mut s);
+        connect_screen(&mut s).set_ptr(&main_ui, &mut s.ui);
         s
     }
 
     pub fn event(&mut self, event: ClientEvent, _: &ActiveEventLoop) {
         match event {
-            ClientEvent::Connect { send, username } => {
-                self.username = username;
-                send.send(ClientMsg::RequestMsgs);
-                let NetState::Connecting(th) = self.net.take() else {
+            ClientEvent::Connect { send } => {
+                let ClientState::Connect(state) = self.state.take() else {
                     panic!("invalid state");
                 };
-                self.net = NetState::Connected(NetHandle {
-                    send: send.clone(),
-                    thread: th,
+                let th = state.handle.unwrap();
+                self.state = ClientState::Login(Login {
+                    handle: NetHandle {
+                        send: send.clone(),
+                        thread: th,
+                    },
                 });
-                main_view(self, send).set_root(&mut self.ui);
+                login_screen(self).set_ptr(&self.main_ui, &mut self.ui);
             }
             ClientEvent::ServerMsg(msg) => match msg {
                 ServerMsg::SendMsg(msg) => {
-                    if let Some(msg_area) = &self.channel {
-                        let msg = msg_widget(msg).add(&mut self.ui);
+                    if let ClientState::LoggedIn(state) = &mut self.state
+                        && let Some(msg_area) = &state.channel
+                    {
+                        let msg = msg_widget(&msg.user, &msg.content).add(&mut self.ui);
                         self.ui[msg_area].children.push(msg.any());
                     }
                 }
                 ServerMsg::LoadMsgs(msgs) => {
-                    if let Some(msg_area) = &self.channel {
+                    if let ClientState::LoggedIn(state) = &mut self.state
+                        && let Some(msg_area) = &state.channel
+                    {
                         for msg in msgs {
-                            self.msgs.push(msg.clone());
-                            let msg = msg_widget(msg).add(&mut self.ui);
+                            state.msgs.push(msg.clone());
+                            let msg = msg_widget(&msg.user, &msg.content).add(&mut self.ui);
                             self.ui[msg_area].children.push(msg.any());
                         }
                     }
                 }
+                ServerMsg::Login { username } => {
+                    let ClientState::Login(state) = self.state.take() else {
+                        panic!("invalid state");
+                    };
+                    state.handle.send(ClientMsg::RequestMsgs);
+                    self.state = ClientState::LoggedIn(LoggedIn {
+                        network: state.handle,
+                        channel: None,
+                        msgs: Vec::new(),
+                        username,
+                    });
+                    main_view(self).set_ptr(&self.main_ui, &mut self.ui);
+                }
+                ServerMsg::Error(error) => {
+                    let msg = format!("{error:?}");
+                    self.ui[&self.notif].inner = Some(werror(&mut self.ui, &msg));
+                }
             },
             ClientEvent::Err(msg) => {
-                if let Some(err) = &self.error {
-                    self.ui[err].inner = Some(ui::error(&mut self.ui, &msg));
-                }
+                self.ui[&self.notif].inner = Some(werror(&mut self.ui, &msg));
             }
         }
     }
@@ -222,10 +250,7 @@ impl Client {
     }
 
     pub fn exit(&mut self) {
-        if let Some(handle) = self.net.take_connection() {
-            handle.send.send(NetCtrlMsg::Exit);
-            let _ = handle.thread.join();
-        }
+        self.state.exit();
         self.dir.save(CLIENT_DATA, &self.data);
     }
 }