notedeck

post.rs (5607B)

---

 use crate::app::Damus;
 use crate::draft::{Draft, DraftSource};
 use crate::post::NewPost;
 use crate::ui;
 use crate::ui::{Preview, PreviewConfig, View};
 use egui::widgets::text_edit::TextEdit;
 use nostrdb::Transaction;
 
 pub struct PostView<'app, 'd> {
     app: &'app mut Damus,
     /// account index
     poster: usize,
     draft_source: DraftSource<'d>,
     id_source: Option<egui::Id>,
 }
 
 pub enum PostAction {
     Post(NewPost),
 }
 
 pub struct PostResponse {
     pub action: Option<PostAction>,
     pub edit_response: egui::Response,
 }
 
 impl<'app, 'd> PostView<'app, 'd> {
     pub fn new(app: &'app mut Damus, draft_source: DraftSource<'d>, poster: usize) -> Self {
         let id_source: Option<egui::Id> = None;
         PostView {
             id_source,
             app,
             poster,
             draft_source,
         }
     }
 
     pub fn id_source(mut self, id_source: impl std::hash::Hash) -> Self {
         self.id_source = Some(egui::Id::new(id_source));
         self
     }
 
     fn draft(&mut self) -> &mut Draft {
         self.draft_source.draft(&mut self.app.drafts)
     }
 
     fn editbox(&mut self, txn: &nostrdb::Transaction, ui: &mut egui::Ui) -> egui::Response {
         ui.spacing_mut().item_spacing.x = 12.0;
 
         let pfp_size = 24.0;
 
         let poster_pubkey = self
             .app
             .account_manager
             .get_account(self.poster)
             .map(|acc| acc.pubkey.bytes())
             .unwrap_or(crate::test_data::test_pubkey());
 
         // TODO: refactor pfp control to do all of this for us
         let poster_pfp = self
             .app
             .ndb
             .get_profile_by_pubkey(txn, poster_pubkey)
             .as_ref()
             .ok()
             .and_then(|p| {
                 Some(ui::ProfilePic::from_profile(&mut self.app.img_cache, p)?.size(pfp_size))
             });
 
         if let Some(pfp) = poster_pfp {
             ui.add(pfp);
         } else {
             ui.add(
                 ui::ProfilePic::new(&mut self.app.img_cache, ui::ProfilePic::no_pfp_url())
                     .size(pfp_size),
             );
         }
 
         let buffer = &mut self.draft_source.draft(&mut self.app.drafts).buffer;
 
         let response = ui.add_sized(
             ui.available_size(),
             TextEdit::multiline(buffer)
                 .hint_text(egui::RichText::new("Write a banger note here...").weak())
                 .frame(false),
         );
 
         let focused = response.has_focus();
 
         ui.ctx().data_mut(|d| d.insert_temp(self.id(), focused));
 
         response
     }
 
     fn focused(&self, ui: &egui::Ui) -> bool {
         ui.ctx()
             .data(|d| d.get_temp::<bool>(self.id()).unwrap_or(false))
     }
 
     fn id(&self) -> egui::Id {
         self.id_source.unwrap_or_else(|| egui::Id::new("post"))
     }
 
     pub fn outer_margin() -> f32 {
         16.0
     }
 
     pub fn inner_margin() -> f32 {
         12.0
     }
 
     pub fn ui(&mut self, txn: &nostrdb::Transaction, ui: &mut egui::Ui) -> PostResponse {
         let focused = self.focused(ui);
         let stroke = if focused {
             ui.visuals().selection.stroke
         } else {
             //ui.visuals().selection.stroke
             ui.visuals().noninteractive().bg_stroke
         };
 
         let mut frame = egui::Frame::default()
             .inner_margin(egui::Margin::same(PostView::inner_margin()))
             .outer_margin(egui::Margin::same(PostView::outer_margin()))
             .fill(ui.visuals().extreme_bg_color)
             .stroke(stroke)
             .rounding(12.0);
 
         if focused {
             frame = frame.shadow(egui::epaint::Shadow {
                 offset: egui::vec2(0.0, 0.0),
                 blur: 8.0,
                 spread: 0.0,
                 color: stroke.color,
             });
         }
 
         frame
             .show(ui, |ui| {
                 ui.vertical(|ui| {
                     let edit_response = ui.horizontal(|ui| self.editbox(txn, ui)).inner;
 
                     let action = ui
                         .with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
                             if ui
                                 .add_sized([91.0, 32.0], egui::Button::new("Post now"))
                                 .clicked()
                             {
                                 Some(PostAction::Post(NewPost {
                                     content: self.draft().buffer.clone(),
                                     account: self.poster,
                                 }))
                             } else {
                                 None
                             }
                         })
                         .inner;
 
                     PostResponse {
                         action,
                         edit_response,
                     }
                 })
                 .inner
             })
             .inner
     }
 }
 
 mod preview {
     use super::*;
     use crate::test_data;
 
     pub struct PostPreview {
         app: Damus,
     }
 
     impl PostPreview {
         fn new(is_mobile: bool) -> Self {
             PostPreview {
                 app: test_data::test_app(is_mobile),
             }
         }
     }
 
     impl View for PostPreview {
         fn ui(&mut self, ui: &mut egui::Ui) {
             let txn = Transaction::new(&self.app.ndb).unwrap();
             PostView::new(&mut self.app, DraftSource::Compose, 0).ui(&txn, ui);
         }
     }
 
     impl<'app, 'p> Preview for PostView<'app, 'p> {
         type Prev = PostPreview;
 
         fn preview(cfg: PreviewConfig) -> Self::Prev {
             PostPreview::new(cfg.is_mobile)
         }
     }
 }