liftof_tui/tabs/
tab_events.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
use std::collections::{
  //HashMap,
  VecDeque,
};

//use std::sync::{
//    Arc,
//    Mutex,
//};

use crossbeam_channel::{
  Receiver,
  Sender,
};

use ratatui::prelude::*;

use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::widgets::{
  Block,
  BorderType,
  Borders,
  Paragraph,
};

//use tof_dataclasses::serialization::Serialization;
use tof_dataclasses::errors::SerializationError;
use tof_dataclasses::packets::TofPacket;
use tof_dataclasses::events::{
  RBEvent,
  TofEvent,
  TofHit,
  TofEventHeader,
  MasterTriggerEvent,
};

use crate::colors::ColorTheme;

#[derive(Debug, Clone)]
pub struct EventTab {
  pub theme         : ColorTheme,
  pub tp_receiver   : Receiver<TofPacket>,
  pub event_queue   : VecDeque<TofEvent>,
  pub queue_size    : usize,
  pub mte_sender    : Sender<MasterTriggerEvent>,
  pub rbe_sender    : Sender<RBEvent>,
  pub th_sender     : Sender<TofHit>,
  pub te_sender     : Sender<TofEvent>,
  //pub streamer   : Arc<Mutex<VecDeque<String>>>,
  //pub pack_stat  : Arc<Mutex<HashMap<String, usize>>>,
  //pub stream     : String,
  //pub stream_max : usize, 
}

impl EventTab {
  pub fn new(tp_receiver : Receiver<TofPacket>,
             mte_sender  : Sender<MasterTriggerEvent>,
             rbe_sender  : Sender<RBEvent>,
             th_sender   : Sender<TofHit>,
             te_sender   : Sender<TofEvent>,
             theme       : ColorTheme) -> Self {
             //streamer  : Arc<Mutex<VecDeque<String>>>,
             //pack_stat : Arc<Mutex<HashMap<String,usize>>>) -> HomeTab<T> {
    Self {
      theme,
      tp_receiver,
      event_queue : VecDeque::<TofEvent>::new(),
      queue_size  : 1000,
      mte_sender,
      rbe_sender,  
      th_sender,
      te_sender
      //streamer, 
      //pack_stat,
      //stream     : String::from(""),
      //stream_max : 30,
    }
  }
 
  pub fn receive_packet(&mut self) -> Result<(), SerializationError> {  
    match self.tp_receiver.try_recv() {
      Err(_err) => {
        return Ok(());
      },
      Ok(pack)    => {
        let ev : TofEvent = pack.unpack()?;
        match self.te_sender.send(ev.clone()) {
          Err(err) => error!("Can't send TofEvent! {err}"),
          Ok(_)    => ()
        }
        match self.mte_sender.send(ev.mt_event.clone()) {
          Err(err) => error!("Can't send MasterTriggerEvent! {err}"),
          Ok(_)    => ()
        }
        for k in ev.rb_events.iter() {
          let rb_ev = k.clone();
          for h in rb_ev.hits.iter() {
            match self.th_sender.send(h.clone()) {
              Err(err) => error!("Can't send TofHit! {err}"),
              Ok(_)    => ()
            }
          }
          match self.rbe_sender.send(k.clone()) {
            Err(err) => error!("Can not send RBEvent! {err}"),
            Ok(_)    => ()
          }
        }
        self.event_queue.push_back(ev);
        if self.event_queue.len() > self.queue_size {
          self.event_queue.pop_front();
        }
        return Ok(());
      }
    }
  }

  pub fn render(&mut self, main_window : &Rect, frame : &mut Frame) {
    
    // as usual, layout first
    let status_chunks = Layout::default()
      .direction(Direction::Horizontal)
      .constraints(
          [Constraint::Percentage(30), Constraint::Percentage(70)].as_ref(),
      )
      .split(*main_window);

    let header      = TofEventHeader::new();
    let mut header_string = header.to_string();
    match self.event_queue.back() {
      None => (),
      Some(ev)   => {
        header_string = ev.header.to_string();
        let info_field = format!("\n --> NRBs {}\n --> Quality: {}\n CompressionLevel {}",
                                 ev.rb_events.len(), ev.quality, ev.compression_level);
        header_string += &info_field;
      }
    }
    let header_view = Paragraph::new(header_string)
      .style(self.theme.style())
      .alignment(Alignment::Left)
      .block(
        Block::default()
          .borders(Borders::ALL)
          .border_type(BorderType::Rounded)
          .title("Last TofEvent")
      );
    frame.render_widget(header_view, status_chunks[0]);
  }
}