mostly-broken pending messages

Author: roobscoob

src/chat/src/channel.rs

@@ -7,5 +7,5 @@ pub trait Channel: Clone {
 
   fn get_receiver(&self) -> broadcast::Receiver<Self::Message>;
 
-  fn send_message(&self, content: String, nonce: String) -> impl std::future::Future<Output = ()>;
+  fn send_message(&self, content: String, nonce: String) -> Self::Message;
 }

src/discord/src/channel/mod.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use scope_chat::channel::Channel;
 use tokio::sync::{broadcast, RwLock};
 
-use crate::{client::DiscordClient, message::DiscordMessage, snowflake::Snowflake};
+use crate::{client::DiscordClient, message::{author::{DiscordMessageAuthor, DisplayName}, content::DiscordMessageContent, DiscordMessage}, snowflake::Snowflake};
 
 pub struct DiscordChannel {
   channel_id: Snowflake,
@@ -28,10 +28,22 @@ impl Channel for DiscordChannel {
     self.receiver.resubscribe()
   }
 
-  async fn send_message(&self, content: String, nonce: String) {
-    println!("Sending: {:?}", content);
-
-    self.client.write().await.send_message(self.channel_id, content, nonce).await;
+  fn send_message(&self, content: String, nonce: String) -> DiscordMessage {
+    let client = self.client.clone();
+    let channel_id = self.channel_id;
+    let sent_content = content.clone();
+    let sent_nonce = nonce.clone();
+
+    tokio::spawn(async move {
+      client.write().await.send_message(channel_id, sent_content, sent_nonce).await;
+    });
+
+    DiscordMessage {
+      content: DiscordMessageContent { content, is_pending: true },
+      author: DiscordMessageAuthor { display_name: DisplayName("Pending".to_owned()), icon: "".to_owned() },
+      id: Snowflake { content: 0 },
+      nonce: Some(nonce),
+    }
   }
 }
 

src/discord/src/client.rs

@@ -80,7 +80,8 @@ impl EventHandler for RemoteDiscordClient {
             icon: msg.author.avatar_url().unwrap_or(msg.author.default_avatar_url()),
           },
           content: DiscordMessageContent {
-            content: msg.content.clone()
+            content: msg.content.clone(),
+            is_pending: false,
           },
           nonce: msg.nonce.clone().map(|n| match n {
             Nonce::Number(n) => n.to_string(),

src/discord/src/message/content.rs

@@ -1,12 +1,13 @@
-use gpui::{IntoElement, Render, RenderOnce, WindowContext};
+use gpui::{div, IntoElement, ParentElement, Render, RenderOnce, Styled, WindowContext};
 
 #[derive(Clone, IntoElement)]
 pub struct DiscordMessageContent {
   pub content: String,
+  pub is_pending: bool,
 }
 
 impl RenderOnce for DiscordMessageContent {
   fn render(self, _: &mut WindowContext) -> impl IntoElement {
-    self.content.clone()
+    div().opacity(if self.is_pending { 0.5 } else { 1.0 }).child(self.content.clone())
   }
 }

src/ui/src/channel/message_list.rs

@@ -9,16 +9,51 @@ use scope_backend_discord::{
 };
 use scope_chat::message::Message;
 
-pub struct MessageList<M: Message> {
-  pub(super) messages: Vec<M>,
+#[derive(Clone)]
+pub struct MessageList<M: Message + 'static> {
+  real_messages: Vec<M>,
+  pending_messages: Vec<M>,
 }
 
 impl<M: Message> MessageList<M> {
   pub fn new() -> MessageList<M> {
-    Self { messages: Vec::default() }
+    Self {
+      real_messages: Vec::default(),
+      pending_messages: Vec::default(),
+    }
   }
 
   pub fn add_external_message(&mut self, message: M) {
+    self.real_messages.push(message);
+  }
+
+  pub fn add_pending_message(&mut self, pending_message: M) {
+    self.pending_messages.push(pending_message);
+  }
+
+  pub fn length(&self) -> usize {
+    self.real_messages.len() + self.pending_messages.len()
+  }
+
+  pub fn get(&self, index: usize) -> Option<&M> {
+    if index >= self.pending_messages.len() {
+      self.real_messages.get(index - self.pending_messages.len())
+    } else {
+      self.pending_messages.get(index)
+    }
+  }
+
+  pub fn create_list_state(&self) -> ListState {
+    let clone = self.clone();
 
+    ListState::new(
+      clone.length(),
+      ListAlignment::Bottom,
+      Pixels(20.),
+      move |idx, _cx| {
+        let item = clone.get(idx).unwrap().clone();
+        div().child(message(item)).into_any_element()
+      },
+    )
   }
 }

src/ui/src/channel/mod.rs

@@ -31,32 +31,17 @@ impl<M: Message + 'static> ChannelView<M> {
           loop {
             let message = channel.get_receiver().recv().await.unwrap();
 
-            println!("Got Message!");
-
-            async_model
-              .update(&mut async_ctx, |data, ctx| {
-                data.messages.push(message);
-                ctx.notify();
-              })
-              .unwrap();
-          }
-        })
-        .detach();
-
-      ctx
-        .observe(&state_model, |this: &mut ChannelView<M>, model, cx| {
-          let items = model.read(cx).messages.clone();
-
-          this.list_state = ListState::new(items.len(), ListAlignment::Bottom, Pixels(20.), move |idx, _cx| {
-            let item = items.get(idx).unwrap().clone();
-            div().child(message(item)).into_any_element()
-          });
-
-          cx.notify();
-        })
-        .detach();
+          async_model.update(&mut async_ctx, |data, ctx| {
+            data.add_external_message(message);
+            ctx.notify();
+          }).unwrap();
+        }
+      }).detach();
 
-      let items = state_model.read(ctx).messages.clone();
+      ctx.observe(&state_model, |this: &mut ChannelView<M>, model, cx| {
+        this.list_state = model.read(cx).create_list_state();
+        cx.notify();
+      }).detach();
 
       let message_input = ctx.new_view(|cx| {
         let mut input = components::input::TextInput::new(cx);
@@ -76,21 +61,19 @@ impl<M: Message + 'static> ChannelView<M> {
               text_input.set_text("", cx);
             });
 
-            ctx.foreground_executor().spawn(async move {
-              let nonce = random_string::generate(20, random_string::charsets::ALPHANUMERIC);
+            let nonce = random_string::generate(20, random_string::charsets::ALPHANUMERIC);
+            let pending = channel_sender.send_message(content, nonce);
 
-              channel_sender.send_message(content, nonce).await;
-            }).detach();
+            channel_view.list_model.update(ctx, move |v, _| {
+              v.add_pending_message(pending);
+            });
           }
           _ => {}
         }
       }).detach();  
 
       ChannelView::<M> {
-        list_state: ListState::new(items.len(), ListAlignment::Bottom, Pixels(20.), move |idx, _cx| {
-          let item = items.get(idx).unwrap().clone();
-          div().child(message(item)).into_any_element()
-        }),
+        list_state: state_model.read(ctx).create_list_state(),
         list_model: state_model,
         message_input,
       }