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

47
crates/notedeck_columns/src/nav.rs
View File

@@ -16,7 +16,7 @@ use crate::{
column::NavTitle,
configure_deck::ConfigureDeckView,
edit_deck::{EditDeckResponse, EditDeckView},
note::{contents::NoteContext, PostAction, PostType},
note::{PostAction, PostType},
profile::EditProfileView,
support::SupportView,
RelayView, View,
@@ -243,22 +243,19 @@ fn render_nav_body(
col: usize,
inner_rect: egui::Rect,
) -> Option<RenderNavAction> {
let mut note_context = NoteContext {
ndb: ctx.ndb,
img_cache: ctx.img_cache,
note_cache: ctx.note_cache,
options: app.note_options,
};
match top {
Route::Timeline(kind) => render_timeline_route(
ctx.ndb,
ctx.img_cache,
ctx.unknown_ids,
ctx.note_cache,
&mut app.timeline_cache,
ctx.accounts,
kind,
col,
app.note_options,
depth,
ui,
&mut note_context,
),
Route::Accounts(amr) => {
let mut action = render_accounts_route(
@@ -305,9 +302,18 @@ fn render_nav_body(
let draft = app.drafts.reply_mut(note.id());
let response = egui::ScrollArea::vertical().show(ui, |ui| {
ui::PostReplyView::new(&mut note_context, poster, draft, &note, inner_rect)
.id_source(id)
.show(ui)
ui::PostReplyView::new(
ctx.ndb,
poster,
draft,
ctx.note_cache,
ctx.img_cache,
&note,
inner_rect,
app.note_options,
)
.id_source(id)
.show(ui)
});
response.inner.action
@@ -333,11 +339,14 @@ fn render_nav_body(
let response = egui::ScrollArea::vertical().show(ui, |ui| {
crate::ui::note::QuoteRepostView::new(
&mut note_context,
ctx.ndb,
poster,
ctx.note_cache,
ctx.img_cache,
draft,
&note,
inner_rect,
app.note_options,
)
.id_source(id)
.show(ui)
@@ -351,9 +360,17 @@ fn render_nav_body(
let draft = app.drafts.compose_mut();
let txn = Transaction::new(ctx.ndb).expect("txn");
let post_response =
ui::PostView::new(&mut note_context, draft, PostType::New, kp, inner_rect)
.ui(&txn, ui);
let post_response = ui::PostView::new(
ctx.ndb,
draft,
PostType::New,
ctx.img_cache,
ctx.note_cache,
kp,
inner_rect,
app.note_options,
)
.ui(&txn, ui);
post_response.action.map(Into::into)
}

58
crates/notedeck_columns/src/timeline/route.rs
View File

@@ -2,25 +2,29 @@ use crate::{
nav::RenderNavAction,
profile::ProfileAction,
timeline::{TimelineCache, TimelineKind},
ui::{self, note::contents::NoteContext, profile::ProfileView},
ui::{self, note::NoteOptions, profile::ProfileView},
};
use enostr::Pubkey;
use notedeck::{Accounts, MuteFun, UnknownIds};
use nostrdb::Ndb;
use notedeck::{Accounts, Images, MuteFun, NoteCache, UnknownIds};
#[allow(clippy::too_many_arguments)]
pub fn render_timeline_route(
ndb: &Ndb,
img_cache: &mut Images,
unknown_ids: &mut UnknownIds,
note_cache: &mut NoteCache,
timeline_cache: &mut TimelineCache,
accounts: &mut Accounts,
kind: &TimelineKind,
col: usize,
mut note_options: NoteOptions,
depth: usize,
ui: &mut egui::Ui,
note_context: &mut NoteContext,
) -> Option<RenderNavAction> {
if kind == &TimelineKind::Universe {
note_context.options.set_hide_media(true);
note_options.set_hide_media(true);
}
match kind {
@@ -30,9 +34,16 @@ pub fn render_timeline_route(
| TimelineKind::Universe
| TimelineKind::Hashtag(_)
| TimelineKind::Generic(_) => {
let note_action =
ui::TimelineView::new(kind, timeline_cache, &accounts.mutefun(), note_context)
.ui(ui);
let note_action = ui::TimelineView::new(
kind,
timeline_cache,
ndb,
note_cache,
img_cache,
note_options,
&accounts.mutefun(),
)
.ui(ui);
note_action.map(RenderNavAction::NoteAction)
}
@@ -42,18 +53,28 @@ pub fn render_timeline_route(
render_profile_route(
pubkey,
accounts,
ndb,
timeline_cache,
img_cache,
note_cache,
unknown_ids,
col,
ui,
&accounts.mutefun(),
note_context,
note_options,
)
} else {
// we render profiles like timelines if they are at the root
let note_action =
ui::TimelineView::new(kind, timeline_cache, &accounts.mutefun(), note_context)
.ui(ui);
let note_action = ui::TimelineView::new(
kind,
timeline_cache,
ndb,
note_cache,
img_cache,
note_options,
&accounts.mutefun(),
)
.ui(ui);
note_action.map(RenderNavAction::NoteAction)
}
@@ -61,10 +82,13 @@ pub fn render_timeline_route(
TimelineKind::Thread(id) => ui::ThreadView::new(
timeline_cache,
ndb,
note_cache,
unknown_ids,
img_cache,
id.selected_or_root(),
note_options,
&accounts.mutefun(),
note_context,
)
.id_source(egui::Id::new(("threadscroll", col)))
.ui(ui)
@@ -76,21 +100,27 @@ pub fn render_timeline_route(
pub fn render_profile_route(
pubkey: &Pubkey,
accounts: &Accounts,
ndb: &Ndb,
timeline_cache: &mut TimelineCache,
img_cache: &mut Images,
note_cache: &mut NoteCache,
unknown_ids: &mut UnknownIds,
col: usize,
ui: &mut egui::Ui,
is_muted: &MuteFun,
note_context: &mut NoteContext,
note_options: NoteOptions,
) -> Option<RenderNavAction> {
let action = ProfileView::new(
pubkey,
accounts,
col,
timeline_cache,
ndb,
note_cache,
img_cache,
unknown_ids,
is_muted,
note_context,
note_options,
)
.ui(ui);

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;

60
crates/notedeck_columns/src/ui/profile/mod.rs
View File

@@ -6,7 +6,7 @@ pub use edit::EditProfileView;
use egui::load::TexturePoll;
use egui::{vec2, Color32, Label, Layout, Rect, RichText, Rounding, ScrollArea, Sense, Stroke};
use enostr::Pubkey;
use nostrdb::{ProfileRecord, Transaction};
use nostrdb::{Ndb, ProfileRecord, Transaction};
pub use picture::ProfilePic;
pub use preview::ProfilePreview;
use tracing::error;
@@ -16,22 +16,26 @@ use crate::{
colors, images,
profile::get_display_name,
timeline::{TimelineCache, TimelineKind},
ui::timeline::{tabs_ui, TimelineTabView},
ui::{
note::NoteOptions,
timeline::{tabs_ui, TimelineTabView},
},
NostrName,
};
use notedeck::{Accounts, MuteFun, NotedeckTextStyle, UnknownIds};
use notedeck::{Accounts, Images, MuteFun, NoteCache, NotedeckTextStyle, UnknownIds};
use super::note::contents::NoteContext;
pub struct ProfileView<'a, 'd> {
pub struct ProfileView<'a> {
pubkey: &'a Pubkey,
accounts: &'a Accounts,
col_id: usize,
timeline_cache: &'a mut TimelineCache,
note_options: NoteOptions,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
unknown_ids: &'a mut UnknownIds,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
}
pub enum ProfileViewAction {
@@ -39,25 +43,31 @@ pub enum ProfileViewAction {
Note(NoteAction),
}
impl<'a, 'd> ProfileView<'a, 'd> {
impl<'a> ProfileView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
pubkey: &'a Pubkey,
accounts: &'a Accounts,
col_id: usize,
timeline_cache: &'a mut TimelineCache,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
unknown_ids: &'a mut UnknownIds,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
note_options: NoteOptions,
) -> Self {
ProfileView {
pubkey,
accounts,
col_id,
timeline_cache,
ndb,
note_cache,
img_cache,
unknown_ids,
note_options,
is_muted,
note_context,
}
}
@@ -68,12 +78,8 @@ impl<'a, 'd> ProfileView<'a, 'd> {
.id_salt(scroll_id)
.show(ui, |ui| {
let mut action = None;
let txn = Transaction::new(self.note_context.ndb).expect("txn");
if let Ok(profile) = self
.note_context
.ndb
.get_profile_by_pubkey(&txn, self.pubkey.bytes())
{
let txn = Transaction::new(self.ndb).expect("txn");
if let Ok(profile) = self.ndb.get_profile_by_pubkey(&txn, self.pubkey.bytes()) {
if self.profile_body(ui, profile) {
action = Some(ProfileViewAction::EditProfile);
}
@@ -81,8 +87,8 @@ impl<'a, 'd> ProfileView<'a, 'd> {
let profile_timeline = self
.timeline_cache
.notes(
self.note_context.ndb,
self.note_context.note_cache,
self.ndb,
self.note_cache,
&txn,
&TimelineKind::Profile(*self.pubkey),
)
@@ -94,10 +100,10 @@ impl<'a, 'd> ProfileView<'a, 'd> {
let reversed = false;
// poll for new notes and insert them into our existing notes
if let Err(e) = profile_timeline.poll_notes_into_view(
self.note_context.ndb,
self.ndb,
&txn,
self.unknown_ids,
self.note_context.note_cache,
self.note_cache,
reversed,
) {
error!("Profile::poll_notes_into_view: {e}");
@@ -106,9 +112,12 @@ impl<'a, 'd> ProfileView<'a, 'd> {
if let Some(note_action) = TimelineTabView::new(
profile_timeline.current_view(),
reversed,
self.note_options,
&txn,
self.ndb,
self.note_cache,
self.img_cache,
self.is_muted,
self.note_context,
)
.show(ui)
{
@@ -140,12 +149,9 @@ impl<'a, 'd> ProfileView<'a, 'd> {
ui.horizontal(|ui| {
ui.put(
pfp_rect,
ProfilePic::new(
self.note_context.img_cache,
get_profile_url(Some(&profile)),
)
.size(size)
.border(ProfilePic::border_stroke(ui)),
ProfilePic::new(self.img_cache, get_profile_url(Some(&profile)))
.size(size)
.border(ProfilePic::border_stroke(ui)),
);
if ui.add(copy_key_widget(&pfp_rect)).clicked() {

61
crates/notedeck_columns/src/ui/thread.rs
View File

@@ -1,40 +1,50 @@
use crate::{
actionbar::NoteAction,
timeline::{ThreadSelection, TimelineCache, TimelineKind},
ui::note::NoteOptions,
};
use nostrdb::Transaction;
use notedeck::{MuteFun, RootNoteId, UnknownIds};
use nostrdb::{Ndb, Transaction};
use notedeck::{Images, MuteFun, NoteCache, RootNoteId, UnknownIds};
use tracing::error;
use super::{note::contents::NoteContext, timeline::TimelineTabView};
use super::timeline::TimelineTabView;
pub struct ThreadView<'a, 'd> {
pub struct ThreadView<'a> {
timeline_cache: &'a mut TimelineCache,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
unknown_ids: &'a mut UnknownIds,
img_cache: &'a mut Images,
selected_note_id: &'a [u8; 32],
note_options: NoteOptions,
id_source: egui::Id,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
}
impl<'a, 'd> ThreadView<'a, 'd> {
impl<'a> ThreadView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
timeline_cache: &'a mut TimelineCache,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
unknown_ids: &'a mut UnknownIds,
img_cache: &'a mut Images,
selected_note_id: &'a [u8; 32],
note_options: NoteOptions,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
) -> Self {
let id_source = egui::Id::new("threadscroll_threadview");
ThreadView {
timeline_cache,
ndb,
note_cache,
unknown_ids,
img_cache,
selected_note_id,
note_options,
id_source,
is_muted,
note_context,
}
}
@@ -44,7 +54,7 @@ impl<'a, 'd> ThreadView<'a, 'd> {
}
pub fn ui(&mut self, ui: &mut egui::Ui) -> Option<NoteAction> {
let txn = Transaction::new(self.note_context.ndb).expect("txn");
let txn = Transaction::new(self.ndb).expect("txn");
ui.label(
egui::RichText::new("Threads ALPHA! It's not done. Things will be broken.")
@@ -57,25 +67,21 @@ impl<'a, 'd> ThreadView<'a, 'd> {
.auto_shrink([false, false])
.scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysVisible)
.show(ui, |ui| {
let root_id = match RootNoteId::new(
self.note_context.ndb,
self.note_context.note_cache,
&txn,
self.selected_note_id,
) {
Ok(root_id) => root_id,
let root_id =
match RootNoteId::new(self.ndb, self.note_cache, &txn, self.selected_note_id) {
Ok(root_id) => root_id,
Err(err) => {
ui.label(format!("Error loading thread: {:?}", err));
return None;
}
};
Err(err) => {
ui.label(format!("Error loading thread: {:?}", err));
return None;
}
};
let thread_timeline = self
.timeline_cache
.notes(
self.note_context.ndb,
self.note_context.note_cache,
self.ndb,
self.note_cache,
&txn,
&TimelineKind::Thread(ThreadSelection::from_root_id(root_id.to_owned())),
)
@@ -86,10 +92,10 @@ impl<'a, 'd> ThreadView<'a, 'd> {
let reversed = true;
// poll for new notes and insert them into our existing notes
if let Err(err) = thread_timeline.poll_notes_into_view(
self.note_context.ndb,
self.ndb,
&txn,
self.unknown_ids,
self.note_context.note_cache,
self.note_cache,
reversed,
) {
error!("error polling notes into thread timeline: {err}");
@@ -98,9 +104,12 @@ impl<'a, 'd> ThreadView<'a, 'd> {
TimelineTabView::new(
thread_timeline.current_view(),
true,
self.note_options,
&txn,
self.ndb,
self.note_cache,
self.img_cache,
self.is_muted,
self.note_context,
)
.show(ui)
})

95
crates/notedeck_columns/src/ui/timeline.rs
View File

@@ -5,52 +5,64 @@ use crate::timeline::TimelineTab;
use crate::{
timeline::{TimelineCache, TimelineKind, ViewFilter},
ui,
ui::note::NoteOptions,
};
use egui::containers::scroll_area::ScrollBarVisibility;
use egui::{vec2, Direction, Layout, Pos2, Stroke};
use egui_tabs::TabColor;
use nostrdb::Transaction;
use nostrdb::{Ndb, Transaction};
use notedeck::note::root_note_id_from_selected_id;
use notedeck::MuteFun;
use notedeck::{Images, MuteFun, NoteCache};
use tracing::{error, warn};
use super::anim::{AnimationHelper, ICON_EXPANSION_MULTIPLE};
use super::note::contents::NoteContext;
pub struct TimelineView<'a, 'd> {
pub struct TimelineView<'a> {
timeline_id: &'a TimelineKind,
timeline_cache: &'a mut TimelineCache,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
note_options: NoteOptions,
reverse: bool,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
}
impl<'a, 'd> TimelineView<'a, 'd> {
impl<'a> TimelineView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
timeline_id: &'a TimelineKind,
timeline_cache: &'a mut TimelineCache,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
note_options: NoteOptions,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
) -> Self {
) -> TimelineView<'a> {
let reverse = false;
TimelineView {
ndb,
timeline_id,
timeline_cache,
note_cache,
img_cache,
reverse,
note_options,
is_muted,
note_context,
}
}
pub fn ui(&mut self, ui: &mut egui::Ui) -> Option<NoteAction> {
timeline_ui(
ui,
self.ndb,
self.timeline_id,
self.timeline_cache,
self.note_cache,
self.img_cache,
self.reverse,
self.note_options,
self.is_muted,
self.note_context,
)
}
@@ -63,11 +75,14 @@ impl<'a, 'd> TimelineView<'a, 'd> {
#[allow(clippy::too_many_arguments)]
fn timeline_ui(
ui: &mut egui::Ui,
ndb: &Ndb,
timeline_id: &TimelineKind,
timeline_cache: &mut TimelineCache,
note_cache: &mut NoteCache,
img_cache: &mut Images,
reversed: bool,
note_options: NoteOptions,
is_muted: &MuteFun,
note_context: &mut NoteContext,
) -> Option<NoteAction> {
//padding(4.0, ui, |ui| ui.heading("Notifications"));
/*
@@ -136,14 +151,16 @@ fn timeline_ui(
return None;
};
let txn = Transaction::new(note_context.ndb).expect("failed to create txn");
let txn = Transaction::new(ndb).expect("failed to create txn");
TimelineTabView::new(
timeline.current_view(),
reversed,
note_options,
&txn,
ndb,
note_cache,
img_cache,
is_muted,
note_context,
)
.show(ui)
});
@@ -298,29 +315,38 @@ fn shrink_range_to_width(range: egui::Rangef, width: f32) -> egui::Rangef {
egui::Rangef::new(min, max)
}
pub struct TimelineTabView<'a, 'd> {
pub struct TimelineTabView<'a> {
tab: &'a TimelineTab,
reversed: bool,
note_options: NoteOptions,
txn: &'a Transaction,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
}
impl<'a, 'd> TimelineTabView<'a, 'd> {
impl<'a> TimelineTabView<'a> {
#[allow(clippy::too_many_arguments)]
pub fn new(
tab: &'a TimelineTab,
reversed: bool,
note_options: NoteOptions,
txn: &'a Transaction,
ndb: &'a Ndb,
note_cache: &'a mut NoteCache,
img_cache: &'a mut Images,
is_muted: &'a MuteFun,
note_context: &'a mut NoteContext<'d>,
) -> Self {
Self {
tab,
reversed,
txn,
note_options,
ndb,
note_cache,
img_cache,
is_muted,
note_context,
}
}
@@ -345,21 +371,17 @@ impl<'a, 'd> TimelineTabView<'a, 'd> {
let note_key = self.tab.notes[ind].key;
let note =
if let Ok(note) = self.note_context.ndb.get_note_by_key(self.txn, note_key) {
note
} else {
warn!("failed to query note {:?}", note_key);
return 0;
};
let note = if let Ok(note) = self.ndb.get_note_by_key(self.txn, note_key) {
note
} else {
warn!("failed to query note {:?}", note_key);
return 0;
};
// should we mute the thread? we might not have it!
let muted = if let Ok(root_id) = root_note_id_from_selected_id(
self.note_context.ndb,
self.note_context.note_cache,
self.txn,
note.id(),
) {
let muted = if let Ok(root_id) =
root_note_id_from_selected_id(self.ndb, self.note_cache, self.txn, note.id())
{
is_muted(&note, root_id.bytes())
} else {
false
@@ -367,7 +389,14 @@ impl<'a, 'd> TimelineTabView<'a, 'd> {
if !muted {
ui::padding(8.0, ui, |ui| {
let resp = ui::NoteView::new(self.note_context, &note).show(ui);
let resp = ui::NoteView::new(
self.ndb,
self.note_cache,
self.img_cache,
&note,
self.note_options,
)
.show(ui);
if let Some(note_action) = resp.action {
action = Some(note_action)