notedeck

One damus client to rule them all
git clone git://jb55.com/notedeck
Log | Files | Refs | README | LICENSE

username.rs (2881B)

      1 use egui::{Color32, RichText, Widget};
      2 use nostrdb::ProfileRecord;
      3 use notedeck::{fonts::NamedFontFamily, tr, Localization};
      4 
      5 pub struct Username<'a> {
      6     i18n: &'a mut Localization,
      7     profile: Option<&'a ProfileRecord<'a>>,
      8     pk: &'a [u8; 32],
      9     pk_colored: bool,
     10     abbrev: usize,
     11 }
     12 
     13 impl<'a> Username<'a> {
     14     pub fn pk_colored(mut self, pk_colored: bool) -> Self {
     15         self.pk_colored = pk_colored;
     16         self
     17     }
     18 
     19     pub fn abbreviated(mut self, amount: usize) -> Self {
     20         self.abbrev = amount;
     21         self
     22     }
     23 
     24     pub fn new(
     25         i18n: &'a mut Localization,
     26         profile: Option<&'a ProfileRecord>,
     27         pk: &'a [u8; 32],
     28     ) -> Self {
     29         let pk_colored = false;
     30         let abbrev: usize = 1000;
     31         Username {
     32             i18n,
     33             profile,
     34             pk,
     35             pk_colored,
     36             abbrev,
     37         }
     38     }
     39 }
     40 
     41 impl Widget for Username<'_> {
     42     fn ui(self, ui: &mut egui::Ui) -> egui::Response {
     43         ui.horizontal(|ui| {
     44             ui.spacing_mut().item_spacing.x = 0.0;
     45 
     46             let color = if self.pk_colored {
     47                 Some(pk_color(self.pk))
     48             } else {
     49                 None
     50             };
     51 
     52             if let Some(profile) = self.profile {
     53                 if let Some(prof) = profile.record().profile() {
     54                     if prof.display_name().is_some() && prof.display_name().unwrap() != "" {
     55                         ui_abbreviate_name(ui, prof.display_name().unwrap(), self.abbrev, color);
     56                     } else if let Some(name) = prof.name() {
     57                         ui_abbreviate_name(ui, name, self.abbrev, color);
     58                     }
     59                 }
     60             } else {
     61                 let mut txt = RichText::new(tr!(
     62                     self.i18n,
     63                     "nostrich",
     64                     "Default username when profile is not available"
     65                 ))
     66                 .family(NamedFontFamily::Medium.as_family());
     67                 if let Some(col) = color {
     68                     txt = txt.color(col)
     69                 }
     70                 ui.label(txt);
     71             }
     72         })
     73         .response
     74     }
     75 }
     76 
     77 fn colored_name(name: &str, color: Option<Color32>) -> RichText {
     78     let mut txt = RichText::new(name).family(NamedFontFamily::Medium.as_family());
     79 
     80     if let Some(color) = color {
     81         txt = txt.color(color);
     82     }
     83 
     84     txt
     85 }
     86 
     87 fn ui_abbreviate_name(ui: &mut egui::Ui, name: &str, len: usize, color: Option<Color32>) {
     88     let should_abbrev = name.len() > len;
     89     let name = if should_abbrev {
     90         let closest = notedeck::abbrev::floor_char_boundary(name, len);
     91         &name[..closest]
     92     } else {
     93         name
     94     };
     95 
     96     ui.label(colored_name(name, color));
     97 
     98     if should_abbrev {
     99         ui.label(colored_name("..", color));
    100     }
    101 }
    102 
    103 fn pk_color(pk: &[u8; 32]) -> Color32 {
    104     Color32::from_rgb(pk[8], pk[10], pk[12])
    105 }