reya/coop
1
0
Fork 0
Code Issues Pull Requests Releases Activity

wip: refactor

Browse Source
This commit is contained in:
reya
2025-01-08 08:02:24 +07:00
parent 402786ec3c
commit fe24f84b02
24 changed files with 521 additions and 945 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
crates/app/src/views/account.rs
View File

@@ -1,21 +1,21 @@
use gpui::*;
use gpui::prelude::FluentBuilder;
use gpui::{
actions, img, Context, IntoElement, Model, ObjectFit, ParentElement, Render, Styled,
StyledImage, ViewContext,
};
use nostr_sdk::prelude::*;
use prelude::FluentBuilder;
use ui::{
button::{Button, ButtonVariants},
popup_menu::PopupMenuExt,
Icon, IconName, Sizable,
};
use crate::{
constants::IMAGE_SERVICE,
get_client,
states::{metadata::MetadataRegistry, signal::SignalRegistry},
};
use crate::{constants::IMAGE_SERVICE, get_client};
actions!(account, [ToDo]);
pub struct Account {
#[allow(dead_code)]
public_key: PublicKey,
metadata: Model<Option<Metadata>>,
}
@@ -23,25 +23,8 @@ pub struct Account {
impl Account {
pub fn new(public_key: PublicKey, cx: &mut ViewContext<'_, Self>) -> Self {
let metadata = cx.new_model(|_| None);
let async_metadata = metadata.clone();
// Request metadata
_ = cx.global::<SignalRegistry>().tx.send(public_key);
// Reload when received metadata
cx.observe_global::<MetadataRegistry>(|chat, cx| {
chat.load_metadata(cx);
})
.detach();
Self {
public_key,
metadata,
}
}
pub fn load_metadata(&mut self, cx: &mut ViewContext<Self>) {
let public_key = self.public_key;
let async_metadata = self.metadata.clone();
let mut async_cx = cx.to_async();
cx.foreground_executor()
@@ -60,6 +43,11 @@ impl Account {
};
})
.detach();
Self {
public_key,
metadata,
}
}
}

26
crates/app/src/views/app.rs
View File

@@ -1,5 +1,13 @@
use gpui::*;
use prelude::FluentBuilder;
use super::{
account::Account, chat::ChatPanel, onboarding::Onboarding, sidebar::Sidebar,
welcome::WelcomePanel,
};
use crate::states::{account::AccountRegistry, chat::Room};
use gpui::prelude::FluentBuilder;
use gpui::{
div, impl_actions, px, Axis, Context, Edges, InteractiveElement, IntoElement, Model,
ParentElement, Render, Styled, View, ViewContext, VisualContext, WeakView, WindowContext,
};
use serde::Deserialize;
use std::sync::Arc;
use ui::{
@@ -9,16 +17,9 @@ use ui::{
Root, Sizable, TitleBar,
};
use super::{
account::Account, chat::ChatPanel, contact::ContactPanel, onboarding::Onboarding,
sidebar::Sidebar, welcome::WelcomePanel,
};
use crate::states::{account::AccountRegistry, chat::Room};
#[derive(Clone, PartialEq, Eq, Deserialize)]
pub enum PanelKind {
Room(Arc<Room>),
Contact,
}
#[derive(Clone, PartialEq, Eq, Deserialize)]
@@ -125,13 +126,6 @@ impl AppView {
PanelKind::Room(room) => {
let panel = Arc::new(ChatPanel::new(room, cx));
self.dock.update(cx, |dock_area, cx| {
dock_area.add_panel(panel, action.position, cx);
});
}
PanelKind::Contact => {
let panel = Arc::new(ContactPanel::new(cx));
self.dock.update(cx, |dock_area, cx| {
dock_area.add_panel(panel, action.position, cx);
});

6
crates/app/src/views/chat/message.rs
View File

@@ -1,6 +1,8 @@
use gpui::*;
use gpui::{
div, img, prelude::FluentBuilder, InteractiveElement, IntoElement, ParentElement, RenderOnce,
SharedString, Styled, WindowContext,
};
use nostr_sdk::prelude::*;
use prelude::FluentBuilder;
use ui::{theme::ActiveTheme, StyledExt};
use crate::{

10
crates/app/src/views/chat/mod.rs
View File

@@ -1,8 +1,10 @@
use std::sync::Arc;
use gpui::*;
use gpui::{
div, AnyElement, AppContext, EventEmitter, FocusHandle, FocusableView, IntoElement,
ParentElement, Render, SharedString, Styled, View, VisualContext, WindowContext,
};
use nostr_sdk::prelude::*;
use room::RoomPanel;
use std::sync::Arc;
use ui::{
button::Button,
dock::{Panel, PanelEvent, PanelState},
@@ -91,7 +93,7 @@ impl Panel for ChatPanel {
impl EventEmitter<PanelEvent> for ChatPanel {}
impl FocusableView for ChatPanel {
fn focus_handle(&self, _: &AppContext) -> gpui::FocusHandle {
fn focus_handle(&self, _: &AppContext) -> FocusHandle {
self.focus_handle.clone()
}
}

95
crates/app/src/views/chat/room.rs
View File

@@ -1,4 +1,7 @@
use gpui::*;
use gpui::{
div, list, px, Context, Flatten, IntoElement, ListAlignment, ListState, Model, ParentElement,
PathPromptOptions, Pixels, Render, SharedString, Styled, View, ViewContext, VisualContext,
};
use itertools::Itertools;
use nostr_sdk::prelude::*;
use std::sync::Arc;
@@ -15,7 +18,6 @@ use crate::{
states::{
account::AccountRegistry,
chat::{ChatRegistry, Room},
metadata::MetadataRegistry,
},
};
@@ -122,21 +124,34 @@ impl RoomPanel {
.await;
if let Ok(events) = events {
let items: Vec<RoomMessage> = events
.into_iter()
.sorted_by_key(|ev| ev.created_at)
.map(|ev| {
// Get user's metadata
let metadata = async_cx
.read_global::<MetadataRegistry, _>(|state, _cx| {
state.get(&ev.pubkey)
})
.unwrap();
let mut items: Vec<RoomMessage> = Vec::new();
// Return message item
RoomMessage::new(ev.pubkey, metadata, ev.content, ev.created_at)
})
.collect();
for event in events.into_iter().sorted_by_key(|ev| ev.created_at) {
let metadata = async_cx
.background_executor()
.spawn(
async move { client.database().metadata(event.pubkey).await },
)
.await;
let message = if let Ok(metadata) = metadata {
RoomMessage::new(
event.pubkey,
metadata,
event.content,
event.created_at,
)
} else {
RoomMessage::new(
event.pubkey,
None,
event.content,
event.created_at,
)
};
items.push(message);
}
let total = items.len();
@@ -154,38 +169,38 @@ impl RoomPanel {
pub fn subscribe(&self, cx: &mut ViewContext<Self>) {
let room_id = self.id.clone();
let messages = self.messages.clone();
let current_user = cx.global::<AccountRegistry>().get().unwrap();
cx.observe_global::<ChatRegistry>(move |_, cx| {
let state = cx.global::<ChatRegistry>();
let new_messages = state.new_messages.read().unwrap().clone();
let filter = new_messages
.into_iter()
.filter(|m| m.room_id == room_id && m.event.pubkey != current_user)
.collect::<Vec<_>>();
let new_messages = state.get_messages(&room_id);
let items: Vec<RoomMessage> = filter
.into_iter()
.map(|m| {
RoomMessage::new(
m.event.pubkey,
m.metadata,
m.event.content,
m.event.created_at,
)
})
.collect();
if let Some(new_messages) = new_messages {
let items: Vec<RoomMessage> = new_messages
.read()
.unwrap()
.clone()
.into_iter()
.map(|m| {
RoomMessage::new(
m.event.pubkey,
m.metadata,
m.event.content,
m.event.created_at,
)
})
.collect();
cx.update_model(&messages, |model, cx| {
model.items.extend(items);
model.count = model.items.len();
cx.notify();
});
cx.update_model(&messages, |model, cx| {
model.items.extend(items);
model.count = model.items.len();
cx.notify();
});
}
})
.detach();
}
pub fn send_message(&mut self, cx: &mut ViewContext<Self>) {
fn send_message(&mut self, cx: &mut ViewContext<Self>) {
let owner = self.owner;
let current_user = cx.global::<AccountRegistry>().get().unwrap();
let content = self.input.read(cx).text().to_string();
@@ -252,7 +267,7 @@ impl RoomPanel {
}
impl Render for RoomPanel {
fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl IntoElement {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
v_flex()
.size_full()
.child(list(self.list.clone()).flex_1())

113
crates/app/src/views/contact/item.rs
View File

@@ -1,113 +0,0 @@
use gpui::*;
use nostr_sdk::prelude::*;
use prelude::FluentBuilder;
use ui::theme::ActiveTheme;
use crate::{
constants::IMAGE_SERVICE,
get_client,
states::{metadata::MetadataRegistry, signal::SignalRegistry},
utils::show_npub,
};
pub struct ContactListItem {
public_key: PublicKey,
metadata: Model<Option<Metadata>>,
}
impl ContactListItem {
pub fn new(public_key: PublicKey, cx: &mut ViewContext<'_, Self>) -> Self {
let metadata = cx.new_model(|_| None);
// Request metadata
_ = cx.global::<SignalRegistry>().tx.send(public_key);
// Reload when received metadata
cx.observe_global::<MetadataRegistry>(|item, cx| {
item.load_metadata(cx);
})
.detach();
Self {
public_key,
metadata,
}
}
pub fn load_metadata(&mut self, cx: &mut ViewContext<Self>) {
let public_key = self.public_key;
let async_metadata = self.metadata.clone();
let mut async_cx = cx.to_async();
cx.foreground_executor()
.spawn({
let client = get_client();
async move {
let query = async_cx
.background_executor()
.spawn(async move { client.database().metadata(public_key).await })
.await;
if let Ok(metadata) = query {
_ = async_cx.update_model(&async_metadata, |a, b| {
*a = metadata;
b.notify();
});
};
}
})
.detach();
}
}
impl Render for ContactListItem {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let fallback = show_npub(self.public_key, 16);
let mut content = div()
.w_full()
.h_10()
.px_2()
.flex()
.items_center()
.gap_2()
.text_sm();
if let Some(metadata) = self.metadata.read(cx).as_ref() {
content = content
.map(|this| {
if let Some(picture) = metadata.picture.clone() {
this.flex_shrink_0().child(
img(format!(
"{}/?url={}&w=72&h=72&fit=cover&mask=circle&n=-1",
IMAGE_SERVICE, picture
))
.size_8(),
)
} else {
this.flex_shrink_0()
.child(img("brand/avatar.png").size_8().rounded_full())
}
})
.map(|this| {
if let Some(display_name) = metadata.display_name.clone() {
this.flex_1().child(display_name)
} else {
this.flex_1().child(fallback)
}
})
} else {
content = content
.child(img("brand/avatar.png").size_8().rounded_full())
.child(fallback)
}
div()
.rounded_md()
.hover(|this| {
this.bg(cx.theme().muted)
.text_color(cx.theme().muted_foreground)
})
.child(content)
}
}

146
crates/app/src/views/contact/mod.rs
View File

@@ -1,146 +0,0 @@
use std::time::Duration;
use gpui::*;
use item::ContactListItem;
use prelude::FluentBuilder;
use ui::{
button::Button,
dock::{Panel, PanelEvent, PanelState},
indicator::Indicator,
popup_menu::PopupMenu,
scroll::ScrollbarAxis,
theme::ActiveTheme,
v_flex, Sizable, StyledExt,
};
use crate::get_client;
mod item;
pub struct ContactPanel {
name: SharedString,
closeable: bool,
zoomable: bool,
focus_handle: FocusHandle,
// Contacts
view_id: EntityId,
contacts: Model<Option<Vec<View<ContactListItem>>>>,
}
impl ContactPanel {
pub fn new(cx: &mut WindowContext) -> View<Self> {
cx.new_view(Self::view)
}
fn view(cx: &mut ViewContext<Self>) -> Self {
let contacts = cx.new_model(|_| None);
let async_contacts = contacts.clone();
let mut async_cx = cx.to_async();
cx.foreground_executor()
.spawn({
let client = get_client();
async move {
if let Ok(contacts) = async_cx
.background_executor()
.spawn(async move { client.get_contact_list(Duration::from_secs(3)).await })
.await
{
let views: Vec<View<ContactListItem>> = contacts
.into_iter()
.map(|contact| {
async_cx
.new_view(|cx| ContactListItem::new(contact.public_key, cx))
.unwrap()
})
.collect();
_ = async_cx.update_model(&async_contacts, |model, cx| {
*model = Some(views);
cx.notify();
});
}
}
})
.detach();
Self {
name: "Contacts".into(),
closeable: true,
zoomable: true,
focus_handle: cx.focus_handle(),
view_id: cx.entity_id(),
contacts,
}
}
}
impl Panel for ContactPanel {
fn panel_id(&self) -> SharedString {
"Contact".into()
}
fn title(&self, _cx: &WindowContext) -> AnyElement {
self.name.clone().into_any_element()
}
fn closeable(&self, _cx: &WindowContext) -> bool {
self.closeable
}
fn zoomable(&self, _cx: &WindowContext) -> bool {
self.zoomable
}
fn popup_menu(&self, menu: PopupMenu, _cx: &WindowContext) -> PopupMenu {
menu.track_focus(&self.focus_handle)
}
fn toolbar_buttons(&self, _cx: &WindowContext) -> Vec<Button> {
vec![]
}
fn dump(&self, _cx: &AppContext) -> PanelState {
PanelState::new(self)
}
}
impl EventEmitter<PanelEvent> for ContactPanel {}
impl FocusableView for ContactPanel {
fn focus_handle(&self, _: &AppContext) -> gpui::FocusHandle {
self.focus_handle.clone()
}
}
impl Render for ContactPanel {
fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl IntoElement {
v_flex()
.scrollable(self.view_id, ScrollbarAxis::Vertical)
.w_full()
.gap_1()
.p_2()
.map(|this| {
if let Some(contacts) = self.contacts.read(cx).as_ref() {
this.children(contacts.clone())
} else {
this.w_full()
.h_40()
.flex()
.items_center()
.justify_center()
.child(
div()
.flex()
.items_center()
.gap_1p5()
.text_color(cx.theme().muted_foreground)
.child(Indicator::new().small())
.child(div().text_xs().child("Loading")),
)
}
})
}
}

153
crates/app/src/views/inbox/item.rs
View File

@@ -1,153 +0,0 @@
use gpui::*;
use nostr_sdk::prelude::*;
use prelude::FluentBuilder;
use std::sync::Arc;
use ui::{theme::ActiveTheme, StyledExt};
use crate::{
constants::IMAGE_SERVICE,
get_client,
states::{chat::Room, metadata::MetadataRegistry, signal::SignalRegistry},
utils::{ago, get_room_id, show_npub},
views::app::{AddPanel, PanelKind},
};
pub struct InboxListItem {
id: SharedString,
event: Event,
metadata: Model<Option<Metadata>>,
}
impl InboxListItem {
pub fn new(event: Event, cx: &mut ViewContext<'_, Self>) -> Self {
let pubkeys: Vec<PublicKey> = event.tags.public_keys().copied().collect();
let id = get_room_id(&event.pubkey, &pubkeys).into();
let metadata = cx.new_model(|_| None);
// Reload when received metadata
cx.observe_global::<MetadataRegistry>(|chat, cx| {
chat.load_metadata(cx);
})
.detach();
Self {
id,
event,
metadata,
}
}
pub fn request_metadata(&mut self, cx: &mut ViewContext<Self>) {
_ = cx.global::<SignalRegistry>().tx.send(self.event.pubkey);
}
pub fn load_metadata(&mut self, cx: &mut ViewContext<Self>) {
let public_key = self.event.pubkey;
let async_metadata = self.metadata.clone();
let mut async_cx = cx.to_async();
cx.foreground_executor()
.spawn(async move {
let client = get_client();
let query = async_cx
.background_executor()
.spawn(async move { client.database().metadata(public_key).await })
.await;
if let Ok(metadata) = query {
_ = async_cx.update_model(&async_metadata, |a, b| {
*a = metadata;
b.notify();
});
};
})
.detach();
}
pub fn id(&self) -> String {
self.id.clone().into()
}
pub fn action(&self, cx: &mut WindowContext<'_>) {
let room = Arc::new(Room::parse(&self.event, cx));
cx.dispatch_action(Box::new(AddPanel {
panel: PanelKind::Room(room),
position: ui::dock::DockPlacement::Center,
}))
}
}
impl Render for InboxListItem {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let ago = ago(self.event.created_at.as_u64());
let fallback_name = show_npub(self.event.pubkey, 16);
let mut content = div()
.font_medium()
.text_color(cx.theme().sidebar_accent_foreground);
if let Some(metadata) = self.metadata.read(cx).as_ref() {
content = content
.flex()
.items_center()
.gap_2()
.map(|this| {
if let Some(picture) = metadata.picture.clone() {
this.flex_shrink_0().child(
img(format!(
"{}/?url={}&w=72&h=72&fit=cover&mask=circle&n=-1",
IMAGE_SERVICE, picture
))
.size_6(),
)
} else {
this.flex_shrink_0()
.child(img("brand/avatar.png").size_6().rounded_full())
}
})
.map(|this| {
if let Some(display_name) = metadata.display_name.clone() {
this.child(display_name)
} else {
this.child(fallback_name)
}
})
} else {
content = content
.flex()
.items_center()
.gap_2()
.child(
img("brand/avatar.png")
.flex_shrink_0()
.size_6()
.rounded_full(),
)
.child(fallback_name)
}
div()
.id(self.id.clone())
.h_8()
.px_1()
.flex()
.items_center()
.justify_between()
.text_xs()
.rounded_md()
.hover(|this| {
this.bg(cx.theme().sidebar_accent)
.text_color(cx.theme().sidebar_accent_foreground)
})
.child(content)
.child(
div()
.child(ago)
.text_color(cx.theme().sidebar_accent_foreground.opacity(0.7)),
)
.on_click(cx.listener(|this, _, cx| {
this.action(cx);
}))
}
}

216
crates/app/src/views/inbox/mod.rs
View File

@@ -1,216 +0,0 @@
use gpui::*;
use itertools::Itertools;
use nostr_sdk::prelude::*;
use prelude::FluentBuilder;
use std::cmp::Reverse;
use ui::{skeleton::Skeleton, theme::ActiveTheme, v_flex, Collapsible, Icon, IconName, StyledExt};
use super::inbox::item::InboxListItem;
use crate::{get_client, states::chat::ChatRegistry, utils::get_room_id};
pub mod item;
pub struct Inbox {
label: SharedString,
items: Model<Option<Vec<View<InboxListItem>>>>,
is_loading: bool,
is_collapsed: bool,
}
impl Inbox {
pub fn new(cx: &mut ViewContext<'_, Self>) -> Self {
let items = cx.new_model(|_| None);
cx.observe_global::<ChatRegistry>(|this, cx| {
let state = cx.global::<ChatRegistry>();
let empty_messages = state.new_messages.read().unwrap().is_empty();
if state.reload || (state.is_initialized && empty_messages) {
this.load(cx);
} else {
#[allow(clippy::collapsible_if)]
if let Some(items) = this.items.read(cx).as_ref() {
// Get all current chats
let current_rooms: Vec<String> =
items.iter().map(|item| item.model.read(cx).id()).collect();
// Get all new messages
let messages = state
.new_messages
.read()
.unwrap()
.clone()
.into_iter()
.filter(|m| {
let keys = m.event.tags.public_keys().copied().collect::<Vec<_>>();
let new_id = get_room_id(&m.event.pubkey, &keys);
!current_rooms.iter().any(|id| id == &new_id)
})
.collect::<Vec<_>>();
// Create view for new chats only
let new = messages
.into_iter()
.map(|m| cx.new_view(|cx| InboxListItem::new(m.event, cx)))
.collect::<Vec<_>>();
cx.update_model(&this.items, |a, b| {
if let Some(items) = a {
items.extend(new);
b.notify();
}
});
}
}
})
.detach();
cx.observe_new_views::<InboxListItem>(|item, cx| {
item.request_metadata(cx);
item.load_metadata(cx);
})
.detach();
Self {
items,
label: "Inbox".into(),
is_loading: true,
is_collapsed: false,
}
}
pub fn load(&mut self, cx: &mut ViewContext<Self>) {
// Hide loading indicator
self.set_loading(cx);
let items = self.items.read(cx).as_ref();
// Get all current rooms id
let current_rooms: Vec<String> = if let Some(items) = items {
items.iter().map(|item| item.model.read(cx).id()).collect()
} else {
Vec::new()
};
let async_items = self.items.clone();
let mut async_cx = cx.to_async();
cx.foreground_executor()
.spawn(async move {
let client = get_client();
let signer = client.signer().await.unwrap();
let public_key = signer.get_public_key().await.unwrap();
let filter = Filter::new()
.kind(Kind::PrivateDirectMessage)
.pubkey(public_key);
let events = async_cx
.background_executor()
.spawn(async move {
if let Ok(events) = client.database().query(vec![filter]).await {
events
.into_iter()
.filter(|ev| ev.pubkey != public_key) // Filter all messages from current user
.unique_by(|ev| ev.pubkey)
.sorted_by_key(|ev| Reverse(ev.created_at))
.collect::<Vec<_>>()
} else {
Vec::new()
}
})
.await;
let views: Vec<View<InboxListItem>> = events
.into_iter()
.filter(|ev| {
let keys = ev.tags.public_keys().copied().collect::<Vec<_>>();
let new_id = get_room_id(&ev.pubkey, &keys);
!current_rooms.iter().any(|id| id == &new_id)
})
.map(|ev| async_cx.new_view(|cx| InboxListItem::new(ev, cx)).unwrap())
.collect();
async_cx.update_model(&async_items, |model, cx| {
if let Some(items) = model {
items.extend(views);
} else {
*model = Some(views);
}
cx.notify();
})
})
.detach();
}
fn set_loading(&mut self, cx: &mut ViewContext<Self>) {
self.is_loading = false;
cx.notify();
}
}
impl Collapsible for Inbox {
fn is_collapsed(&self) -> bool {
self.is_collapsed
}
fn collapsed(mut self, collapsed: bool) -> Self {
self.is_collapsed = collapsed;
self
}
}
impl Render for Inbox {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let mut content = div();
if self.is_loading {
content = content.children((0..5).map(|_| {
div()
.h_8()
.px_1()
.flex()
.items_center()
.gap_2()
.child(Skeleton::new().flex_shrink_0().size_6().rounded_full())
.child(Skeleton::new().w_20().h_3().rounded_sm())
}))
} else if let Some(items) = self.items.read(cx).as_ref() {
content = content.children(items.clone())
} else {
// TODO: handle error
}
v_flex()
.px_2()
.gap_1()
.child(
div()
.id("inbox")
.h_7()
.px_1()
.flex()
.items_center()
.rounded_md()
.text_xs()
.font_semibold()
.text_color(cx.theme().sidebar_foreground.opacity(0.7))
.hover(|this| this.bg(cx.theme().sidebar_accent.opacity(0.7)))
.on_click(cx.listener(move |view, _event, cx| {
view.is_collapsed = !view.is_collapsed;
cx.notify();
}))
.child(
Icon::new(IconName::ChevronDown)
.size_6()
.when(self.is_collapsed, |this| {
this.rotate(percentage(270. / 360.))
}),
)
.child(self.label.clone()),
)
.when(!self.is_collapsed, |this| this.child(content))
}
}

6
crates/app/src/views/mod.rs
View File

@@ -1,9 +1,7 @@
pub mod app;
mod account;
mod chat;
mod contact;
mod inbox;
mod onboarding;
mod sidebar;
mod welcome;
pub mod app;

5
crates/app/src/views/onboarding/mod.rs
View File

@@ -1,4 +1,7 @@
use gpui::*;
use gpui::{
div, IntoElement,
ParentElement, Render, Styled, View, ViewContext, VisualContext,
};
use nostr_sdk::prelude::*;
use ui::{
input::{InputEvent, TextInput},

10
crates/app/src/views/sidebar/contact_list.rs
View File

@@ -1,5 +1,6 @@
use std::collections::{BTreeSet, HashSet};
use crate::{
constants::IMAGE_SERVICE, get_client, states::account::AccountRegistry, utils::show_npub,
};
use gpui::{
div, img, impl_actions, list, px, Context, ElementId, FocusHandle, InteractiveElement,
IntoElement, ListAlignment, ListState, Model, ParentElement, Pixels, Render, RenderOnce,
@@ -7,16 +8,13 @@ use gpui::{
};
use nostr_sdk::prelude::*;
use serde::Deserialize;
use std::collections::{BTreeSet, HashSet};
use ui::{
prelude::FluentBuilder,
theme::{ActiveTheme, Colorize},
Icon, IconName, Selectable, StyledExt,
};
use crate::{
constants::IMAGE_SERVICE, get_client, states::account::AccountRegistry, utils::show_npub,
};
#[derive(Clone, PartialEq, Eq, Deserialize)]
struct SelectContact(PublicKey);

255
crates/app/src/views/sidebar/inbox.rs Normal file
View File

@@ -0,0 +1,255 @@
use crate::{
constants::IMAGE_SERVICE,
get_client,
states::chat::ChatRegistry,
states::chat::Room,
utils::get_room_id,
utils::{ago, show_npub},
views::app::{AddPanel, PanelKind},
};
use gpui::prelude::FluentBuilder;
use gpui::{
div, img, percentage, Context, InteractiveElement, IntoElement, Model, ParentElement, Render,
SharedString, StatefulInteractiveElement, Styled, View, ViewContext, VisualContext,
WindowContext,
};
use nostr_sdk::prelude::*;
use std::sync::Arc;
use ui::{skeleton::Skeleton, theme::ActiveTheme, v_flex, Collapsible, Icon, IconName, StyledExt};
struct InboxListItem {
id: SharedString,
event: Event,
metadata: Option<Metadata>,
}
impl InboxListItem {
pub fn new(event: Event, metadata: Option<Metadata>, _cx: &mut ViewContext<'_, Self>) -> Self {
let id = SharedString::from(get_room_id(&event.pubkey, &event.tags));
Self {
id,
event,
metadata,
}
}
pub fn action(&self, cx: &mut WindowContext<'_>) {
let room = Arc::new(Room::parse(&self.event, self.metadata.clone()));
cx.dispatch_action(Box::new(AddPanel {
panel: PanelKind::Room(room),
position: ui::dock::DockPlacement::Center,
}))
}
}
impl Render for InboxListItem {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let ago = ago(self.event.created_at.as_u64());
let fallback_name = show_npub(self.event.pubkey, 16);
let mut content = div()
.font_medium()
.text_color(cx.theme().sidebar_accent_foreground);
if let Some(metadata) = self.metadata.clone() {
content = content
.flex()
.items_center()
.gap_2()
.map(|this| {
if let Some(picture) = metadata.picture.clone() {
this.flex_shrink_0().child(
img(format!(
"{}/?url={}&w=72&h=72&fit=cover&mask=circle&n=-1",
IMAGE_SERVICE, picture
))
.size_6(),
)
} else {
this.flex_shrink_0()
.child(img("brand/avatar.png").size_6().rounded_full())
}
})
.map(|this| {
if let Some(display_name) = metadata.display_name.clone() {
this.child(display_name)
} else {
this.child(fallback_name)
}
})
} else {
content = content
.flex()
.items_center()
.gap_2()
.child(
img("brand/avatar.png")
.flex_shrink_0()
.size_6()
.rounded_full(),
)
.child(fallback_name)
}
div()
.id(self.id.clone())
.h_8()
.px_1()
.flex()
.items_center()
.justify_between()
.text_xs()
.rounded_md()
.hover(|this| {
this.bg(cx.theme().sidebar_accent)
.text_color(cx.theme().sidebar_accent_foreground)
})
.child(content)
.child(
div()
.child(ago)
.text_color(cx.theme().sidebar_accent_foreground.opacity(0.7)),
)
.on_click(cx.listener(|this, _, cx| {
this.action(cx);
}))
}
}
pub struct Inbox {
label: SharedString,
items: Model<Option<Vec<View<InboxListItem>>>>,
is_loading: bool,
is_collapsed: bool,
}
impl Inbox {
pub fn new(cx: &mut ViewContext<'_, Self>) -> Self {
let items = cx.new_model(|_| None);
cx.observe_global::<ChatRegistry>(|this, cx| {
if cx.global::<ChatRegistry>().is_initialized {
this.load(cx)
}
})
.detach();
Self {
items,
label: "Inbox".into(),
is_loading: true,
is_collapsed: false,
}
}
pub fn load(&mut self, cx: &mut ViewContext<Self>) {
// Hide loading indicator
self.set_loading(cx);
// Get all room's events
let events: Vec<Event> = cx.global::<ChatRegistry>().rooms.read(cx).clone();
cx.spawn(|view, mut async_cx| async move {
let client = get_client();
let mut views = Vec::new();
for event in events.into_iter() {
let metadata = async_cx
.background_executor()
.spawn(async move { client.database().metadata(event.pubkey).await })
.await;
let item = async_cx
.new_view(|cx| {
if let Ok(metadata) = metadata {
InboxListItem::new(event, metadata, cx)
} else {
InboxListItem::new(event, None, cx)
}
})
.unwrap();
views.push(item);
}
_ = view.update(&mut async_cx, |this, cx| {
this.items.update(cx, |model, cx| {
*model = Some(views);
cx.notify()
});
});
})
.detach();
}
fn set_loading(&mut self, cx: &mut ViewContext<Self>) {
self.is_loading = false;
cx.notify();
}
}
impl Collapsible for Inbox {
fn collapsed(mut self, collapsed: bool) -> Self {
self.is_collapsed = collapsed;
self
}
fn is_collapsed(&self) -> bool {
self.is_collapsed
}
}
impl Render for Inbox {
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
let mut content = div();
if self.is_loading {
content = content.children((0..5).map(|_| {
div()
.h_8()
.px_1()
.flex()
.items_center()
.gap_2()
.child(Skeleton::new().flex_shrink_0().size_6().rounded_full())
.child(Skeleton::new().w_20().h_3().rounded_sm())
}))
} else if let Some(items) = self.items.read(cx).as_ref() {
content = content.children(items.clone())
} else {
// TODO: handle error
}
v_flex()
.px_2()
.gap_1()
.child(
div()
.id("inbox")
.h_7()
.px_1()
.flex()
.items_center()
.rounded_md()
.text_xs()
.font_semibold()
.text_color(cx.theme().sidebar_foreground.opacity(0.7))
.hover(|this| this.bg(cx.theme().sidebar_accent.opacity(0.7)))
.on_click(cx.listener(move |view, _event, cx| {
view.is_collapsed = !view.is_collapsed;
cx.notify();
}))
.child(
Icon::new(IconName::ChevronDown)
.size_6()
.when(self.is_collapsed, |this| {
this.rotate(percentage(270. / 360.))
}),
)
.child(self.label.clone()),
)
.when(!self.is_collapsed, |this| this.child(content))
}
}

37
crates/app/src/views/sidebar/mod.rs
View File

@@ -1,9 +1,10 @@
use std::sync::Arc;
use crate::views::sidebar::inbox::Inbox;
use contact_list::ContactList;
use gpui::*;
use nostr_sdk::Timestamp;
use rnglib::{Language, RNG};
use gpui::{
div, AnyElement, AppContext, Entity, EntityId, EventEmitter, FocusHandle, FocusableView,
IntoElement, ParentElement, Render, SharedString, Styled, View, ViewContext, VisualContext,
WindowContext,
};
use ui::{
button::{Button, ButtonRounded, ButtonVariants},
dock::{Panel, PanelEvent, PanelState},
@@ -12,14 +13,8 @@ use ui::{
v_flex, ContextModal, Icon, IconName, Sizable, StyledExt,
};
use crate::states::{account::AccountRegistry, chat::Room};
use super::{
app::{AddPanel, PanelKind},
inbox::Inbox,
};
mod contact_list;
mod inbox;
pub struct Sidebar {
// Panel
@@ -64,23 +59,7 @@ impl Sidebar {
.on_click({
let contact_list = contact_list.clone();
move |_, cx| {
let members = contact_list.model.read(cx).selected();
let owner = cx.global::<AccountRegistry>().get().unwrap();
let rng = RNG::from(&Language::Roman);
let name = rng.generate_names(2, true).join("-").to_lowercase();
let room = Arc::new(Room::new(
owner,
members,
Timestamp::now(),
Some(name.into()),
cx,
));
cx.dispatch_action(Box::new(AddPanel {
panel: PanelKind::Room(room),
position: ui::dock::DockPlacement::Center,
}))
// TODO: open room
}
}),
),

5
crates/app/src/views/welcome.rs
View File

@@ -1,4 +1,7 @@
use gpui::*;
use gpui::{
div, AnyElement, AppContext, EventEmitter, FocusHandle, FocusableView, IntoElement,
ParentElement, Render, SharedString, Styled, View, ViewContext, VisualContext, WindowContext,
};
use ui::{
button::Button,
dock::{Panel, PanelEvent, PanelState},