- Replace every hand drawn symbol and unicode glyph with Lucide icons via Symbol, with tooltips on icon buttons (built-in Tooltip, which does not swallow clicks), a proper gear and a clear log-out button for leaving a server. - Center text and controls vertically in channel rows, headers, the user panel and friend rows. - Message actions: quick reactions, add reaction, reply, edit and delete as icons. The bar stays visible while the pointer is over its buttons. - Emoji picker with categories and Russian and English search for the composer and for reactions. Reactions are shown under the message and toggle on click (ReactionAdd or ReactionRemove). - Remove the keyboard hint under the composer, add a placeholder and a growing editor with emoji and send buttons. - Voice room: participant cards with avatar and speaking ring, round icon controls with off states in red, accent gradient background. - One AvatarView everywhere (including voice cards and members). The local user is listed as online in the member list. - Real checkbox on the connect screen, theme overlay colour for the trust dialog, accent primary button. - ui_smoke now renders screens in all four themes and checks the member status, the action bar and the picker with real pointer input.
881 lines
30 KiB
Rust
881 lines
30 KiB
Rust
mod ui;
|
|
|
|
use std::cell::RefCell;
|
|
use std::rc::Rc;
|
|
use std::time::Duration;
|
|
|
|
use crate::ui::slint::MainWindow;
|
|
use anyhow::Result;
|
|
use slint::ComponentHandle;
|
|
use tracing::info;
|
|
use tracing_subscriber::EnvFilter;
|
|
use vnox_client::audio::AudioPipeline;
|
|
use vnox_client::audio::PipelineConfig;
|
|
use vnox_client::audio::sounds::SoundEvent;
|
|
use vnox_client::identity;
|
|
use vnox_client::net;
|
|
use vnox_client::net::NetCommand;
|
|
use vnox_client::net::NetHandle;
|
|
|
|
use crate::ui::state::{ConnState, UiState};
|
|
|
|
pub struct AppState {
|
|
pub(crate) webhooks: Option<Rc<ui::webhooks::WebhookUi>>,
|
|
pub(crate) connection_generation: u64,
|
|
pub(crate) identity: identity::Identity,
|
|
pub(crate) net: NetHandle,
|
|
pub(crate) ui: UiState,
|
|
pub(crate) audio: Option<AudioPipeline>,
|
|
pub(crate) voice_channel: Option<String>,
|
|
pub(crate) last_pipeline_config: Option<PipelineConfig>,
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
ui::i18n::initialize();
|
|
let filter = EnvFilter::try_from_default_env()
|
|
.unwrap_or_else(|_| EnvFilter::new("info,wgpu=warn,wgpu_hal=warn,naga=warn"));
|
|
tracing_subscriber::fmt().with_env_filter(filter).init();
|
|
|
|
let Some(identity) = load_identity()? else {
|
|
return Ok(());
|
|
};
|
|
info!("identity: {}", identity.short_id());
|
|
|
|
let rt = tokio::runtime::Builder::new_multi_thread()
|
|
.enable_all()
|
|
.build()?;
|
|
let _guard = rt.enter();
|
|
|
|
let net = net::spawn(identity.clone());
|
|
|
|
let state = Rc::new(RefCell::new(AppState {
|
|
webhooks: None,
|
|
connection_generation: 0,
|
|
identity,
|
|
net,
|
|
ui: UiState::default(),
|
|
audio: None,
|
|
voice_channel: None,
|
|
last_pipeline_config: None,
|
|
}));
|
|
|
|
{
|
|
let mut s = state.borrow_mut();
|
|
crate::ui::preferences::load(&mut s.ui);
|
|
s.ui.appearance = crate::ui::appearance::AppearancePreferences::load();
|
|
s.ui.vault_enabled = identity::is_vault_encrypted();
|
|
let user_id = s.identity.pubkey_hex.clone();
|
|
let nickname = s.identity.nickname.clone();
|
|
s.ui.user_names.insert(user_id, nickname);
|
|
}
|
|
let window = MainWindow::new()?;
|
|
window.set_address_input(state.borrow().ui.connect_input.as_str().into());
|
|
refresh_devices(&window, &mut state.borrow_mut().ui);
|
|
|
|
let webhook_net = state.borrow().net.clone();
|
|
state.borrow_mut().webhooks = Some(Rc::new(ui::webhooks::WebhookUi::new(Rc::new(
|
|
move |command| {
|
|
let net = webhook_net.clone();
|
|
tokio::spawn(async move {
|
|
net.send(command).await;
|
|
});
|
|
},
|
|
))?));
|
|
wire_signals(&window, &state);
|
|
ui::media::wire(&window, &state)?;
|
|
|
|
let timer = slint::Timer::default();
|
|
{
|
|
let state = state.clone();
|
|
let weak = window.as_weak();
|
|
timer.start(
|
|
slint::TimerMode::Repeated,
|
|
Duration::from_millis(16),
|
|
move || {
|
|
if let Some(win) = weak.upgrade() {
|
|
let mut s = state.borrow_mut();
|
|
crate::ui::update::process_net_events(&mut s);
|
|
let own_id = s.identity.pubkey_hex.clone();
|
|
let own_nick = s.identity.nickname.clone();
|
|
let own_pubkey = s.identity.pubkey_hex.clone();
|
|
crate::ui::bridge::sync_ui(&win, &s.ui, &own_id, &own_nick, &own_pubkey);
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
window.run()?;
|
|
Ok(())
|
|
}
|
|
|
|
fn load_identity() -> Result<Option<identity::Identity>> {
|
|
match identity::load_or_generate() {
|
|
Ok(identity) => Ok(Some(identity)),
|
|
Err(error) if error.downcast_ref::<identity::LoadError>().is_some() => {
|
|
let dialog = crate::ui::slint::UnlockWindow::new()?;
|
|
let appearance = crate::ui::appearance::AppearancePreferences::load();
|
|
if let Ok(spec) = appearance.resolve() {
|
|
crate::ui::appearance::apply_unlock(&dialog, &spec);
|
|
}
|
|
ui::i18n::set_language(ui::i18n::current());
|
|
let unlocked = Rc::new(RefCell::new(None));
|
|
let result = unlocked.clone();
|
|
let weak = dialog.as_weak();
|
|
dialog.on_unlock(move |passphrase| {
|
|
if let Some(dialog) = weak.upgrade() {
|
|
match identity::load_with_passphrase(passphrase.as_str()) {
|
|
Ok(identity) => {
|
|
*result.borrow_mut() = Some(identity);
|
|
let _ = dialog.hide();
|
|
}
|
|
Err(_) => dialog.set_error(
|
|
crate::ui::i18n::text(
|
|
"Could not unlock your profile. Check your passphrase.",
|
|
)
|
|
.into(),
|
|
),
|
|
}
|
|
}
|
|
});
|
|
dialog.run()?;
|
|
let identity = unlocked.borrow_mut().take();
|
|
Ok(identity)
|
|
}
|
|
Err(error) => Err(error),
|
|
}
|
|
}
|
|
|
|
fn refresh_devices(window: &MainWindow, ui: &mut UiState) {
|
|
crate::ui::devices::refresh(ui);
|
|
let model = |items: Vec<String>| {
|
|
Rc::new(slint::VecModel::from(
|
|
items
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(index, label)| {
|
|
// Position 0 is always the system default.
|
|
slint::SharedString::from(if index == 0 {
|
|
crate::ui::i18n::text("Default audio device")
|
|
} else {
|
|
label
|
|
})
|
|
})
|
|
.collect::<Vec<_>>(),
|
|
))
|
|
.into()
|
|
};
|
|
window.set_input_devices(model(ui.device_lists.input_labels()));
|
|
window.set_output_devices(model(ui.device_lists.output_labels()));
|
|
}
|
|
|
|
fn wire_signals(window: &MainWindow, state: &Rc<RefCell<AppState>>) {
|
|
{
|
|
let state = state.clone();
|
|
let weak = window.as_weak();
|
|
window.on_open_webhooks(move || {
|
|
let s = state.borrow();
|
|
let Some(window) = weak.upgrade() else { return };
|
|
if let Some(webhooks) = &s.webhooks {
|
|
let channel =
|
|
s.ui.active_channel
|
|
.as_deref()
|
|
.and_then(|id| s.ui.channels.iter().find(|c| c.id == id));
|
|
let scope = vnox_client::webhooks::Scope {
|
|
connection: s.connection_generation,
|
|
channel_id: channel.map(|c| c.id.clone()).unwrap_or_default(),
|
|
channel_name: channel.map(|c| c.name.clone()).unwrap_or_default(),
|
|
guild_id: channel.and_then(|c| c.guild_id.clone()).unwrap_or_default(),
|
|
};
|
|
if let Err(error) = webhooks.open(
|
|
&window,
|
|
scope,
|
|
matches!(s.ui.conn, ConnState::Connected { .. }),
|
|
) {
|
|
tracing::warn!(%error,"Cannot open webhooks");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
ui::emoji::wire(window);
|
|
crate::ui::appearance::wire(window, state, !cfg!(test));
|
|
ui::i18n::wire(window, !cfg!(test));
|
|
crate::ui::avatar::wire(window, state, !cfg!(test));
|
|
{
|
|
let state = state.clone();
|
|
window.on_dismiss_status(move || state.borrow_mut().ui.status_msg = None);
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_input_edited(move |text| state.borrow_mut().ui.remember_draft(text.to_string()));
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window
|
|
.on_address_edited(move |text| state.borrow_mut().ui.connect_input = text.to_string());
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_auto_reconnect_changed(move |value| state.borrow_mut().ui.auto_reconnect = value);
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window
|
|
.on_friends_tab_changed(move |tab| state.borrow_mut().ui.friends_tab = tab.to_string());
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
let weak = window.as_weak();
|
|
window.on_open_settings(move || {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.settings_open = true;
|
|
if let Some(window) = weak.upgrade() {
|
|
refresh_devices(&window, &mut s.ui);
|
|
}
|
|
});
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_show_voice_view(move || state.borrow_mut().ui.showing_voice = true);
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_show_friends_view(move || state.borrow_mut().ui.select_friends());
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_ptt_held(move |held| state.borrow_mut().ui.ptt_held = held);
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_audio_settings_changed(move |input, output, bitrate, mode, volume| {
|
|
let mut s = state.borrow_mut();
|
|
crate::ui::devices::select(&mut s.ui, input.max(0) as usize, output.max(0) as usize);
|
|
s.ui.voice_bitrate = bitrate.clamp(8.0, 128.0);
|
|
let mode = mode.clamp(0, 2) as usize;
|
|
if mode != s.ui.vad_mode {
|
|
// Only a real change counts as the person's own choice.
|
|
s.ui.vad_mode_chosen = true;
|
|
}
|
|
s.ui.vad_mode = mode;
|
|
s.ui.output_volume = volume.clamp(0.0, 100.0);
|
|
if let Err(error) = crate::ui::preferences::save(&s.ui) {
|
|
s.ui.status_msg = Some(ui::i18n::Message::with(
|
|
"Cannot save audio settings: {error}",
|
|
vec![("error", error.to_string())],
|
|
));
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_channel_selected(move |id| {
|
|
let id = id.to_string();
|
|
let mut s = state.borrow_mut();
|
|
let is_voice =
|
|
s.ui.channels
|
|
.iter()
|
|
.any(|c| c.id == id && c.kind == "voice");
|
|
let send_join = if is_voice {
|
|
s.ui.request_voice_join(&id)
|
|
} else {
|
|
s.ui.select_text_channel(id.clone());
|
|
true
|
|
};
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
if send_join {
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::JoinChannel { channel_id: id }).await;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_guild_selected(move |idx| {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.active_guild_id = if idx >= 0 {
|
|
s.ui.guilds
|
|
.get(idx as usize)
|
|
.map(|guild| guild.guild_id.clone())
|
|
} else {
|
|
None
|
|
};
|
|
s.ui.browsing_dms = false;
|
|
let destination =
|
|
s.ui.channels
|
|
.iter()
|
|
.find(|channel| {
|
|
channel.kind == "text"
|
|
&& (s.ui.active_guild_id.is_none()
|
|
|| channel.guild_id == s.ui.active_guild_id)
|
|
})
|
|
.map(|channel| channel.id.clone());
|
|
if let Some(channel_id) = destination {
|
|
s.ui.select_text_channel(channel_id.clone());
|
|
let net = s.net.clone();
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::JoinChannel { channel_id }).await;
|
|
});
|
|
} else {
|
|
s.ui.active_dm_id = None;
|
|
s.ui.active_channel = None;
|
|
s.ui.showing_voice = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_dm_selected(move |dm_id| {
|
|
let mut s = state.borrow_mut();
|
|
let id = dm_id.to_string();
|
|
if s.ui.dm_conversations.iter().any(|c| c.dm_id == id) {
|
|
s.ui.select_dm(id.clone());
|
|
if let Some(dm) = s.ui.dm_conversations.iter_mut().find(|c| c.dm_id == id) {
|
|
dm.unread_count = 0;
|
|
}
|
|
let net = s.net.clone();
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::DmReadAck { dm_id: id }).await;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_connect(move |addr| {
|
|
let addr = addr.to_string();
|
|
let mut s = state.borrow_mut();
|
|
s.ui.conn = ConnState::Connecting;
|
|
s.ui.connect_input = addr.clone();
|
|
s.ui.status_msg = Some("Connecting…".into());
|
|
let auto_reconnect = s.ui.auto_reconnect;
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::Connect {
|
|
address: addr,
|
|
auto_reconnect,
|
|
})
|
|
.await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
// First trust: remember the confirmed fingerprint, then connect again.
|
|
let state = state.clone();
|
|
window.on_trust_accept(move || {
|
|
let mut s = state.borrow_mut();
|
|
let Some(prompt) = s.ui.trust_prompt.take() else {
|
|
return;
|
|
};
|
|
if prompt.kind != ui::state::TrustPromptKind::FirstUse {
|
|
return;
|
|
}
|
|
if let Err(error) = s.net.trust().pin(&prompt.address, &prompt.received) {
|
|
tracing::warn!(%error, "could not save the trusted fingerprint");
|
|
s.ui.status_msg = Some("Could not save the trusted fingerprint".into());
|
|
return;
|
|
}
|
|
s.ui.conn = ConnState::Connecting;
|
|
s.ui.status_msg = Some("Connecting…".into());
|
|
let auto_reconnect = s.ui.auto_reconnect;
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::Connect {
|
|
address: prompt.address,
|
|
auto_reconnect,
|
|
})
|
|
.await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
// A blocked change: forgetting is the only way forward and needs a new decision.
|
|
let state = state.clone();
|
|
window.on_trust_forget(move || {
|
|
let mut s = state.borrow_mut();
|
|
let Some(prompt) = s.ui.trust_prompt.take() else {
|
|
return;
|
|
};
|
|
if let Err(error) = s.net.trust().forget(&prompt.address) {
|
|
tracing::warn!(%error, "could not forget the server");
|
|
}
|
|
s.ui.status_msg =
|
|
Some("Server forgotten. Connect again to review its fingerprint.".into());
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_trust_dismiss(move || {
|
|
state.borrow_mut().ui.trust_prompt = None;
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_disconnect(move || {
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::Disconnect).await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_send_message(move |ch_id, text| {
|
|
let ch_id = ch_id.to_string();
|
|
let text = text.to_string();
|
|
if text.trim().is_empty() {
|
|
return;
|
|
}
|
|
let mut s = state.borrow_mut();
|
|
if !matches!(s.ui.conn, ConnState::Connected { .. }) {
|
|
s.ui.status_msg = Some("Not connected to a server. Your draft has been kept.".into());
|
|
return;
|
|
}
|
|
if let Some(dm_id) = s.ui.active_dm_id.as_ref()
|
|
&& s.ui.dm_conversations.iter().any(|c| &c.dm_id == dm_id && c.e2ee_enabled)
|
|
{
|
|
s.ui.status_msg = Some("Encrypted messaging is temporarily unavailable. Your draft has been kept; the message was not sent.".into());
|
|
return;
|
|
}
|
|
|
|
if let Some(edit_id) = s.ui.editing_message_id.take() {
|
|
let net = s.net.clone();
|
|
s.ui.remember_draft(String::new());
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::MessageEdit {
|
|
channel_id: ch_id,
|
|
message_id: edit_id,
|
|
content: text,
|
|
})
|
|
.await;
|
|
});
|
|
return;
|
|
}
|
|
|
|
let reply_to = s.ui.replying_to_message.take();
|
|
s.ui.replying_to_sender.clear();
|
|
s.ui.replying_to_content.clear();
|
|
s.ui.remember_draft(String::new());
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
|
|
if !ch_id.is_empty() {
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::SendChat {
|
|
channel_id: ch_id,
|
|
content: text,
|
|
reply_to,
|
|
})
|
|
.await;
|
|
});
|
|
} else {
|
|
let s = state.borrow();
|
|
if let Some(dm_id) = s.ui.active_dm_id.clone() {
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::DmSend {
|
|
dm_id,
|
|
content: text,
|
|
})
|
|
.await;
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_add_friend(move |user_id| {
|
|
let user_id = user_id.to_string();
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::FriendRequest {
|
|
target_user_id: user_id,
|
|
})
|
|
.await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_accept_friend(move |user_id| {
|
|
let user_id = user_id.to_string();
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::FriendAccept { user_id }).await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_decline_friend(move |user_id| {
|
|
let user_id = user_id.to_string();
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::FriendDecline { user_id }).await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_remove_friend(move |user_id| {
|
|
let user_id = user_id.to_string();
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::FriendRemove { user_id }).await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_start_dm(move |user_id| {
|
|
let user_id = user_id.to_string();
|
|
let s = state.borrow();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::DmStart {
|
|
target_user_id: user_id,
|
|
})
|
|
.await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_sound_settings_changed(move |enabled, volume, voice_room, messages, mentions| {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.sounds = vnox_client::audio::sounds::SoundSettings {
|
|
enabled,
|
|
volume: volume.clamp(0.0, 100.0),
|
|
voice_room,
|
|
messages,
|
|
mentions,
|
|
};
|
|
if let Err(error) = crate::ui::preferences::save(&s.ui) {
|
|
s.ui.status_msg = Some(ui::i18n::Message::with(
|
|
"Cannot save audio settings: {error}",
|
|
vec![("error", error.to_string())],
|
|
));
|
|
}
|
|
});
|
|
}
|
|
{
|
|
let state = state.clone();
|
|
window.on_preview_sound(move || crate::ui::sounds::preview(&state.borrow()));
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_toggle_mic(move || {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.mic_enabled = !s.ui.mic_enabled;
|
|
let event = if s.ui.mic_enabled {
|
|
SoundEvent::MicUnmuted
|
|
} else {
|
|
SoundEvent::MicMuted
|
|
};
|
|
crate::ui::sounds::play(&s, event);
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_toggle_deafen(move || {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.deafen = !s.ui.deafen;
|
|
let event = if s.ui.deafen {
|
|
SoundEvent::Deafened
|
|
} else {
|
|
SoundEvent::Undeafened
|
|
};
|
|
crate::ui::sounds::play(&s, event);
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_leave_voice(move || {
|
|
let mut s = state.borrow_mut();
|
|
let voice_channel = s.ui.voice_target.take();
|
|
let was_in_voice = s.audio.is_some();
|
|
crate::ui::update::stop_voice(&mut s);
|
|
if was_in_voice {
|
|
crate::ui::sounds::play(&s, SoundEvent::VoiceLeft);
|
|
}
|
|
s.ui.showing_voice = false;
|
|
s.ui.ptt_held = false;
|
|
let net = s.net.clone();
|
|
if let Some(channel_id) = voice_channel {
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::LeaveChannel { channel_id }).await;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_add_bookmark(move |addr| {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.connect_input = addr.to_string();
|
|
s.ui.add_bookmark_from_input();
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_remove_bookmark(move |address| {
|
|
let addr = address.to_string();
|
|
let mut s = state.borrow_mut();
|
|
if let Some(idx) = s.ui.bookmarks.iter().position(|b| b.address == addr) {
|
|
s.ui.remove_bookmark(idx);
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_load_more(move |_| {
|
|
state.borrow_mut().ui.status_msg =
|
|
Some("Earlier history is not available with this protocol version.".into());
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
let weak = window.as_weak();
|
|
window.on_close_settings(move || {
|
|
let mut state = state.borrow_mut();
|
|
state.ui.settings_open = false;
|
|
if let Some(window) = weak.upgrade() {
|
|
crate::ui::appearance::bindings_restore(&window, &state.ui.appearance);
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_set_passphrase(move |pass, confirm| {
|
|
let mut s = state.borrow_mut();
|
|
if pass != confirm {
|
|
s.ui.settings_passphrase_error = Some("Passphrases do not match".into());
|
|
return;
|
|
}
|
|
if pass.len() < 8 {
|
|
s.ui.settings_passphrase_error =
|
|
Some("Passphrase must be at least 8 characters".into());
|
|
return;
|
|
}
|
|
s.ui.settings_passphrase_error = None;
|
|
let identity = s.identity.clone();
|
|
drop(s);
|
|
match identity::save(&identity, Some(pass.as_str())) {
|
|
Ok(()) => state.borrow_mut().ui.vault_enabled = true,
|
|
Err(e) => {
|
|
state.borrow_mut().ui.settings_passphrase_error = Some(ui::i18n::Message::with(
|
|
"Could not update profile: {error}",
|
|
vec![("error", e.to_string())],
|
|
))
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_remove_passphrase(move || {
|
|
let s = state.borrow();
|
|
let identity = s.identity.clone();
|
|
drop(s);
|
|
match identity::save(&identity, None) {
|
|
Ok(()) => state.borrow_mut().ui.vault_enabled = false,
|
|
Err(e) => {
|
|
state.borrow_mut().ui.settings_passphrase_error = Some(ui::i18n::Message::with(
|
|
"Could not update profile: {error}",
|
|
vec![("error", e.to_string())],
|
|
))
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_export_keyfile(move |pass, confirm| {
|
|
let mut s = state.borrow_mut();
|
|
if pass != confirm {
|
|
s.ui.settings_export_error = Some("Passphrases do not match".into());
|
|
return;
|
|
}
|
|
let passphrase = if pass.is_empty() {
|
|
None
|
|
} else {
|
|
Some(pass.as_str())
|
|
};
|
|
let identity = s.identity.clone();
|
|
drop(s);
|
|
match identity::export_keyfile(&identity, passphrase) {
|
|
Ok(json) => {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.settings_export_output = Some(json);
|
|
s.ui.settings_export_error = None;
|
|
}
|
|
Err(e) => {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.settings_export_error = Some(ui::i18n::Message::with(
|
|
"Could not update profile: {error}",
|
|
vec![("error", e.to_string())],
|
|
));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_import_keyfile(move |input, pass| {
|
|
let input = input.to_string();
|
|
let passphrase = if pass.is_empty() {
|
|
None
|
|
} else {
|
|
Some(pass.as_str())
|
|
};
|
|
let mut s = state.borrow_mut();
|
|
match identity::import_keyfile(&input, passphrase) {
|
|
Ok(identity) => {
|
|
if let Err(e) = identity::save(&identity, None) {
|
|
s.ui.settings_import_error = Some(ui::i18n::Message::with(
|
|
"Could not update profile: {error}",
|
|
vec![("error", e.to_string())],
|
|
));
|
|
} else {
|
|
s.ui.settings_import_error = None;
|
|
s.ui.vault_enabled = false;
|
|
s.ui.status_msg =
|
|
Some("Profile imported. Restart Vnox to use your new keys.".into());
|
|
}
|
|
}
|
|
Err(e) => {
|
|
s.ui.settings_import_error = Some(ui::i18n::Message::with(
|
|
"Could not update profile: {error}",
|
|
vec![("error", e.to_string())],
|
|
));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_react(move |msg_id, emoji| {
|
|
let msg_id = msg_id.to_string();
|
|
let emoji = emoji.to_string();
|
|
let s = state.borrow();
|
|
let ch_id = s.ui.active_channel.clone().unwrap_or_default();
|
|
let net = s.net.clone();
|
|
let command =
|
|
ui::update::reaction_command(&s.ui, &s.identity.pubkey_hex, ch_id, msg_id, emoji);
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(command).await;
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_reply_to_msg(move |msg_id| {
|
|
let msg_id = msg_id.to_string();
|
|
let mut s = state.borrow_mut();
|
|
s.ui.replying_to_message = Some(msg_id.clone());
|
|
if let Some(ch_id) = s.ui.active_channel.clone()
|
|
&& let Some(msgs) = s.ui.messages.get(&ch_id)
|
|
&& let Some(m) = msgs.iter().find(|m| m.message_id == msg_id)
|
|
{
|
|
let sender = m.sender_id.clone();
|
|
let content = m.content.clone();
|
|
s.ui.replying_to_sender = s.ui.nick_for(&sender).to_owned();
|
|
s.ui.replying_to_content = content;
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_cancel_reply(move || {
|
|
let mut s = state.borrow_mut();
|
|
s.ui.replying_to_message = None;
|
|
s.ui.replying_to_sender.clear();
|
|
s.ui.replying_to_content.clear();
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_edit_msg(move |msg_id| {
|
|
let msg_id = msg_id.to_string();
|
|
let mut s = state.borrow_mut();
|
|
if let Some(ch_id) = s.ui.active_channel.clone()
|
|
&& let Some(msgs) = s.ui.messages.get(&ch_id)
|
|
&& let Some(m) = msgs.iter().find(|m| m.message_id == msg_id)
|
|
{
|
|
let content = m.content.clone();
|
|
s.ui.remember_draft(content);
|
|
s.ui.editing_message_id = Some(msg_id);
|
|
}
|
|
});
|
|
}
|
|
|
|
{
|
|
let state = state.clone();
|
|
window.on_delete_msg(move |msg_id| {
|
|
let msg_id = msg_id.to_string();
|
|
let s = state.borrow();
|
|
let ch_id = s.ui.active_channel.clone().unwrap_or_default();
|
|
let net = s.net.clone();
|
|
drop(s);
|
|
tokio::spawn(async move {
|
|
net.send(NetCommand::MessageDelete {
|
|
channel_id: ch_id,
|
|
message_id: msg_id,
|
|
})
|
|
.await;
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod ui_smoke;
|