From ce68053a035c4130d649cc7bf57a9c39e204d337 Mon Sep 17 00:00:00 2001
From: Facundo Mendizabal <facu@fmzbl.com>
Date: Fri, 11 Oct 2024 16:31:40 -0300
Subject: [PATCH 1/5] Add login screen.

---
 src/app.rs                |  32 ++++-
 src/lib.rs                |   2 +
 src/login/login_screen.rs | 238 ++++++++++++++++++++++++++++++++++++++
 src/login/mod.rs          |   7 ++
 4 files changed, 275 insertions(+), 4 deletions(-)
 create mode 100644 src/login/login_screen.rs
 create mode 100644 src/login/mod.rs

diff --git a/src/app.rs b/src/app.rs
index 04fae7b9..1c9685f9 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -2,9 +2,7 @@ use makepad_widgets::*;
 use matrix_sdk::ruma::OwnedRoomId;
 
 use crate::{
-    home::rooms_list::RoomListAction,
-    verification::VerificationAction,
-    verification_modal::{VerificationModalAction, VerificationModalWidgetRefExt},
+    home::rooms_list::RoomListAction, login::login_screen::LoginAction, verification::VerificationAction, verification_modal::{VerificationModalAction, VerificationModalWidgetRefExt}
 };
 
 live_design! {
@@ -18,6 +16,7 @@ live_design! {
     import crate::home::room_screen::RoomScreen;
     import crate::profile::my_profile_screen::MyProfileScreen;
     import crate::verification_modal::VerificationModal;
+    import crate::login::login_screen::LoginScreen;
 
     ICON_CHAT = dep("crate://self/resources/icons/chat.svg")
     ICON_CONTACTS = dep("crate://self/resources/icons/contacts.svg")
@@ -102,6 +101,12 @@ live_design! {
         }
     }
 
+    // StackNavigationView without header
+    SimpleStackNavigationView = <StackNavigationView> {
+        header = <View> {width: 0, height: 0}
+        margin: 0
+    }
+
     App = {{App}} {
         ui: <Window> {
             window: {inner_size: vec2(1280, 800)},
@@ -113,7 +118,16 @@ live_design! {
                     width: Fill, height: Fill,
                     flow: Overlay,
 
-                    home_screen = <HomeScreen> {}
+                    navigation = <StackNavigation> {
+                        root_view = {
+                            login_screen = <LoginScreen> {}
+                        }
+                        stack_navigation_view_home_screen = <SimpleStackNavigationView> {
+                            body = {
+                                home_screen = <HomeScreen> {}
+                            }
+                        }
+                    }
 
                     verification_modal = <Modal> {
                         content: {
@@ -148,6 +162,7 @@ impl LiveRegister for App {
         crate::verification_modal::live_design(cx);
         crate::home::live_design(cx);
         crate::profile::live_design(cx);
+        crate::login::live_design(cx);
     }
 }
 
@@ -166,6 +181,14 @@ impl MatchEvent for App {
 
     fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions) {
         for action in actions {
+            match action.as_widget_action().cast() {
+                LoginAction::LoginSuccess => {
+                    let mut navigation = self.ui.stack_navigation(id!(navigation));
+                    navigation.show_stack_view_by_id(live_id!(stack_navigation_view_home_screen), cx)
+                }
+                LoginAction::None => { }
+            }
+
             match action.as_widget_action().cast() {
                 // A room has been selected, update the app state and navigate to the main content view.
                 RoomListAction::Selected {
@@ -244,6 +267,7 @@ impl AppMain for App {
 #[derive(Default, Debug)]
 pub struct AppState {
     pub rooms_panel: RoomsPanelState,
+    pub login_state: bool,
 }
 
 #[derive(Default, Debug)]
diff --git a/src/lib.rs b/src/lib.rs
index 1b4ecf74..14917b4d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,6 +6,8 @@ pub use makepad_widgets;
 pub mod app;
 pub mod persistent_state;
 
+/// Login screen
+pub mod login;
 /// Core UI content: the main home screen (rooms list), room screen.
 pub mod home;
 /// User profile info and a user profile sliding pane.
diff --git a/src/login/login_screen.rs b/src/login/login_screen.rs
new file mode 100644
index 00000000..eaca6c12
--- /dev/null
+++ b/src/login/login_screen.rs
@@ -0,0 +1,238 @@
+use makepad_widgets::*;
+
+live_design! {
+    import makepad_widgets::base::*;
+    import makepad_widgets::theme_desktop_dark::*;
+    import makepad_draw::shader::std::*;
+
+    import crate::shared::styles::*;
+    import crate::shared::icon_button::*;
+
+    IMG_APP_LOGO = dep("crate://self/packaging/robrix_logo_alpha.png")
+
+    LoginTextInput = <TextInput> {
+        width: Fill, height: Fit, margin: 0
+        align: {y: 0.5}
+        draw_bg: {
+            color: (COLOR_PRIMARY)
+            instance radius: 2.0
+            instance border_width: 0.8
+            instance border_color: #D0D5DD
+            instance inset: vec4(0.0, 0.0, 0.0, 0.0)
+
+            fn get_color(self) -> vec4 {
+                return self.color
+            }
+
+            fn get_border_color(self) -> vec4 {
+                return self.border_color
+            }
+
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size)
+                sdf.box(
+                    self.inset.x + self.border_width,
+                    self.inset.y + self.border_width,
+                    self.rect_size.x - (self.inset.x + self.inset.z + self.border_width * 2.0),
+                    self.rect_size.y - (self.inset.y + self.inset.w + self.border_width * 2.0),
+                    max(1.0, self.radius)
+                )
+                sdf.fill_keep(self.get_color())
+                if self.border_width > 0.0 {
+                    sdf.stroke(self.get_border_color(), self.border_width)
+                }
+                return sdf.result;
+            }
+        }
+
+        draw_text: {
+            color: (MESSAGE_TEXT_COLOR),
+            text_style: <MESSAGE_TEXT_STYLE>{},
+
+            fn get_color(self) -> vec4 {
+                return mix(
+                    self.color,
+                    #B,
+                    self.is_empty
+                )
+            }
+        }
+
+
+        // TODO find a way to override colors
+        draw_cursor: {
+            instance focus: 0.0
+            uniform border_radius: 0.5
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                sdf.box(
+                    0.,
+                    0.,
+                    self.rect_size.x,
+                    self.rect_size.y,
+                    self.border_radius
+                )
+                sdf.fill(mix(#fff, #bbb, self.focus));
+                return sdf.result
+            }
+        }
+
+        // TODO find a way to override colors
+        draw_selection: {
+            instance hover: 0.0
+            instance focus: 0.0
+            uniform border_radius: 2.0
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                sdf.box(
+                    0.,
+                    0.,
+                    self.rect_size.x,
+                    self.rect_size.y,
+                    self.border_radius
+                )
+                sdf.fill(mix(#eee, #ddd, self.focus)); // Pad color
+                return sdf.result
+            }
+        }
+    }
+
+    LoginScreen = {{LoginScreen}} {
+        show_bg: true,
+        draw_bg: {
+            color: (COLOR_PRIMARY)
+        }
+        align: {x: 0.5, y: 0.5}
+
+        <RoundedView> {
+            width: Fit, height: Fit
+            flow: Down
+            align: {x: 0.5, y: 0.5}
+            padding: 50
+            spacing: 20.0
+
+            show_bg: true,
+            draw_bg: {
+                color: (COLOR_SECONDARY)
+            }
+
+            logo_image = <Image> {
+                fit: Smallest,
+                width: 80
+                source: (IMG_APP_LOGO),
+            }
+
+            title = <Label> {
+                width: Fit, height: Fit
+                draw_text: {
+                    color: (COLOR_TEXT)
+                        text_style: <TITLE_TEXT>{font_size: 16.0}
+                }
+                text: "Login to Robrix"
+            }
+
+            username_input = <LoginTextInput> {
+                width: 300, height: 40
+                empty_message: "Username"
+            }
+
+            password_input = <LoginTextInput> {
+                width: 300, height: 40
+                empty_message: "Password"
+                // password: true
+            }
+
+            login_button = <RobrixIconButton > {
+                width: 300, height: 40
+                draw_text: {
+                    color: (COLOR_PRIMARY)
+                    text_style: <REGULAR_TEXT> {}
+                }
+
+                draw_bg: {
+                    color: (COLOR_SELECTED_PRIMARY)
+                }
+                    text: "Login"
+            }
+
+            error_message = <Label> {
+                width: 300, height: Fit
+                draw_text: {
+                    color: (COLOR_DANGER_RED)
+                    text_style: <REGULAR_TEXT> {}
+                }
+                text: ""
+            }
+
+            success_message = <Label> {
+                width: 300, height: Fit
+                draw_text: {
+                    color: (COLOR_ACCEPT_GREEN)
+                    text_style: <REGULAR_TEXT> {}
+                }
+                text: ""
+            }
+        }
+    }
+}
+
+#[derive(Live, LiveHook, Widget)]
+pub struct LoginScreen {
+    #[deref]
+    view: View,
+}
+
+impl Widget for LoginScreen {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        let widget_uid = self.widget_uid();
+
+        self.view.handle_event(cx, event, scope);
+
+        let password_input = self.view.text_input(id!(password_input));
+        let error_message_label = self.view.label(id!(error_message));
+        let success_message_label = self.view.label(id!(success_message));
+        let login_button = self.view.button(id!(login_button));
+
+        let username = self.view.text_input(id!(username_input)).text();
+        let password = self.view.text_input(id!(password_input)).text();
+
+        if let Event::Actions(actions) = event {
+            if login_button.clicked(actions) {
+                if username.is_empty() || password.is_empty() {
+                    error_message_label.set_text("Please enter both username and password.");
+                } else {
+                    // TODO: Implement actual login logic
+                    let mut login_successful = false;
+
+                    if password == "aa" {login_successful = true}
+
+                    if login_successful {
+                        cx.widget_action(
+                            widget_uid,
+                            &scope.path,
+                            LoginAction::LoginSuccess,
+                        );
+                        error_message_label.set_text("");
+                        success_message_label.set_text("Login successful!");
+                    } else {
+                        password_input.set_text("");
+                        error_message_label.set_text("Incorrect username or password.");
+                    }
+
+
+                }
+                self.redraw(cx);
+            }
+        }
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+#[derive(Clone, DefaultNone, Debug)]
+pub enum LoginAction {
+    None,
+    LoginSuccess,
+}
diff --git a/src/login/mod.rs b/src/login/mod.rs
new file mode 100644
index 00000000..64cf8399
--- /dev/null
+++ b/src/login/mod.rs
@@ -0,0 +1,7 @@
+use makepad_widgets::*;
+
+pub mod login_screen;
+
+pub fn live_design(cx: &mut Cx) {
+    login_screen::live_design(cx);
+}

From 57b58cd6ac8afc5ea487d7cfe608ce13a5511d06 Mon Sep 17 00:00:00 2001
From: Facundo Mendizabal <facu@fmzbl.com>
Date: Fri, 11 Oct 2024 16:40:59 -0300
Subject: [PATCH 2/5] remove unnecesary field

---
 src/app.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/app.rs b/src/app.rs
index 5e206fe1..16721542 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -281,7 +281,6 @@ impl AppMain for App {
 #[derive(Default, Debug)]
 pub struct AppState {
     pub rooms_panel: RoomsPanelState,
-    pub login_state: bool,
 }
 
 #[derive(Default, Debug)]

From 812d53e26228b6c12c417ffc8303f6fc89df601d Mon Sep 17 00:00:00 2001
From: Facundo Mendizabal <facu@fmzbl.com>
Date: Fri, 11 Oct 2024 22:09:22 -0300
Subject: [PATCH 3/5] fix margin

---
 src/app.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/app.rs b/src/app.rs
index 16721542..1d61fa01 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -104,8 +104,10 @@ live_design! {
 
     // StackNavigationView without header
     SimpleStackNavigationView = <StackNavigationView> {
-        header = <View> {width: 0, height: 0}
-        margin: 0
+        header = <View> {}
+        body = {
+            margin: 0
+        }
     }
 
     App = {{App}} {

From 869e239f1ab3d0e1e7334c093381eef99589d6df Mon Sep 17 00:00:00 2001
From: Kevin Boos <kevinaboos@gmail.com>
Date: Sat, 12 Oct 2024 13:07:10 -0700
Subject: [PATCH 4/5] Refactor login logic to support a login screen.

however, the top app-level stacknav doesn't cleanly transition from
the login screen to the rooms list
---
 .github/workflows/login-toml.yaml |  14 --
 login.toml                        |  21 ---
 src/app.rs                        |  22 ++-
 src/login/login_screen.rs         | 163 ++++++++++++++++------
 src/persistent_state.rs           |   8 +-
 src/sliding_sync.rs               | 217 +++++++++++++++++++-----------
 6 files changed, 276 insertions(+), 169 deletions(-)
 delete mode 100644 .github/workflows/login-toml.yaml
 delete mode 100644 login.toml

diff --git a/.github/workflows/login-toml.yaml b/.github/workflows/login-toml.yaml
deleted file mode 100644
index 7b4dfc07..00000000
--- a/.github/workflows/login-toml.yaml
+++ /dev/null
@@ -1,14 +0,0 @@
-name: Prevent modifying login.toml
-
-on: [push, pull_request]
-
-jobs:
-  prevent_modify_login_toml:
-    name: Prevent modifying login.toml
-    runs-on: ubuntu-latest
-    steps:
-    - name: Prevent modifying login.toml
-      uses: xalvarez/prevent-file-change-action@v1.6.0
-      with:
-        githubToken: ${{ secrets.GITHUB_TOKEN }}
-        pattern: login.toml
diff --git a/login.toml b/login.toml
deleted file mode 100644
index e5ec2440..00000000
--- a/login.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-username = " "
-password = " "
-homeserver = " "
-
-### Please fill in your username and password above.
-### The homeserver name/URL field is optional, but defaults to "matrix.org".
-###
-### Robrix does not yet have a login splash screen.
-### Thus, on desktop platforms, we allow the user to
-### pass in a username and password as command line arguments.
-###
-### However, on mobile platforms, there is no way to reliably
-### pass in command line arguments.
-### Instead, we enable the mobile apps to read them from a copy
-### of this file that is included in the app package files.
-###
-### Only the username, password, and homeserver fields are supported.
-###
-### Note that for obvious reasons you should not commit this file
-### or upload it to a public repo with your actual username and password in it.
-### Thus, we have added it to the .gitignore file.
diff --git a/src/app.rs b/src/app.rs
index 1d61fa01..fd1ec97c 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -183,13 +183,23 @@ impl MatchEvent for App {
     }
 
     fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions) {
+        self.ui.stack_navigation(id!(navigation))
+            .handle_stack_view_actions(cx, actions);
+
         for action in actions {
-            match action.as_widget_action().cast() {
-                LoginAction::LoginSuccess => {
-                    let mut navigation = self.ui.stack_navigation(id!(navigation));
-                    navigation.show_stack_view_by_id(live_id!(stack_navigation_view_home_screen), cx)
-                }
-                LoginAction::None => { }
+            if let Some(LoginAction::LoginSuccess) = action.downcast_ref() {
+                cx.widget_action(
+                    self.ui.widget_uid(),
+                    &Scope::default().path,
+                    StackNavigationAction::NavigateTo(live_id!(stack_navigation_view_home_screen)), 
+                );
+                // Try to trigger the home_screen to redraw or handle events.
+                self.ui.view(id!(home_screen)).redraw(cx);
+                SignalToUI::set_ui_signal();
+
+                // let mut navigation = self.ui.stack_navigation(id!(navigation));
+                // navigation.show_stack_view_by_id(live_id!(stack_navigation_view_home_screen), cx);
+                self.ui.redraw(cx);
             }
 
             match action.as_widget_action().cast() {
diff --git a/src/login/login_screen.rs b/src/login/login_screen.rs
index eaca6c12..056fab8f 100644
--- a/src/login/login_screen.rs
+++ b/src/login/login_screen.rs
@@ -1,5 +1,9 @@
+use std::ops::Not;
+
 use makepad_widgets::*;
 
+use crate::sliding_sync::{submit_async_request, LoginRequest, MatrixRequest};
+
 live_design! {
     import makepad_widgets::base::*;
     import makepad_widgets::theme_desktop_dark::*;
@@ -124,16 +128,17 @@ live_design! {
 
             title = <Label> {
                 width: Fit, height: Fit
+                margin: { bottom: 10 }
                 draw_text: {
                     color: (COLOR_TEXT)
-                        text_style: <TITLE_TEXT>{font_size: 16.0}
+                    text_style: <TITLE_TEXT>{font_size: 16.0}
                 }
                 text: "Login to Robrix"
             }
 
-            username_input = <LoginTextInput> {
+            user_id_input = <LoginTextInput> {
                 width: 300, height: 40
-                empty_message: "Username"
+                empty_message: "User ID"
             }
 
             password_input = <LoginTextInput> {
@@ -142,88 +147,143 @@ live_design! {
                 // password: true
             }
 
-            login_button = <RobrixIconButton > {
+            homeserver_input = <LoginTextInput> {
                 width: 300, height: 40
+                margin: {bottom: -15}
+                empty_message: "matrix.org"
+            }
+            <Label> {
+                width: Fit, height: Fit
                 draw_text: {
-                    color: (COLOR_PRIMARY)
-                    text_style: <REGULAR_TEXT> {}
+                    color: #x8c8c8c
+                    text_style: <REGULAR_TEXT>{font_size: 9}
                 }
+                text: "Homeserver (optional)"
+            }
 
+            login_button = <RobrixIconButton> {
+                width: 300, height: 40
+                margin: {top: 15}
                 draw_bg: {
                     color: (COLOR_SELECTED_PRIMARY)
                 }
-                    text: "Login"
+                draw_text: {
+                    color: (COLOR_PRIMARY)
+                    text_style: <REGULAR_TEXT> {}
+                }
+                text: "Login"
             }
 
-            error_message = <Label> {
+            status_label = <Label> {
                 width: 300, height: Fit
+                padding: {left: 5, right: 5}
                 draw_text: {
-                    color: (COLOR_DANGER_RED)
+                    color: (MESSAGE_TEXT_COLOR)
                     text_style: <REGULAR_TEXT> {}
                 }
                 text: ""
             }
 
-            success_message = <Label> {
-                width: 300, height: Fit
+            <Label> {
+                width: Fit, height: Fit
                 draw_text: {
-                    color: (COLOR_ACCEPT_GREEN)
-                    text_style: <REGULAR_TEXT> {}
+                    color: #x6c6c6c
+                    text_style: <REGULAR_TEXT>{}
                 }
-                text: ""
+                text: "Don't have an account?"
+            }
+            signup_button = <Button> {
+                width: Fit, height: Fit
+                margin: {top: -5}
+                draw_text: {
+                    // color: (MESSAGE_TEXT_COLOR)
+                    fn get_color(self) -> vec4 {
+                        return MESSAGE_TEXT_COLOR
+                    }
+                    text_style: <REGULAR_TEXT>{}
+                }
+                draw_bg: {
+                    bodybottom: #DDDDDD
+                }
+
+                text: "Sign up here"
             }
         }
     }
 }
 
+static MATRIX_SIGN_UP_URL: &str = "https://matrix.org/docs/chat_basics/matrix-for-im/#creating-a-matrix-account";
+
 #[derive(Live, LiveHook, Widget)]
 pub struct LoginScreen {
-    #[deref]
-    view: View,
+    #[deref] view: View,
 }
 
 impl Widget for LoginScreen {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
-        let widget_uid = self.widget_uid();
-
         self.view.handle_event(cx, event, scope);
 
-        let password_input = self.view.text_input(id!(password_input));
-        let error_message_label = self.view.label(id!(error_message));
-        let success_message_label = self.view.label(id!(success_message));
+        let status_label = self.view.label(id!(status_label));
         let login_button = self.view.button(id!(login_button));
+        let signup_button = self.view.button(id!(signup_button));
+        let user_id_input = self.view.text_input(id!(user_id_input));
+        let password_input = self.view.text_input(id!(password_input));
+        let homeserver_input = self.view.text_input(id!(homeserver_input));
 
-        let username = self.view.text_input(id!(username_input)).text();
-        let password = self.view.text_input(id!(password_input)).text();
+        let mut needs_redraw = false;
 
         if let Event::Actions(actions) = event {
+            if signup_button.clicked(actions) {
+                let _ = robius_open::Uri::new(MATRIX_SIGN_UP_URL).open();
+            }
+
             if login_button.clicked(actions) {
-                if username.is_empty() || password.is_empty() {
-                    error_message_label.set_text("Please enter both username and password.");
+                let user_id = user_id_input.text();
+                let password = password_input.text();
+                let homeserver = homeserver_input.text();
+                if user_id.is_empty() || password.is_empty() {
+                    status_label.set_text("Please enter both User ID and Password.");
                 } else {
-                    // TODO: Implement actual login logic
-                    let mut login_successful = false;
-
-                    if password == "aa" {login_successful = true}
-
-                    if login_successful {
-                        cx.widget_action(
-                            widget_uid,
-                            &scope.path,
-                            LoginAction::LoginSuccess,
-                        );
-                        error_message_label.set_text("");
-                        success_message_label.set_text("Login successful!");
-                    } else {
+                    submit_async_request(MatrixRequest::Login(LoginRequest {
+                        user_id,
+                        password,
+                        homeserver: homeserver.is_empty().not().then(|| homeserver),
+                    }));
+                    status_label.set_text("Waiting for login response...");
+                }
+                needs_redraw = true;
+            }
+
+            for action in actions {
+                match action.downcast_ref() {
+                    Some(LoginAction::AutofillInfo { .. }) => {
+                        todo!("set user_id, password, and homeserver inputs");
+                    }
+                    Some(LoginAction::Status(status)) => {
+                        status_label.set_text(status);
+                        needs_redraw = true;
+                    }
+                    Some(LoginAction::LoginSuccess) => {
+                        // The other real action of showing the main screen
+                        // is handled by the main app, not by this login screen.
+                        user_id_input.set_text("");
                         password_input.set_text("");
-                        error_message_label.set_text("Incorrect username or password.");
+                        homeserver_input.set_text("");
+                        status_label.set_text("Login successful!");
+                        needs_redraw = true;
                     }
-
-
+                    Some(LoginAction::LoginFailure(error)) => {
+                        status_label.set_text(error);
+                        needs_redraw = true;
+                    }
+                    _ => {}
                 }
-                self.redraw(cx);
             }
         }
+
+        if needs_redraw {
+            self.redraw(cx);
+        }
     }
 
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
@@ -231,8 +291,23 @@ impl Widget for LoginScreen {
     }
 }
 
+/// Actions sent to or from the login screen.
 #[derive(Clone, DefaultNone, Debug)]
 pub enum LoginAction {
-    None,
+    /// A positive response from the backend Matrix task to the login screen.
+    ///
+    /// This is not handled by the login screen itself, but by the main app.
     LoginSuccess,
+    /// A negative response from the backend Matrix task to the login screen.
+    LoginFailure(String),
+    /// A status message to display to the user.
+    Status(String),
+    /// Login credentials that should be filled into the login screen,
+    /// which get sent from the main function that parses CLI arguments.
+    AutofillInfo {
+        user_id: String,
+        password: String,
+        homeserver: Option<String>,
+    },
+    None,
 }
diff --git a/src/persistent_state.rs b/src/persistent_state.rs
index b38b13e6..6ac17641 100644
--- a/src/persistent_state.rs
+++ b/src/persistent_state.rs
@@ -2,14 +2,14 @@
 
 use std::path::PathBuf;
 use anyhow::{anyhow, bail};
-use makepad_widgets::log;
+use makepad_widgets::{log, Cx};
 use matrix_sdk::{
     matrix_auth::MatrixSession, ruma::{OwnedUserId, UserId}, sliding_sync::VersionBuilder, Client
 };
 use serde::{Deserialize, Serialize};
 use tokio::fs;
 
-use crate::app_data_dir;
+use crate::{app_data_dir, login::login_screen::LoginAction};
 
 /// The data needed to re-build a client.
 #[derive(Debug, Serialize, Deserialize)]
@@ -113,7 +113,9 @@ pub async fn restore_session(
         .build()
         .await?;
 
-    log!("Restoring previous session for {}", user_session.meta.user_id);
+    let status_str = format!("Restoring previous session for {}", user_session.meta.user_id);
+    log!("{status_str}");
+    Cx::post_action(LoginAction::Status(status_str));
 
     // Restore the Matrix user session.
     client.restore_session(user_session).await?;
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index d60e70a7..7c62bbb4 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -3,7 +3,7 @@ use clap::Parser;
 use eyeball::Subscriber;
 use eyeball_im::VectorDiff;
 use futures_util::StreamExt;
-use makepad_widgets::{error, log, warning, SignalToUI};
+use makepad_widgets::{error, log, warning, Cx, SignalToUI};
 use matrix_sdk::{
     config::RequestConfig,
     event_handler::EventHandlerDropGuard,
@@ -31,7 +31,7 @@ use matrix_sdk_ui::{
 };
 use tokio::{
     runtime::Handle,
-    sync::mpsc::{UnboundedSender, UnboundedReceiver},
+    sync::mpsc::{Sender, Receiver, UnboundedSender, UnboundedReceiver},
 };
 use unicode_segmentation::UnicodeSegmentation;
 use std::{cmp::{max, min}, collections::{BTreeMap, BTreeSet}, path:: Path, sync::{Arc, Mutex, OnceLock}};
@@ -39,7 +39,7 @@ use std::{cmp::{max, min}, collections::{BTreeMap, BTreeSet}, path:: Path, sync:
 use crate::{
     app_data_dir, avatar_cache::AvatarUpdate, event_preview::text_preview_of_timeline_item, home::{
         room_screen::TimelineUpdate, rooms_list::{self, enqueue_rooms_list_update, RoomPreviewAvatar, RoomPreviewEntry, RoomsListUpdate}
-    }, media_cache::MediaCacheEntry, persistent_state::{self, ClientSessionPersisted}, profile::{
+    }, login::login_screen::LoginAction, media_cache::MediaCacheEntry, persistent_state::{self, ClientSessionPersisted}, profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{enqueue_user_profile_update, UserProfileUpdate},
     }, utils::MEDIA_THUMBNAIL_FORMAT, verification::add_verification_event_handlers_and_sync_client
@@ -64,10 +64,26 @@ struct Cli {
     #[clap(short, long)]
     proxy: Option<String>,
 
+    /// Force login screen.
+    #[clap(short, long, action)]
+    login_screen: bool,
+
     /// Enable verbose logging output.
     #[clap(short, long, action)]
     verbose: bool,
 }
+impl From<LoginRequest> for Cli {
+    fn from(login: LoginRequest) -> Self {
+        Self {
+            username: login.user_id,
+            password: login.password,
+            homeserver: None,
+            proxy: None,
+            login_screen: false,
+            verbose: false,
+        }
+    }
+}
 
 
 /// Build a new client.
@@ -132,7 +148,7 @@ async fn login(cli: Cli) -> Result<(Client, Option<String>)> {
     // Query the server for supported login types.
     let login_kinds = client.matrix_auth().get_login_types().await?;
     if !login_kinds.flows.iter().any(|flow| matches!(flow, LoginType::Password(_))) {
-        bail!("Server does not support username + password login flow.");
+        bail!("Homeserver does not support username + password login flow.");
     }
 
     // Attempt to login using the CLI-provided username & password.
@@ -188,6 +204,8 @@ impl std::fmt::Display for PaginationDirection {
 
 /// The set of requests for async work that can be made to the worker thread.
 pub enum MatrixRequest {
+    /// Request from the login screen to log in with the given credentials.
+    Login(LoginRequest),
     /// Request to paginate (backwards fetch) the older events of a room's timeline.
     PaginateRoomTimeline {
         room_id: OwnedRoomId,
@@ -290,15 +308,34 @@ pub fn submit_async_request(req: MatrixRequest) {
 }
 
 
+/// Information needed to log in to a Matrix homeserver.
+pub struct LoginRequest {
+    pub user_id: String,
+    pub password: String,
+    pub homeserver: Option<String>,
+}
+
+
 /// The entry point for an async worker thread that can run async tasks.
 ///
 /// All this thread does is wait for [`MatrixRequests`] from the main UI-driven non-async thread(s)
 /// and then executes them within an async runtime context.
-async fn async_worker(mut receiver: UnboundedReceiver<MatrixRequest>) -> Result<()> {
+async fn async_worker(
+    mut request_receiver: UnboundedReceiver<MatrixRequest>,
+    login_sender: Sender<LoginRequest>,
+) -> Result<()> {
     log!("Started async_worker task.");
 
-    while let Some(request) = receiver.recv().await {
+    while let Some(request) = request_receiver.recv().await {
         match request {
+            MatrixRequest::Login(login_request) => {
+                if let Err(e) = login_sender.send(login_request).await {
+                    error!("Error sending login request to login_sender: {e:?}");
+                    Cx::post_action(LoginAction::LoginFailure(String::from(
+                        "BUG: failed to send login request to async worker thread."
+                    )));
+                }
+            }
             MatrixRequest::PaginateRoomTimeline { room_id, num_events, direction } => {
                 let (timeline, sender) = {
                     let mut all_room_info = ALL_ROOM_INFO.lock().unwrap();
@@ -691,14 +728,16 @@ pub fn start_matrix_tokio() -> Result<()> {
     // Create a channel to be used between UI thread(s) and the async worker thread.
     let (sender, receiver) = tokio::sync::mpsc::unbounded_channel::<MatrixRequest>();
     REQUEST_SENDER.set(sender).expect("BUG: REQUEST_SENDER already set!");
+    
+    let (login_sender, login_receiver) = tokio::sync::mpsc::channel(1);
 
     // Start a high-level async task that will start and monitor all other tasks.
     let _monitor = rt.spawn(async move {
         // Spawn the actual async worker thread.
-        let mut worker_join_handle = rt.spawn(async_worker(receiver));
+        let mut worker_join_handle = rt.spawn(async_worker(receiver, login_sender));
 
         // Start the main loop that drives the Matrix client SDK.
-        let mut main_loop_join_handle = rt.spawn(async_main_loop());
+        let mut main_loop_join_handle = rt.spawn(async_main_loop(login_receiver));
 
         loop {
             tokio::select! {
@@ -818,91 +857,107 @@ pub fn take_timeline_update_receiver(
 }
 
 
-async fn async_main_loop() -> Result<()> {
+const DEFAULT_HOMESERVER: &str = "matrix.org";
+
+fn username_to_full_user_id(
+    username: &str,
+    homeserver: Option<&str>,
+) -> Option<OwnedUserId> {
+    username
+        .try_into()
+        .ok()
+        .or_else(|| {
+            let homeserver_url = homeserver.unwrap_or(DEFAULT_HOMESERVER);
+            let user_id_str = if username.starts_with("@") {
+                format!("{}:{}", username, homeserver_url)
+            } else {
+                format!("@{}:{}", username, homeserver_url)
+            };
+            user_id_str.as_str().try_into().ok()
+        })
+}
+
+async fn async_main_loop(
+    mut login_receiver: Receiver<LoginRequest>,
+) -> Result<()> {
     tracing_subscriber::fmt::init();
 
-    let cli = Cli::try_parse().ok().or_else(|| {
-        // Quickly try to parse the username, password, and homeserver fields from "login.toml".
-        let login_file = std::include_str!("../login.toml");
-        let mut username = None;
-        let mut password = None;
-        let mut homeserver = None;
-        let mut homeserver_found = false;
-        for line in login_file.lines() {
-            if line.starts_with("username") {
-                username = line.find('=')
-                    .and_then(|i| line.get((i + 1) ..))
-                    .map(|s| s.trim().trim_matches('"').trim().to_string());
-            }
-            if line.starts_with("password") {
-                password = line.find('=')
-                    .and_then(|i| line.get((i + 1) ..))
-                    .map(|s| s.trim().trim_matches('"').trim().to_string());
-            }
-            if line.starts_with("homeserver") {
-                homeserver_found = true;
-                homeserver = line.find('=')
-                    .and_then(|i| line.get((i + 1) ..))
-                    .map(|s| s.trim().trim_matches('"').trim().to_string());
-                if homeserver.as_ref().is_some_and(|h| h.is_empty()) {
-                    homeserver = None;
+    let most_recent_user_id = persistent_state::most_recent_user_id();
+    log!("Most recent user ID: {most_recent_user_id:?}");
+    let cli_parse_result = Cli::try_parse();
+    log!("CLI parsing succeeded? {}", cli_parse_result.is_ok());
+    let wait_for_login = most_recent_user_id.is_none()
+        || cli_parse_result.as_ref().map_or(false, |cli| cli.login_screen);
+    log!("Waiting for login? {}", wait_for_login);
+
+    let new_login_opt = if !wait_for_login {
+        let specified_username = cli_parse_result.as_ref().ok().and_then(|cli|
+            username_to_full_user_id(
+                &cli.username,
+                cli.homeserver.as_deref(),
+            )
+        );
+        log!("Trying to restore session for user: {specified_username:?}");
+        if let Some(session) = persistent_state::restore_session(specified_username).await.ok() {
+            Some(session)
+        } else {
+            let status_err = "Could not restore previous user session";
+            log!("{status_err}");
+            Cx::post_action(LoginAction::Status(status_err.to_string()));
+
+            if let Ok(cli) = cli_parse_result {
+                let status_str = format!("Attempting auto-login from CLI arguments as user {}", cli.username);
+                log!("{status_str}");
+                Cx::post_action(LoginAction::Status(status_str));
+
+                match login(cli).await {
+                    Ok(new_login) => Some(new_login),
+                    Err(e) => {
+                        error!("CLI-based login failed: {e:?}");
+                        Cx::post_action(LoginAction::LoginFailure(e.to_string()));
+                        enqueue_rooms_list_update(RoomsListUpdate::Status {
+                            status: e.to_string(),
+                        });
+                        None
+                    }
                 }
-            }
-            if username.is_some() && password.is_some() && homeserver_found {
-                break;
-            }
-        }
-        if let (Some(username), Some(password)) = (username, password) {
-            if username.is_empty() || password.is_empty() {
-                None
             } else {
-                log!("Parsed username and password from 'login.toml': {username:?}, homeserver: {homeserver:?}");
-                Some(Cli {
-                    username,
-                    password,
-                    homeserver,
-                    proxy: None,
-                    verbose: false,
-                })
+                None
             }
-        } else {
-            log!("Failed to parse username and password from \"login.toml\".");
-            None
         }
-    });
-
-    let Some(cli) = cli else {
-        enqueue_rooms_list_update(RoomsListUpdate::Status {
-            status: String::from("Error: missing username and password in 'login.toml' file. \
-                Please provide a valid username and password in 'login.toml' and rebuild the app."
-            ),
-        });
-        loop { } // nothing else we can do right now
+    } else {
+        None
     };
-    enqueue_rooms_list_update(RoomsListUpdate::Status {
-        status: format!("Logging in as {}...", &cli.username)
-    });
 
-    let specified_username: Option<OwnedUserId> = cli.username.to_string().try_into().ok()
-        .or_else(|| {
-            let homeserver_url = cli.homeserver.as_deref()
-                .unwrap_or("matrix.org");
-            let user_id_str = if cli.username.starts_with("@") {
-                format!("{}:{}", cli.username, homeserver_url)
+    let (client, _sync_token) = match new_login_opt {
+        Some(new_login) => new_login,
+        None => loop {
+            log!("Waiting for login request...");
+            if let Some(login_request) = login_receiver.recv().await {
+                log!("Received login request for user {}", login_request.user_id);
+                match login(Cli::from(login_request)).await {
+                    Ok(new_login) => break new_login,
+                    Err(e) => {
+                        error!("Login failed: {e:?}");
+                        Cx::post_action(LoginAction::LoginFailure(e.to_string()));
+                        enqueue_rooms_list_update(RoomsListUpdate::Status {
+                            status: e.to_string(),
+                        });
+                    }
+                }
             } else {
-                format!("@{}:{}", cli.username, homeserver_url)
-            };
-            user_id_str.as_str().try_into().ok()
-        });
-    let (client, _sync_token) = if let Ok(restored) = persistent_state::restore_session(specified_username).await {
-        restored
-    } else {
-        match login(cli).await {
-            Ok(new_login) => new_login,
-            Err(e) => return Err(e),
+                error!("BUG: login_receiver hung up unexpectedly");
+                return Err(anyhow::anyhow!("BUG: login_receiver hung up unexpectedly"));
+            }
         }
     };
 
+    Cx::post_action(LoginAction::LoginSuccess);
+
+    enqueue_rooms_list_update(RoomsListUpdate::Status {
+        status: format!("Logged in as {}. Loading rooms...", client.user_id().unwrap()),
+    });
+
     CLIENT.set(client.clone()).expect("BUG: CLIENT already set!");
 
     add_verification_event_handlers_and_sync_client(client.clone());

From 5107ffae72f702aba6ae8766e31b29a1a7589328 Mon Sep 17 00:00:00 2001
From: Kevin Boos <kevinaboos@gmail.com>
Date: Sat, 12 Oct 2024 13:48:01 -0700
Subject: [PATCH 5/5] Switch to using a modal for the login screen; stacknav
 didn't work

---
 src/app.rs                | 54 +++++++++++++++++----------------------
 src/login/login_screen.rs |  3 ++-
 src/sliding_sync.rs       |  2 +-
 3 files changed, 27 insertions(+), 32 deletions(-)

diff --git a/src/app.rs b/src/app.rs
index fd1ec97c..53a90558 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -102,14 +102,6 @@ live_design! {
         }
     }
 
-    // StackNavigationView without header
-    SimpleStackNavigationView = <StackNavigationView> {
-        header = <View> {}
-        body = {
-            margin: 0
-        }
-    }
-
     App = {{App}} {
         ui: <Window> {
             window: {inner_size: vec2(1280, 800)},
@@ -121,15 +113,21 @@ live_design! {
                     width: Fill, height: Fill,
                     flow: Overlay,
 
-                    navigation = <StackNavigation> {
-                        root_view = {
-                            login_screen = <LoginScreen> {}
-                        }
-                        stack_navigation_view_home_screen = <SimpleStackNavigationView> {
-                            body = {
-                                home_screen = <HomeScreen> {}
+                    home_screen = <HomeScreen> {}
+
+                    login_modal = <Modal> {
+                        bg_view: {
+                            show_bg: true,
+                            draw_bg: {
+                                color: #f
+                                fn pixel(self) -> vec4 {
+                                    return vec4(1.0, 1.0, 1.0, 0.0)
+                                }
                             }
                         }
+                        content: {
+                            login_modal_inner = <LoginScreen> {}
+                        }
                     }
 
                     verification_modal = <Modal> {
@@ -150,6 +148,8 @@ pub struct App {
     #[live]
     ui: WidgetRef,
 
+    #[rust(true)] show_login: bool,
+
     #[rust]
     app_state: AppState,
 }
@@ -172,7 +172,7 @@ impl LiveRegister for App {
 impl LiveHook for App { }
 
 impl MatchEvent for App {
-    fn handle_startup(&mut self, _cx: &mut Cx) {
+    fn handle_startup(&mut self, cx: &mut Cx) {
         // Initialize the project directory here from the main UI thread
         // such that background threads/tasks will be able to can access it.
         let _app_data_dir = crate::app_data_dir();
@@ -183,22 +183,10 @@ impl MatchEvent for App {
     }
 
     fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions) {
-        self.ui.stack_navigation(id!(navigation))
-            .handle_stack_view_actions(cx, actions);
-
         for action in actions {
             if let Some(LoginAction::LoginSuccess) = action.downcast_ref() {
-                cx.widget_action(
-                    self.ui.widget_uid(),
-                    &Scope::default().path,
-                    StackNavigationAction::NavigateTo(live_id!(stack_navigation_view_home_screen)), 
-                );
-                // Try to trigger the home_screen to redraw or handle events.
-                self.ui.view(id!(home_screen)).redraw(cx);
-                SignalToUI::set_ui_signal();
-
-                // let mut navigation = self.ui.stack_navigation(id!(navigation));
-                // navigation.show_stack_view_by_id(live_id!(stack_navigation_view_home_screen), cx);
+                log!("Received LoginAction::LoginSuccess, closing login modal.");
+                self.ui.modal(id!(login_modal)).close(cx);
                 self.ui.redraw(cx);
             }
 
@@ -283,6 +271,12 @@ impl MatchEvent for App {
 
 impl AppMain for App {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event) {
+        if self.show_login {
+            log!("showing login modal");
+            self.ui.modal(id!(login_modal)).open(cx);
+            self.show_login = false;
+        }
+
         // Forward events to the MatchEvent trait impl, and then to the App's UI element.
         self.match_event(cx, event);
         let scope = &mut Scope::with_data(&mut self.app_state);
diff --git a/src/login/login_screen.rs b/src/login/login_screen.rs
index 056fab8f..5ad51e62 100644
--- a/src/login/login_screen.rs
+++ b/src/login/login_screen.rs
@@ -102,6 +102,7 @@ live_design! {
     }
 
     LoginScreen = {{LoginScreen}} {
+        width: Fit, height: Fit
         show_bg: true,
         draw_bg: {
             color: (COLOR_PRIMARY)
@@ -244,12 +245,12 @@ impl Widget for LoginScreen {
                 if user_id.is_empty() || password.is_empty() {
                     status_label.set_text("Please enter both User ID and Password.");
                 } else {
+                    status_label.set_text("Waiting for login response...");
                     submit_async_request(MatrixRequest::Login(LoginRequest {
                         user_id,
                         password,
                         homeserver: homeserver.is_empty().not().then(|| homeserver),
                     }));
-                    status_label.set_text("Waiting for login response...");
                 }
                 needs_redraw = true;
             }
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 7c62bbb4..6a2b0e79 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -887,7 +887,7 @@ async fn async_main_loop(
     let cli_parse_result = Cli::try_parse();
     log!("CLI parsing succeeded? {}", cli_parse_result.is_ok());
     let wait_for_login = most_recent_user_id.is_none()
-        || cli_parse_result.as_ref().map_or(false, |cli| cli.login_screen);
+        || std::env::args().any(|arg| arg == "--login-screen" || arg == "--force-login");
     log!("Waiting for login? {}", wait_for_login);
 
     let new_login_opt = if !wait_for_login {