tyiu/notedeck
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert driller

Browse Source 
This reverts commit cec49c83bd.

Revert "update NoteContentsDriller to NoteContext"

This reverts commit 65bd6a65f9.

Revert "introduce the driller"

This reverts commit 95d618e7fe.
This commit is contained in:
William Casarin
2025-03-07 12:53:04 -08:00
parent 50cf75b8bc
commit 4365839242
11 changed files with 495 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
crates/notedeck_columns/src/ui/note/contents.rs
View File

@@ -11,33 +11,33 @@ use tracing::warn;
use notedeck::{supported_mime_hosted_at_url, Images, MediaCacheType, NoteCache};
/// Aggregates dependencies to reduce the number of parameters
/// passed to inner UI elements, minimizing prop drilling.
pub struct NoteContext<'d> {
pub ndb: &'d Ndb,
pub img_cache: &'d mut Images,
pub note_cache: &'d mut NoteCache,
pub options: NoteOptions,
}
pub struct NoteContents<'a, 'd> {
note_context: &'a mut NoteContext<'d>,
pub struct NoteContents<'a> {
ndb: &'a Ndb,
img_cache: &'a mut Images,
note_cache: &'a mut NoteCache,
txn: &'a Transaction,
note: &'a Note<'a>,
options: NoteOptions,
action: Option<NoteAction>,
}
impl<'a, 'd> NoteContents<'a, 'd> {
impl<'a> NoteContents<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
note_context: &'a mut NoteContext<'d>,
ndb: &'a Ndb,
img_cache: &'a mut Images,
note_cache: &'a mut NoteCache,
txn: &'a Transaction,
note: &'a Note,
options: ui::note::NoteOptions,
) -> Self {
NoteContents {
note_context,
ndb,
img_cache,
note_cache,
txn,
note,
options,
action: None,
}
}
@@ -47,9 +47,17 @@ impl<'a, 'd> NoteContents<'a, 'd> {
}
}
impl egui::Widget for &mut NoteContents<'_, '_> {
impl egui::Widget for &mut NoteContents<'_> {
fn ui(self, ui: &mut egui::Ui) -> egui::Response {
let result = render_note_contents(ui, self.note_context, self.txn, self.note);
let result = render_note_contents(
ui,
self.ndb,
self.img_cache,
self.note_cache,
self.txn,
self.note,
self.options,
);
self.action = result.action;
result.response
}
@@ -60,15 +68,18 @@ impl egui::Widget for &mut NoteContents<'_, '_> {
#[allow(clippy::too_many_arguments)]
pub fn render_note_preview(
ui: &mut egui::Ui,
note_context: &mut NoteContext,
ndb: &Ndb,
note_cache: &mut NoteCache,
img_cache: &mut Images,
txn: &Transaction,
id: &[u8; 32],
parent: NoteKey,
note_options: NoteOptions,
) -> NoteResponse {
#[cfg(feature = "profiling")]
puffin::profile_function!();
let note = if let Ok(note) = note_context.ndb.get_note_by_id(txn, id) {
let note = if let Ok(note) = ndb.get_note_by_id(txn, id) {
// TODO: support other preview kinds
if note.kind() == 1 {
note
@@ -101,7 +112,7 @@ pub fn render_note_preview(
ui.visuals().noninteractive().bg_stroke.color,
))
.show(ui, |ui| {
ui::NoteView::new(note_context, &note)
ui::NoteView::new(ndb, note_cache, img_cache, &note, note_options)
.actionbar(false)
.small_pfp(true)
.wide(true)
@@ -116,23 +127,26 @@ pub fn render_note_preview(
#[allow(clippy::too_many_arguments)]
fn render_note_contents(
ui: &mut egui::Ui,
note_context: &mut NoteContext,
ndb: &Ndb,
img_cache: &mut Images,
note_cache: &mut NoteCache,
txn: &Transaction,
note: &Note,
options: NoteOptions,
) -> NoteResponse {
#[cfg(feature = "profiling")]
puffin::profile_function!();
let note_key = note.key().expect("todo: implement non-db notes");
let selectable = note_context.options.has_selectable_text();
let selectable = options.has_selectable_text();
let mut images: Vec<(String, MediaCacheType)> = vec![];
let mut note_action: Option<NoteAction> = None;
let mut inline_note: Option<(&[u8; 32], &str)> = None;
let hide_media = note_context.options.has_hide_media();
let hide_media = options.has_hide_media();
let link_color = ui.visuals().hyperlink_color;
let response = ui.horizontal_wrapped(|ui| {
let blocks = if let Ok(blocks) = note_context.ndb.get_blocks_by_key(txn, note_key) {
let blocks = if let Ok(blocks) = ndb.get_blocks_by_key(txn, note_key) {
blocks
} else {
warn!("missing note content blocks? '{}'", note.content());
@@ -146,38 +160,28 @@ fn render_note_contents(
match block.blocktype() {
BlockType::MentionBech32 => match block.as_mention().unwrap() {
Mention::Profile(profile) => {
let act = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
profile.pubkey(),
)
.show(ui)
.inner;
let act = ui::Mention::new(ndb, img_cache, txn, profile.pubkey())
.show(ui)
.inner;
if act.is_some() {
note_action = act;
}
}
Mention::Pubkey(npub) => {
let act = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
npub.pubkey(),
)
.show(ui)
.inner;
let act = ui::Mention::new(ndb, img_cache, txn, npub.pubkey())
.show(ui)
.inner;
if act.is_some() {
note_action = act;
}
}
Mention::Note(note) if note_context.options.has_note_previews() => {
Mention::Note(note) if options.has_note_previews() => {
inline_note = Some((note.id(), block.as_str()));
}
Mention::Event(note) if note_context.options.has_note_previews() => {
Mention::Event(note) if options.has_note_previews() => {
inline_note = Some((note.id(), block.as_str()));
}
@@ -204,7 +208,7 @@ fn render_note_contents(
let mut found_supported = || -> bool {
let url = block.as_str();
if let Some(cache_type) =
supported_mime_hosted_at_url(&mut note_context.img_cache.urls, url)
supported_mime_hosted_at_url(&mut img_cache.urls, url)
{
images.push((url.to_string(), cache_type));
true
@@ -225,7 +229,7 @@ fn render_note_contents(
BlockType::Text => {
#[cfg(feature = "profiling")]
puffin::profile_scope!("text contents");
if note_context.options.has_scramble_text() {
if options.has_scramble_text() {
ui.add(egui::Label::new(rot13(block.as_str())).selectable(selectable));
} else {
ui.add(egui::Label::new(block.as_str()).selectable(selectable));
@@ -240,15 +244,15 @@ fn render_note_contents(
});
let preview_note_action = if let Some((id, _block_str)) = inline_note {
render_note_preview(ui, note_context, txn, id, note_key).action
render_note_preview(ui, ndb, note_cache, img_cache, txn, id, note_key, options).action
} else {
None
};
if !images.is_empty() && !note_context.options.has_textmode() {
if !images.is_empty() && !options.has_textmode() {
ui.add_space(2.0);
let carousel_id = egui::Id::new(("carousel", note.key().expect("expected tx note")));
image_carousel(ui, note_context.img_cache, images, carousel_id);
image_carousel(ui, img_cache, images, carousel_id);
ui.add_space(2.0);
}

142
crates/notedeck_columns/src/ui/note/mod.rs
View File

@@ -7,7 +7,6 @@ pub mod reply;
pub mod reply_description;
pub use contents::NoteContents;
use contents::NoteContext;
pub use context::{NoteContextButton, NoteContextSelection};
pub use options::NoteOptions;
pub use post::{PostAction, PostResponse, PostType, PostView};
@@ -26,14 +25,17 @@ use egui::emath::{pos2, Vec2};
use egui::{Id, Label, Pos2, Rect, Response, RichText, Sense};
use enostr::{NoteId, Pubkey};
use nostrdb::{Ndb, Note, NoteKey, Transaction};
use notedeck::{CachedNote, NoteCache, NotedeckTextStyle};
use notedeck::{CachedNote, Images, NoteCache, NotedeckTextStyle};
use super::profile::preview::one_line_display_name_widget;
pub struct NoteView<'a, 'd> {
note_context: &'a mut NoteContext<'d>,
pub struct NoteView<'a> {
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
parent: Option<NoteKey>,
note: &'a nostrdb::Note<'a>,
flags: NoteOptions,
}
pub struct NoteResponse {
@@ -62,22 +64,31 @@ impl NoteResponse {
}
}
impl View for NoteView<'_, '_> {
impl View for NoteView<'_> {
fn ui(&mut self, ui: &mut egui::Ui) {
self.show(ui);
}
}
impl<'a, 'd> NoteView<'a, 'd> {
pub fn new(note_context: &'a mut NoteContext<'d>, note: &'a nostrdb::Note<'a>) -> Self {
note_context.options.set_actionbar(true);
note_context.options.set_note_previews(true);
impl<'a> NoteView<'a> {
pub fn new(
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
note: &'a nostrdb::Note<'a>,
mut flags: NoteOptions,
) -> Self {
flags.set_actionbar(true);
flags.set_note_previews(true);
let parent: Option<NoteKey> = None;
Self {
note_context,
ndb,
note_cache,
img_cache,
parent,
note,
flags,
}
}
@@ -122,11 +133,11 @@ impl<'a, 'd> NoteView<'a, 'd> {
}
pub fn options(&self) -> NoteOptions {
self.note_context.options
self.flags
}
pub fn options_mut(&mut self) -> &mut NoteOptions {
&mut self.note_context.options
&mut self.flags
}
pub fn parent(mut self, parent: NoteKey) -> Self {
@@ -139,16 +150,12 @@ impl<'a, 'd> NoteView<'a, 'd> {
let txn = self.note.txn().expect("todo: implement non-db notes");
ui.with_layout(egui::Layout::left_to_right(egui::Align::TOP), |ui| {
let profile = self
.note_context
.ndb
.get_profile_by_pubkey(txn, self.note.pubkey());
let profile = self.ndb.get_profile_by_pubkey(txn, self.note.pubkey());
//ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 2.0;
let cached_note = self
.note_context
.note_cache
.cached_note_or_insert_mut(note_key, self.note);
@@ -167,7 +174,14 @@ impl<'a, 'd> NoteView<'a, 'd> {
)
});
ui.add(&mut NoteContents::new(self.note_context, txn, self.note));
ui.add(&mut NoteContents::new(
self.ndb,
self.img_cache,
self.note_cache,
txn,
self.note,
self.flags,
));
//});
})
.response
@@ -212,17 +226,14 @@ impl<'a, 'd> NoteView<'a, 'd> {
anim_speed,
);
ui.put(
rect,
ui::ProfilePic::new(self.note_context.img_cache, pic).size(size),
)
.on_hover_ui_at_pointer(|ui| {
ui.set_max_width(300.0);
ui.add(ui::ProfilePreview::new(
profile.as_ref().unwrap(),
self.note_context.img_cache,
));
});
ui.put(rect, ui::ProfilePic::new(self.img_cache, pic).size(size))
.on_hover_ui_at_pointer(|ui| {
ui.set_max_width(300.0);
ui.add(ui::ProfilePreview::new(
profile.as_ref().unwrap(),
self.img_cache,
));
});
if resp.hovered() || resp.clicked() {
ui::show_pointer(ui);
@@ -238,7 +249,7 @@ impl<'a, 'd> NoteView<'a, 'd> {
ui.put(
rect,
ui::ProfilePic::new(self.note_context.img_cache, ui::ProfilePic::no_pfp_url())
ui::ProfilePic::new(self.img_cache, ui::ProfilePic::no_pfp_url())
.size(pfp_size),
)
.interact(sense)
@@ -251,11 +262,8 @@ impl<'a, 'd> NoteView<'a, 'd> {
NoteResponse::new(self.textmode_ui(ui))
} else {
let txn = self.note.txn().expect("txn");
if let Some(note_to_repost) = get_reposted_note(self.note_context.ndb, txn, self.note) {
let profile = self
.note_context
.ndb
.get_profile_by_pubkey(txn, self.note.pubkey());
if let Some(note_to_repost) = get_reposted_note(self.ndb, txn, self.note) {
let profile = self.ndb.get_profile_by_pubkey(txn, self.note.pubkey());
let style = NotedeckTextStyle::Small;
ui.horizontal(|ui| {
@@ -272,7 +280,7 @@ impl<'a, 'd> NoteView<'a, 'd> {
if let Ok(rec) = &profile {
resp.on_hover_ui_at_pointer(|ui| {
ui.set_max_width(300.0);
ui.add(ui::ProfilePreview::new(rec, self.note_context.img_cache));
ui.add(ui::ProfilePreview::new(rec, self.img_cache));
});
}
let color = ui.style().visuals.noninteractive().fg_stroke.color;
@@ -283,7 +291,14 @@ impl<'a, 'd> NoteView<'a, 'd> {
.text_style(style.text_style()),
);
});
NoteView::new(self.note_context, &note_to_repost).show(ui)
NoteView::new(
self.ndb,
self.note_cache,
self.img_cache,
&note_to_repost,
self.flags,
)
.show(ui)
} else {
self.show_standard(ui)
}
@@ -337,10 +352,7 @@ impl<'a, 'd> NoteView<'a, 'd> {
let mut selected_option: Option<NoteContextSelection> = None;
let hitbox_id = note_hitbox_id(note_key, self.options(), self.parent);
let profile = self
.note_context
.ndb
.get_profile_by_pubkey(txn, self.note.pubkey());
let profile = self.ndb.get_profile_by_pubkey(txn, self.note.pubkey());
let maybe_hitbox = maybe_note_hitbox(ui, hitbox_id);
let container_right = {
let r = ui.available_rect_before_wrap();
@@ -365,7 +377,7 @@ impl<'a, 'd> NoteView<'a, 'd> {
ui.horizontal_centered(|ui| {
selected_option = NoteView::note_header(
ui,
self.note_context.note_cache,
self.note_cache,
self.note,
&profile,
self.options(),
@@ -377,7 +389,6 @@ impl<'a, 'd> NoteView<'a, 'd> {
});
let note_reply = self
.note_context
.note_cache
.cached_note_or_insert_mut(note_key, self.note)
.reply
@@ -386,7 +397,15 @@ impl<'a, 'd> NoteView<'a, 'd> {
if note_reply.reply().is_some() {
let action = ui
.horizontal(|ui| {
reply_desc(ui, txn, &note_reply, self.note_context)
reply_desc(
ui,
txn,
&note_reply,
self.ndb,
self.img_cache,
self.note_cache,
self.flags,
)
})
.inner;
@@ -397,7 +416,14 @@ impl<'a, 'd> NoteView<'a, 'd> {
});
});
let mut contents = NoteContents::new(self.note_context, txn, self.note);
let mut contents = NoteContents::new(
self.ndb,
self.img_cache,
self.note_cache,
txn,
self.note,
self.options(),
);
ui.add(&mut contents);
@@ -425,7 +451,7 @@ impl<'a, 'd> NoteView<'a, 'd> {
ui.with_layout(egui::Layout::top_down(egui::Align::LEFT), |ui| {
selected_option = NoteView::note_header(
ui,
self.note_context.note_cache,
self.note_cache,
self.note,
&profile,
self.options(),
@@ -436,14 +462,21 @@ impl<'a, 'd> NoteView<'a, 'd> {
ui.spacing_mut().item_spacing.x = 2.0;
let note_reply = self
.note_context
.note_cache
.cached_note_or_insert_mut(note_key, self.note)
.reply
.borrow(self.note.tags());
if note_reply.reply().is_some() {
let action = reply_desc(ui, txn, &note_reply, self.note_context);
let action = reply_desc(
ui,
txn,
&note_reply,
self.ndb,
self.img_cache,
self.note_cache,
self.flags,
);
if action.is_some() {
note_action = action;
@@ -451,7 +484,14 @@ impl<'a, 'd> NoteView<'a, 'd> {
}
});
let mut contents = NoteContents::new(self.note_context, txn, self.note);
let mut contents = NoteContents::new(
self.ndb,
self.img_cache,
self.note_cache,
txn,
self.note,
self.options(),
);
ui.add(&mut contents);
if let Some(action) = contents.action() {
@@ -472,8 +512,8 @@ impl<'a, 'd> NoteView<'a, 'd> {
let note_action = if note_hitbox_clicked(ui, hitbox_id, &response.rect, maybe_hitbox) {
if let Ok(selection) = ThreadSelection::from_note_id(
self.note_context.ndb,
self.note_context.note_cache,
self.ndb,
self.note_cache,
self.note.txn().unwrap(),
NoteId::new(*self.note.id()),
) {

71
crates/notedeck_columns/src/ui/note/post.rs
View File

@@ -14,18 +14,21 @@ use egui::{vec2, Frame, Layout, Margin, Pos2, ScrollArea, Sense, TextBuffer};
use enostr::{FilledKeypair, FullKeypair, NoteId, Pubkey, RelayPool};
use nostrdb::{Ndb, Transaction};
use notedeck::supported_mime_hosted_at_url;
use notedeck::{supported_mime_hosted_at_url, Images, NoteCache};
use tracing::error;
use super::contents::{render_note_preview, NoteContext};
use super::contents::render_note_preview;
pub struct PostView<'a, 'd> {
note_context: &'a mut NoteContext<'d>,
pub struct PostView<'a> {
ndb: &'a Ndb,
draft: &'a mut Draft,
post_type: PostType,
img_cache: &'a mut Images,
note_cache: &'a mut NoteCache,
poster: FilledKeypair<'a>,
id_source: Option<egui::Id>,
inner_rect: egui::Rect,
note_options: NoteOptions,
}
#[derive(Clone)]
@@ -80,23 +83,29 @@ pub struct PostResponse {
pub edit_response: egui::Response,
}
impl<'a, 'd> PostView<'a, 'd> {
impl<'a> PostView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
note_context: &'a mut NoteContext<'d>,
ndb: &'a Ndb,
draft: &'a mut Draft,
post_type: PostType,
img_cache: &'a mut Images,
note_cache: &'a mut NoteCache,
poster: FilledKeypair<'a>,
inner_rect: egui::Rect,
note_options: NoteOptions,
) -> Self {
let id_source: Option<egui::Id> = None;
PostView {
note_context,
ndb,
draft,
img_cache,
note_cache,
poster,
id_source,
post_type,
inner_rect,
note_options,
}
}
@@ -112,21 +121,17 @@ impl<'a, 'd> PostView<'a, 'd> {
// TODO: refactor pfp control to do all of this for us
let poster_pfp = self
.note_context
.ndb
.get_profile_by_pubkey(txn, self.poster.pubkey.bytes())
.as_ref()
.ok()
.and_then(|p| {
Some(ui::ProfilePic::from_profile(self.note_context.img_cache, p)?.size(pfp_size))
});
.and_then(|p| Some(ui::ProfilePic::from_profile(self.img_cache, p)?.size(pfp_size)));
if let Some(pfp) = poster_pfp {
ui.add(pfp);
} else {
ui.add(
ui::ProfilePic::new(self.note_context.img_cache, ui::ProfilePic::no_pfp_url())
.size(pfp_size),
ui::ProfilePic::new(self.img_cache, ui::ProfilePic::no_pfp_url()).size(pfp_size),
);
}
@@ -223,15 +228,9 @@ impl<'a, 'd> PostView<'a, 'd> {
hint_rect
};
if let Ok(res) = self.note_context.ndb.search_profile(txn, mention_str, 10)
{
let resp = SearchResultsView::new(
self.note_context.img_cache,
self.note_context.ndb,
txn,
&res,
)
.show_in_rect(hint_rect, ui);
if let Ok(res) = self.ndb.search_profile(txn, mention_str, 10) {
let resp = SearchResultsView::new(self.img_cache, self.ndb, txn, &res)
.show_in_rect(hint_rect, ui);
match resp {
ui::search_results::SearchResultsResponse::SelectResult(
@@ -239,10 +238,7 @@ impl<'a, 'd> PostView<'a, 'd> {
) => {
if let Some(hint_index) = selection {
if let Some(pk) = res.get(hint_index) {
let record = self
.note_context
.ndb
.get_profile_by_pubkey(txn, pk);
let record = self.ndb.get_profile_by_pubkey(txn, pk);
self.draft.buffer.select_mention_and_replace_name(
mention.index,
@@ -322,10 +318,13 @@ impl<'a, 'd> PostView<'a, 'd> {
ui.set_max_width(avail_size.x * 0.8);
render_note_preview(
ui,
self.note_context,
self.ndb,
self.note_cache,
self.img_cache,
txn,
id.bytes(),
nostrdb::NoteKey::new(0),
self.note_options,
);
});
});
@@ -405,11 +404,11 @@ impl<'a, 'd> PostView<'a, 'd> {
};
if let Some(cache_type) =
supported_mime_hosted_at_url(&mut self.note_context.img_cache.urls, &media.url)
supported_mime_hosted_at_url(&mut self.img_cache.urls, &media.url)
{
render_images(
ui,
self.note_context.img_cache,
self.img_cache,
&media.url,
crate::images::ImageType::Content(width, height),
cache_type,
@@ -712,25 +711,21 @@ mod preview {
impl App for PostPreview {
fn update(&mut self, app: &mut AppContext<'_>, ui: &mut egui::Ui) {
let txn = Transaction::new(app.ndb).expect("txn");
let mut note_context = NoteContext {
ndb: app.ndb,
img_cache: app.img_cache,
note_cache: app.note_cache,
options: NoteOptions::default(),
};
PostView::new(
&mut note_context,
app.ndb,
&mut self.draft,
PostType::New,
app.img_cache,
app.note_cache,
self.poster.to_filled(),
ui.available_rect_before_wrap(),
NoteOptions::default(),
)
.ui(&txn, ui);
}
}
impl Preview for PostView<'_, '_> {
impl Preview for PostView<'_> {
type Prev = PostPreview;
fn preview(_cfg: PreviewConfig) -> Self::Prev {

30
crates/notedeck_columns/src/ui/note/quote_repost.rs
View File

@@ -1,38 +1,49 @@
use enostr::{FilledKeypair, NoteId};
use nostrdb::Ndb;
use notedeck::{Images, NoteCache};
use crate::{
draft::Draft,
ui::{self},
ui::{self, note::NoteOptions},
};
use super::{contents::NoteContext, PostResponse, PostType};
use super::{PostResponse, PostType};
pub struct QuoteRepostView<'a, 'd> {
note_context: &'a mut NoteContext<'d>,
pub struct QuoteRepostView<'a> {
ndb: &'a Ndb,
poster: FilledKeypair<'a>,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
draft: &'a mut Draft,
quoting_note: &'a nostrdb::Note<'a>,
id_source: Option<egui::Id>,
inner_rect: egui::Rect,
note_options: NoteOptions,
}
impl<'a, 'd> QuoteRepostView<'a, 'd> {
impl<'a> QuoteRepostView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
note_context: &'a mut NoteContext<'d>,
ndb: &'a Ndb,
poster: FilledKeypair<'a>,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
draft: &'a mut Draft,
quoting_note: &'a nostrdb::Note<'a>,
inner_rect: egui::Rect,
note_options: NoteOptions,
) -> Self {
let id_source: Option<egui::Id> = None;
QuoteRepostView {
note_context,
ndb,
poster,
note_cache,
img_cache,
draft,
quoting_note,
id_source,
inner_rect,
note_options,
}
}
@@ -41,11 +52,14 @@ impl<'a, 'd> QuoteRepostView<'a, 'd> {
let quoting_note_id = self.quoting_note.id();
ui::PostView::new(
self.note_context,
self.ndb,
self.draft,
PostType::Quote(NoteId::new(quoting_note_id.to_owned())),
self.img_cache,
self.note_cache,
self.poster,
self.inner_rect,
self.note_options,
)
.id_source(id)
.ui(self.quoting_note.txn().unwrap(), ui)

45
crates/notedeck_columns/src/ui/note/reply.rs
View File

@@ -1,36 +1,46 @@
use crate::draft::Draft;
use crate::ui;
use crate::ui::note::{PostResponse, PostType};
use crate::ui::note::{NoteOptions, PostResponse, PostType};
use enostr::{FilledKeypair, NoteId};
use nostrdb::Ndb;
use super::contents::NoteContext;
use notedeck::{Images, NoteCache};
pub struct PostReplyView<'a, 'd> {
note_context: &'a mut NoteContext<'d>,
pub struct PostReplyView<'a> {
ndb: &'a Ndb,
poster: FilledKeypair<'a>,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
draft: &'a mut Draft,
note: &'a nostrdb::Note<'a>,
id_source: Option<egui::Id>,
inner_rect: egui::Rect,
note_options: NoteOptions,
}
impl<'a, 'd> PostReplyView<'a, 'd> {
impl<'a> PostReplyView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
note_context: &'a mut NoteContext<'d>,
ndb: &'a Ndb,
poster: FilledKeypair<'a>,
draft: &'a mut Draft,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
note: &'a nostrdb::Note<'a>,
inner_rect: egui::Rect,
note_options: NoteOptions,
) -> Self {
let id_source: Option<egui::Id> = None;
PostReplyView {
note_context,
ndb,
poster,
draft,
note,
note_cache,
img_cache,
id_source,
inner_rect,
note_options,
}
}
@@ -61,11 +71,17 @@ impl<'a, 'd> PostReplyView<'a, 'd> {
egui::Frame::none()
.outer_margin(egui::Margin::same(note_offset))
.show(ui, |ui| {
ui::NoteView::new(self.note_context, self.note)
.actionbar(false)
.medium_pfp(true)
.options_button(true)
.show(ui);
ui::NoteView::new(
self.ndb,
self.note_cache,
self.img_cache,
self.note,
self.note_options,
)
.actionbar(false)
.medium_pfp(true)
.options_button(true)
.show(ui);
});
let id = self.id();
@@ -74,11 +90,14 @@ impl<'a, 'd> PostReplyView<'a, 'd> {
let post_response = {
ui::PostView::new(
self.note_context,
self.ndb,
self.draft,
PostType::Reply(NoteId::new(*replying_to)),
self.img_cache,
self.note_cache,
self.poster,
self.inner_rect,
self.note_options,
)
.id_source(id)
.ui(self.note.txn().unwrap(), ui)

142
crates/notedeck_columns/src/ui/note/reply_description.rs
View File

@@ -1,18 +1,20 @@
use crate::{
actionbar::NoteAction,
ui::{self},
ui::{self, note::NoteOptions},
};
use egui::{Label, RichText, Sense};
use nostrdb::{Note, NoteReply, Transaction};
use super::contents::NoteContext;
use nostrdb::{Ndb, Note, NoteReply, Transaction};
use notedeck::{Images, NoteCache};
#[must_use = "Please handle the resulting note action"]
pub fn reply_desc(
ui: &mut egui::Ui,
txn: &Transaction,
note_reply: &NoteReply,
note_context: &mut NoteContext,
ndb: &Ndb,
img_cache: &mut Images,
note_cache: &mut NoteCache,
note_options: NoteOptions,
) -> Option<NoteAction> {
#[cfg(feature = "profiling")]
puffin::profile_function!();
@@ -25,34 +27,37 @@ pub fn reply_desc(
let link_color = visuals.hyperlink_color;
// note link renderer helper
let note_link =
|ui: &mut egui::Ui, note_context: &mut NoteContext, text: &str, note: &Note<'_>| {
let r = ui.add(
Label::new(RichText::new(text).size(size).color(link_color))
.sense(Sense::click())
.selectable(selectable),
);
let note_link = |ui: &mut egui::Ui,
note_cache: &mut NoteCache,
img_cache: &mut Images,
text: &str,
note: &Note<'_>| {
let r = ui.add(
Label::new(RichText::new(text).size(size).color(link_color))
.sense(Sense::click())
.selectable(selectable),
);
if r.clicked() {
// TODO: jump to note
}
if r.clicked() {
// TODO: jump to note
}
if r.hovered() {
r.on_hover_ui_at_pointer(|ui| {
ui.set_max_width(400.0);
ui::NoteView::new(note_context, note)
.actionbar(false)
.wide(true)
.show(ui);
});
}
};
if r.hovered() {
r.on_hover_ui_at_pointer(|ui| {
ui.set_max_width(400.0);
ui::NoteView::new(ndb, note_cache, img_cache, note, note_options)
.actionbar(false)
.wide(true)
.show(ui);
});
}
};
ui.add(Label::new(RichText::new("replying to").size(size).color(color)).selectable(selectable));
let reply = note_reply.reply()?;
let reply_note = if let Ok(reply_note) = note_context.ndb.get_note_by_id(txn, reply.id) {
let reply_note = if let Ok(reply_note) = ndb.get_note_by_id(txn, reply.id) {
reply_note
} else {
ui.add(Label::new(RichText::new("a note").size(size).color(color)).selectable(selectable));
@@ -61,16 +66,11 @@ pub fn reply_desc(
if note_reply.is_reply_to_root() {
// We're replying to the root, let's show this
let action = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
reply_note.pubkey(),
)
.size(size)
.selectable(selectable)
.show(ui)
.inner;
let action = ui::Mention::new(ndb, img_cache, txn, reply_note.pubkey())
.size(size)
.selectable(selectable)
.show(ui)
.inner;
if action.is_some() {
note_action = action;
@@ -78,23 +78,18 @@ pub fn reply_desc(
ui.add(Label::new(RichText::new("'s").size(size).color(color)).selectable(selectable));
note_link(ui, note_context, "thread", &reply_note);
note_link(ui, note_cache, img_cache, "thread", &reply_note);
} else if let Some(root) = note_reply.root() {
// replying to another post in a thread, not the root
if let Ok(root_note) = note_context.ndb.get_note_by_id(txn, root.id) {
if let Ok(root_note) = ndb.get_note_by_id(txn, root.id) {
if root_note.pubkey() == reply_note.pubkey() {
// simply "replying to bob's note" when replying to bob in his thread
let action = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
reply_note.pubkey(),
)
.size(size)
.selectable(selectable)
.show(ui)
.inner;
let action = ui::Mention::new(ndb, img_cache, txn, reply_note.pubkey())
.size(size)
.selectable(selectable)
.show(ui)
.inner;
if action.is_some() {
note_action = action;
@@ -104,20 +99,15 @@ pub fn reply_desc(
Label::new(RichText::new("'s").size(size).color(color)).selectable(selectable),
);
note_link(ui, note_context, "note", &reply_note);
note_link(ui, note_cache, img_cache, "note", &reply_note);
} else {
// replying to bob in alice's thread
let action = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
reply_note.pubkey(),
)
.size(size)
.selectable(selectable)
.show(ui)
.inner;
let action = ui::Mention::new(ndb, img_cache, txn, reply_note.pubkey())
.size(size)
.selectable(selectable)
.show(ui)
.inner;
if action.is_some() {
note_action = action;
@@ -127,22 +117,17 @@ pub fn reply_desc(
Label::new(RichText::new("'s").size(size).color(color)).selectable(selectable),
);
note_link(ui, note_context, "note", &reply_note);
note_link(ui, note_cache, img_cache, "note", &reply_note);
ui.add(
Label::new(RichText::new("in").size(size).color(color)).selectable(selectable),
);
let action = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
root_note.pubkey(),
)
.size(size)
.selectable(selectable)
.show(ui)
.inner;
let action = ui::Mention::new(ndb, img_cache, txn, root_note.pubkey())
.size(size)
.selectable(selectable)
.show(ui)
.inner;
if action.is_some() {
note_action = action;
@@ -152,19 +137,14 @@ pub fn reply_desc(
Label::new(RichText::new("'s").size(size).color(color)).selectable(selectable),
);
note_link(ui, note_context, "thread", &root_note);
note_link(ui, note_cache, img_cache, "thread", &root_note);
}
} else {
let action = ui::Mention::new(
note_context.ndb,
note_context.img_cache,
txn,
reply_note.pubkey(),
)
.size(size)
.selectable(selectable)
.show(ui)
.inner;
let action = ui::Mention::new(ndb, img_cache, txn, reply_note.pubkey())
.size(size)
.selectable(selectable)
.show(ui)
.inner;
if action.is_some() {
note_action = action;