Add optional frame around repost. Also comment mentions now have reversed avatar size and show of interaction buttons.

src/ui/feed/note/mod.rs

@@ -254,7 +254,7 @@ pub(super) fn render_note(
                     if note_data.author.muted > 0 {
                         ui.label(RichText::new("MUTED POST").monospace().italics());
                     } else {
-                        render_note_inner(app, ctx, ui, note_data, &render_data, hide_footer);
+                        render_note_inner(app, ctx, ui, note_data, &render_data, hide_footer, &None);
                     }
                 });
             });
@@ -307,6 +307,7 @@ fn render_note_inner(
     note_data: NoteData,
     render_data: &NoteRenderData,
     hide_footer: bool,
+    parent_repost: &Option<RepostType>,
 ) {
     let NoteData {
         event,
@@ -330,16 +331,44 @@ fn render_note_inner(
     };
 
     // Determine avatar size
-    let avatar_size = match repost {
-        None => AVATAR_SIZE_F32,
-        Some(_) => AVATAR_SIZE_REPOST_F32,
+    let avatar_size = if parent_repost.is_none() {
+        match repost {
+            None | Some(RepostType::CommentMention) => AVATAR_SIZE_F32,
+            Some(_) => AVATAR_SIZE_REPOST_F32,
+        }
+    } else {
+        match parent_repost {
+            None | Some(RepostType::CommentMention) => AVATAR_SIZE_REPOST_F32,
+            Some(_) => AVATAR_SIZE_F32,
+        }
     };
 
     let inner_margin = app.settings.theme.feed_frame_inner_margin(render_data);
 
-    let avatar_margin_left = match repost {
-        None => 0.0,
-        Some(_) => (AVATAR_SIZE_F32 - AVATAR_SIZE_REPOST_F32) / 2.0,
+    let avatar_margin_left = if parent_repost.is_none() {
+        match repost {
+            None | Some(RepostType::CommentMention) => 0.0,
+            Some(_) => (AVATAR_SIZE_F32 - AVATAR_SIZE_REPOST_F32) / 2.0,
+        }
+    } else {
+        match parent_repost {
+            None | Some(RepostType::CommentMention) => (AVATAR_SIZE_F32 - AVATAR_SIZE_REPOST_F32) / 2.0,
+            Some(_) => 0.0,
+        }
+    };
+
+    let hide_footer = if hide_footer {
+        true
+    } else if parent_repost.is_none() {
+        match repost {
+            None | Some(RepostType::CommentMention) => false,
+            Some(_) => true,
+        }
+    } else {
+        match parent_repost {
+            None | Some(RepostType::CommentMention) => true,
+            Some(_) => false,
+        }
     };
 
     let content_pull_top = inner_margin.top + ui.style().spacing.item_spacing.y * 4.0 - avatar_size;
@@ -580,7 +609,7 @@ fn render_note_inner(
 
             // render any repost without frame or indent
             if let Some(repost) = append_repost {
-                render_repost(app, ui, ctx, repost)
+                render_repost(app, ui, ctx, &note_data, repost)
             }
 
             // deleted?
@@ -595,7 +624,7 @@ fn render_note_inner(
             }
 
             // Footer
-            if !hide_footer && note_data.repost.is_none() {
+            if !hide_footer {
             Frame::none()
                 .inner_margin(Margin {
                     left: footer_margin_left,
@@ -742,7 +771,7 @@ fn thin_separator(ui: &mut Ui, stroke: Stroke) {
     ui.reset_style();
 }
 
-pub(super) fn render_repost(app: &mut GossipUi, ui: &mut Ui, ctx: &Context, repost_data: NoteData) {
+pub(super) fn render_repost(app: &mut GossipUi, ui: &mut Ui, ctx: &Context, parent_data: &NoteData, repost_data: NoteData) {
     let render_data = NoteRenderData {
         height: 0.0,
         has_repost: repost_data.repost.is_some(),
@@ -755,12 +784,24 @@ pub(super) fn render_repost(app: &mut GossipUi, ui: &mut Ui, ctx: &Context, repo
     };
 
     ui.vertical(|ui| {
-        ui.add_space(app.settings.theme.repost_space_above_separator(&render_data));
-        thin_separator(ui, app.settings.theme.repost_separator_stroke(&render_data));
-        ui.add_space(app.settings.theme.repost_space_below_separator(&render_data));
-        ui.horizontal_wrapped(|ui| {
-            // FIXME: don't do this recursively
-            render_note_inner(app, ctx, ui, repost_data, &render_data, false);
-        });
+        ui.add_space(app.settings.theme.repost_space_above_separator_before(&render_data));
+        thin_separator(ui, app.settings.theme.repost_separator_before_stroke(&render_data));
+        ui.add_space(app.settings.theme.repost_space_below_separator_before(&render_data));
+        Frame::none()
+            .inner_margin(app.settings.theme.repost_inner_margin(&render_data))
+            .outer_margin(app.settings.theme.repost_outer_margin(&render_data))
+            .rounding(app.settings.theme.repost_rounding(&render_data))
+            .shadow(app.settings.theme.repost_shadow(&render_data))
+            .fill(app.settings.theme.repost_fill(&render_data))
+            .stroke(app.settings.theme.repost_stroke(&render_data))
+            .show(ui, |ui|{
+                ui.horizontal_wrapped(|ui| {
+                    // FIXME: don't do this recursively
+                    render_note_inner(app, ctx, ui, repost_data, &render_data, false,&parent_data.repost);
+                });
+            });
+        ui.add_space(app.settings.theme.repost_space_above_separator_after(&render_data));
+        thin_separator(ui, app.settings.theme.repost_separator_after_stroke(&render_data));
+        ui.add_space(app.settings.theme.repost_space_below_separator_after(&render_data));
     });
 }

src/ui/theme/classic.rs

@@ -435,7 +435,7 @@ impl ThemeDef for ClassicTheme {
         Stroke::NONE
     }
 
-    fn repost_separator_stroke(dark_mode: bool, _post: &NoteRenderData) -> Stroke {
+    fn repost_separator_before_stroke(dark_mode: bool, _post: &NoteRenderData) -> Stroke {
         if dark_mode {
             Stroke::new(1.0, Color32::from_gray(72))
         } else {
@@ -443,13 +443,54 @@ impl ThemeDef for ClassicTheme {
         }
     }
 
-    fn repost_space_above_separator(_post: &NoteRenderData) -> f32 {
+    fn repost_space_above_separator_before(_post: &NoteRenderData) -> f32 {
         4.0
     }
-    fn repost_space_below_separator(_post: &NoteRenderData) -> f32 {
+    fn repost_space_below_separator_before(_post: &NoteRenderData) -> f32 {
         8.0
     }
 
+    fn repost_separator_after_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke {
+        Self::repost_separator_before_stroke(dark_mode, post)
+    }
+    fn repost_space_above_separator_after(_post: &NoteRenderData) -> f32 {
+        4.0
+    }
+    fn repost_space_below_separator_after(_post: &NoteRenderData) -> f32 {
+        0.0
+    }
+
+    fn repost_inner_margin(_post: &NoteRenderData) -> Margin {
+        // Margin {
+        //     left: 10.0,
+        //     top: 4.0,
+        //     right: 10.0,
+        //     bottom: 4.0,
+        // }
+        Margin::same(0.0)
+    }
+    fn repost_outer_margin(_post: &NoteRenderData) -> Margin {
+        // Margin {
+        //     left: -10.0,
+        //     top: -4.0,
+        //     right: -10.0,
+        //     bottom: -4.0,
+        // }
+        Margin::same(0.0)
+    }
+    fn repost_rounding(post: &NoteRenderData) -> Rounding {
+        Self::feed_frame_rounding(post)
+    }
+    fn repost_shadow(_dark_mode: bool, _post: &NoteRenderData) -> Shadow {
+        Shadow::NONE
+    }
+    fn repost_fill(_dark_mode: bool, _post: &NoteRenderData) -> Color32 {
+        Color32::TRANSPARENT
+    }
+    fn repost_stroke(_dark_mode: bool, _post: &NoteRenderData) -> Stroke {
+        Stroke::NONE
+    }
+
     fn round_image() -> bool {
         false
     }

src/ui/theme/default.rs

@@ -463,21 +463,66 @@ impl ThemeDef for DefaultTheme {
         Stroke::NONE
     }
 
-    fn repost_separator_stroke(dark_mode: bool, _post: &NoteRenderData) -> Stroke {
+    fn repost_separator_before_stroke(dark_mode: bool, _post: &NoteRenderData) -> Stroke {
         if dark_mode {
             Stroke::new(1.0, Color32::from_gray(60))
         } else {
             Stroke::new(1.0, Color32::from_gray(230))
         }
     }
-
-    fn repost_space_above_separator(_post: &NoteRenderData) -> f32 {
+    fn repost_space_above_separator_before(_post: &NoteRenderData) -> f32 {
         0.0
     }
-    fn repost_space_below_separator(_post: &NoteRenderData) -> f32 {
+    fn repost_space_below_separator_before(_post: &NoteRenderData) -> f32 {
         10.0
     }
 
+    fn repost_separator_after_stroke(_dark_mode: bool, _post: &NoteRenderData) -> Stroke {
+        Stroke::NONE
+    }
+    fn repost_space_above_separator_after(_post: &NoteRenderData) -> f32 {
+        0.0
+    }
+    fn repost_space_below_separator_after(_post: &NoteRenderData) -> f32 {
+        0.0
+    }
+
+    fn repost_inner_margin(_post: &NoteRenderData) -> Margin {
+        Margin {
+            left: 5.0,
+            top: 14.0,
+            right: 6.0,
+            bottom: 6.0,
+        }
+    }
+    fn repost_outer_margin(_post: &NoteRenderData) -> Margin {
+        Margin {
+            left: -5.0,
+            top: -14.0,
+            right: -6.0,
+            bottom: -3.0,
+        }
+    }
+    fn repost_rounding(post: &NoteRenderData) -> Rounding {
+        Self::feed_frame_rounding(post)
+    }
+    fn repost_shadow(_dark_mode: bool, _post: &NoteRenderData) -> Shadow {
+        Shadow::NONE
+    }
+    fn repost_fill(dark_mode: bool, post: &NoteRenderData) -> Color32 {
+        let mut hsva: ecolor::HsvaGamma = Self::feed_frame_fill(dark_mode, post).into();
+        if dark_mode {
+            hsva.v = (hsva.v + 0.05).min(1.0); // lighten
+        } else {
+            hsva.v = (hsva.v - 0.05).max(0.0); // darken
+        }
+        let color: Color32 = hsva.into();
+        color
+    }
+    fn repost_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke {
+        Self::feed_frame_stroke(dark_mode, post)
+    }
+
     fn round_image() -> bool {
         true
     }

src/ui/theme/mod.rs

@@ -182,21 +182,75 @@ macro_rules! theme_dispatch {
                 }
             }
 
-            pub fn repost_separator_stroke(&self, post: &NoteRenderData) -> Stroke {
+            pub fn repost_separator_before_stroke(&self, post: &NoteRenderData) -> Stroke {
                 match self.variant {
-                    $( $variant => $class::repost_separator_stroke(self.dark_mode, post), )+
+                    $( $variant => $class::repost_separator_before_stroke(self.dark_mode, post), )+
                 }
             }
 
-            pub fn repost_space_above_separator(&self, post: &NoteRenderData) -> f32 {
+            pub fn repost_space_above_separator_before(&self, post: &NoteRenderData) -> f32 {
                 match self.variant {
-                    $( $variant => $class::repost_space_above_separator(post), )+
+                    $( $variant => $class::repost_space_above_separator_before(post), )+
                 }
             }
 
-            pub fn repost_space_below_separator(&self, post: &NoteRenderData) -> f32 {
+            pub fn repost_space_below_separator_before(&self, post: &NoteRenderData) -> f32 {
                 match self.variant {
-                    $( $variant => $class::repost_space_below_separator(post), )+
+                    $( $variant => $class::repost_space_below_separator_before(post), )+
+                }
+            }
+
+            pub fn repost_separator_after_stroke(&self, post: &NoteRenderData) -> Stroke {
+                match self.variant {
+                    $( $variant => $class::repost_separator_after_stroke(self.dark_mode, post), )+
+                }
+            }
+
+            pub fn repost_space_above_separator_after(&self, post: &NoteRenderData) -> f32 {
+                match self.variant {
+                    $( $variant => $class::repost_space_above_separator_after(post), )+
+                }
+            }
+
+            pub fn repost_space_below_separator_after(&self, post: &NoteRenderData) -> f32 {
+                match self.variant {
+                    $( $variant => $class::repost_space_below_separator_after(post), )+
+                }
+            }
+
+            pub fn repost_inner_margin(&self, post: &NoteRenderData) -> Margin {
+                match self.variant {
+                    $( $variant => $class::repost_inner_margin(post), )+
+                }
+            }
+
+            pub fn repost_outer_margin(&self, post: &NoteRenderData) -> Margin {
+                match self.variant {
+                    $( $variant => $class::repost_outer_margin(post), )+
+                }
+            }
+
+            pub fn repost_rounding(&self, post: &NoteRenderData) -> Rounding {
+                match self.variant {
+                    $( $variant => $class::repost_rounding(post), )+
+                }
+            }
+
+            pub fn repost_shadow(&self, post: &NoteRenderData) -> Shadow {
+                match self.variant {
+                    $( $variant => $class::repost_shadow(self.dark_mode, post), )+
+                }
+            }
+
+            pub fn repost_fill(&self, post: &NoteRenderData) -> Color32 {
+                match self.variant {
+                    $( $variant => $class::repost_fill(self.dark_mode, post), )+
+                }
+            }
+
+            pub fn repost_stroke(&self, post: &NoteRenderData) -> Stroke {
+                match self.variant {
+                    $( $variant => $class::repost_stroke(self.dark_mode, post), )+
                 }
             }
 
@@ -253,9 +307,18 @@ pub trait ThemeDef: Send + Sync {
     fn feed_frame_shadow(dark_mode: bool, post: &NoteRenderData) -> Shadow;
     fn feed_frame_fill(dark_mode: bool, post: &NoteRenderData) -> Color32;
     fn feed_frame_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke;
-    fn repost_separator_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke;
-    fn repost_space_above_separator(post: &NoteRenderData) -> f32;
-    fn repost_space_below_separator(post: &NoteRenderData) -> f32;
+    fn repost_separator_before_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke;
+    fn repost_space_above_separator_before(post: &NoteRenderData) -> f32;
+    fn repost_space_below_separator_before(post: &NoteRenderData) -> f32;
+    fn repost_separator_after_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke;
+    fn repost_space_above_separator_after(post: &NoteRenderData) -> f32;
+    fn repost_space_below_separator_after(post: &NoteRenderData) -> f32;
+    fn repost_inner_margin(post: &NoteRenderData) -> Margin;
+    fn repost_outer_margin(post: &NoteRenderData) -> Margin;
+    fn repost_rounding(post: &NoteRenderData) -> Rounding;
+    fn repost_shadow(dark_mode: bool, post: &NoteRenderData) -> Shadow;
+    fn repost_fill(dark_mode: bool, post: &NoteRenderData) -> Color32;
+    fn repost_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke;
 
     // image rounding
     fn round_image() -> bool;

src/ui/theme/roundy.rs

@@ -2,7 +2,7 @@ use super::{FeedProperties, NoteRenderData, ThemeDef};
 use crate::ui::HighlightType;
 use eframe::egui::style::{Selection, WidgetVisuals, Widgets};
 use eframe::egui::{FontDefinitions, Margin, Style, TextFormat, TextStyle, Visuals};
-use eframe::epaint::{Color32, FontFamily, FontId, Rounding, Shadow, Stroke};
+use eframe::epaint::{Color32, FontFamily, FontId, Rounding, Shadow, Stroke, ecolor};
 use std::collections::BTreeMap;
 
 #[derive(Default)]
@@ -447,21 +447,67 @@ impl ThemeDef for RoundyTheme {
         }
     }
 
-    fn repost_separator_stroke(dark_mode: bool, _post: &NoteRenderData) -> Stroke {
-        if dark_mode {
-            Stroke::new(1.0, Color32::from_gray(72))
-        } else {
-            Stroke::new(1.0, Color32::from_gray(192))
-        }
+    fn repost_separator_before_stroke(_dark_mode: bool, _post: &NoteRenderData) -> Stroke {
+        // if dark_mode {
+        //     Stroke::new(1.0, Color32::from_gray(72))
+        // } else {
+        //     Stroke::new(1.0, Color32::from_gray(192))
+        // }
+        Stroke::NONE
     }
-
-    fn repost_space_above_separator(_post: &NoteRenderData) -> f32 {
+    fn repost_space_above_separator_before(_post: &NoteRenderData) -> f32 {
         0.0
     }
-    fn repost_space_below_separator(_post: &NoteRenderData) -> f32 {
+    fn repost_space_below_separator_before(_post: &NoteRenderData) -> f32 {
         8.0
     }
 
+    fn repost_separator_after_stroke(_dark_mode: bool, _post: &NoteRenderData) -> Stroke {
+        Stroke::NONE
+    }
+    fn repost_space_above_separator_after(_post: &NoteRenderData) -> f32 {
+        0.0
+    }
+    fn repost_space_below_separator_after(_post: &NoteRenderData) -> f32 {
+        8.0
+    }
+
+    fn repost_inner_margin(_post: &NoteRenderData) -> Margin {
+        Margin {
+            left: 10.0,
+            right: 10.0,
+            top: 10.0,
+            bottom: 10.0,
+        }
+    }
+    fn repost_outer_margin(_post: &NoteRenderData) -> Margin {
+        Margin {
+            left: -10.0,
+            right: -10.0,
+            top: -10.0,
+            bottom: -6.0,
+        }
+    }
+    fn repost_rounding(post: &NoteRenderData) -> Rounding {
+        Self::feed_frame_rounding(post)
+    }
+    fn repost_shadow(_dark_mode: bool, _post: &NoteRenderData) -> Shadow {
+        Shadow::NONE
+    }
+    fn repost_fill(dark_mode: bool, post: &NoteRenderData) -> Color32 {
+        let mut hsva: ecolor::HsvaGamma = Self::feed_frame_fill(dark_mode, post).into();
+        if dark_mode {
+            hsva.v = (hsva.v + 0.05).min(1.0); // lighten
+        } else {
+            hsva.v = (hsva.v - 0.05).max(0.0); // darken
+        }
+        let color: Color32 = hsva.into();
+        color
+    }
+    fn repost_stroke(dark_mode: bool, post: &NoteRenderData) -> Stroke {
+        Self::feed_frame_stroke(dark_mode, post)
+    }
+
     fn round_image() -> bool {
         true
     }