Raspberry Pi Weighting Control System
This project serves as a simple weighting control system, that was realized as a Bachelor Thesis
Public Member Functions | Public Attributes | List of all members
screen_manager Class Reference

#include <screen_manager.h>

Public Member Functions

 screen_manager ()
 
void render_active_screen ()
 
uint8_t get_selected_screen ()
 
void refresh_screen_elements (uint8_t screen)
 
void refresh_all_screns ()
 
void set_selected_screen (uint8_t screen)
 
void set_err_screen_content ()
 
void push_screen_to_previous ()
 
void pop_screen_from_previous ()
 
void clear_previous_screen_stack ()
 
uint8_t get_screen_count ()
 

Public Attributes

gui_elementfocused
 
gui_elementactivated
 

Detailed Description

Definition at line 19 of file screen_manager.h.

Constructor & Destructor Documentation

◆ screen_manager()

screen_manager::screen_manager ( )

Definition at line 34 of file screen_manager.cpp.

34  {
35  int desired_screen_number;
36  if (app_workspace::get_instance()->is_debug_screens())
37  desired_screen_number = DEBUG_SCREENS;
38  else
39  desired_screen_number = REAL_SCREENS;
40 
41  for (int i = 0; i <= desired_screen_number; i++) {
42  this->available_screens.emplace(i, std::vector<std::unique_ptr<gui_element>>());
43  }
44 
45  define_screen_0(available_screens.at(0));
46  if (app_workspace::get_instance()->is_debug_screens()) {
47  define_screen_1_debug(available_screens.at(1));
48  define_screen_2_debug(available_screens.at(2));
49  define_screen_3_debug(available_screens.at(3));
50  define_screen_4_debug(available_screens.at(4));
51  define_screen_5_debug(available_screens.at(5));
52  } else {
53  define_screen_1(available_screens.at(LOGIN_SCREEN));
54  define_screen_2(available_screens.at(MEASURING_SCREEN));
55  define_screen_3(available_screens.at(SELECTION_SCREEN));
56  define_screen_4(available_screens.at(DETAIL_SCREEN));
57  define_screen_5(available_screens.at(ADMIN_SELECT_SCREEN));
58  define_screen_6(available_screens.at(ADMIN_CTRL_SCREEN));
59  }
60 
61  this->selected_screen = 1; // default screen
62 }
static std::unique_ptr< app_workspace > & get_instance()
Get the instance app_workspace which is a singleton.
void define_screen_5_debug(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 5.
void define_screen_5(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 5.
void define_screen_6(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 6.
void define_screen_1(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 1.
void define_screen_0(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 0.
void define_screen_1_debug(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 1.
void define_screen_2_debug(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 2.
void define_screen_4(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 4.
void define_screen_3_debug(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 3.
void define_screen_3(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 3.
void define_screen_2(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 2.
void define_screen_4_debug(std::vector< std::unique_ptr< gui_element >> &elems)
Definitions of gui elemnts of debug screen 4.
#define REAL_SCREENS
#define DEBUG_SCREENS
#define LOGIN_SCREEN
#define ADMIN_SELECT_SCREEN
#define DETAIL_SCREEN
#define ADMIN_CTRL_SCREEN
#define MEASURING_SCREEN
#define SELECTION_SCREEN

Member Function Documentation

◆ clear_previous_screen_stack()

void screen_manager::clear_previous_screen_stack ( )

Definition at line 285 of file screen_manager.cpp.

285  {
286  prev_screen_stack.clear();
287 }

◆ get_screen_count()

uint8_t screen_manager::get_screen_count ( )

Definition at line 397 of file screen_manager.cpp.

397  {
398  // -1 because 0 is err_screen
399  return available_screens.size() - 1;
400 }

◆ get_selected_screen()

uint8_t screen_manager::get_selected_screen ( )

Definition at line 155 of file screen_manager.cpp.

155  {
156  return this->selected_screen;
157 }

◆ pop_screen_from_previous()

void screen_manager::pop_screen_from_previous ( )

Definition at line 275 of file screen_manager.cpp.

275  {
276  if (prev_screen_stack.size() <= 0) {
277  spdlog::info("screen_manager.cpp - Cannot go to previous screen. No screens in stack.");
278  return;
279  }
280 
281  selected_screen = prev_screen_stack[prev_screen_stack.size() - 1];
282  prev_screen_stack.pop_back();
283 }

◆ push_screen_to_previous()

void screen_manager::push_screen_to_previous ( )

Definition at line 265 of file screen_manager.cpp.

265  {
266  if (prev_screen_stack.size() > PREV_SCREEN_Q_MAX)
267  prev_screen_stack.erase(prev_screen_stack.begin() + (PREV_SCREEN_Q_MAX / 2));
268  // prev_screen_stack.clear();
269 
270  // dont allow to go back to error screen
271  if (selected_screen > 0)
272  prev_screen_stack.push_back(selected_screen);
273 }
#define PREV_SCREEN_Q_MAX

◆ refresh_all_screns()

void screen_manager::refresh_all_screns ( )

Definition at line 257 of file screen_manager.cpp.

257  {
258  // starting from 1, because 0 (err_sreen) doesn't need to be reloaded
259  // also don't do error checking for i > 255 (refresh_screen_elements takes uint8_t)
260  for (size_t i = 1; i < available_screens.size(); i++) {
262  }
263 }
void refresh_screen_elements(uint8_t screen)

◆ refresh_screen_elements()

void screen_manager::refresh_screen_elements ( uint8_t  screen)

Definition at line 203 of file screen_manager.cpp.

203  {
204  std::vector<std::unique_ptr<gui_element>> *elems;
205 
206  try {
207  elems = &(available_screens.at(screen));
208  //elems->clear(); //clear current screen elements
209  } catch (std::invalid_argument &ex) {
210  spdlog::error("screen_manager.cpp - Cannot refresh screen {0}. Screen doesn't exist");
211  return;
212  }
213 
214  if (app_workspace::get_instance()->is_debug_screens()) {
215  switch (screen) {
216  case 0:
217  define_screen_0(*elems); break;
218  case 1:
219  define_screen_1_debug(*elems); break;
220  case 2:
221  define_screen_2_debug(*elems); break;
222  case 3:
223  define_screen_3_debug(*elems); break;
224  case 4:
225  define_screen_4_debug(*elems); break;
226  case 5:
227  define_screen_5_debug(*elems); break;
228 
229  default:
230  spdlog::error("screen_manager.cpp - Cannot refresh screen {0}. Screen doesn't exist", screen);
231  break;
232  }
233  } else {
234  switch (screen) {
235  case 0:
236  define_screen_0(*elems); break;
237  case 1:
238  define_screen_1(*elems); break;
239  case 2:
240  define_screen_2(*elems); break;
241  case 3:
242  define_screen_3(*elems); break;
243  case 4:
244  define_screen_4(*elems); break;
245  case 5:
246  define_screen_5(*elems); break;
247  case 6:
248  define_screen_6(*elems); break;
249 
250  default:
251  spdlog::error("screen_manager.cpp - Cannot refresh screen {0}. Screen doesn't exist", screen);
252  break;
253  }
254  }
255 }

◆ render_active_screen()

void screen_manager::render_active_screen ( )

Definition at line 117 of file screen_manager.cpp.

117  {
118  //spdlog::debug("screen_manager.cpp - Rendering screen number: {0}", this->selected_screen);
119  rt_content_width = ImGui::GetWindowContentRegionMax().x;
120  rt_line_height = ImGui::GetTextLineHeightWithSpacing();
121 
122  if (app_workspace::get_instance()->refresh_current_screen) {
123  refresh_screen_elements(selected_screen);
124  app_workspace::get_instance()->refresh_current_screen = false;
125  }
126 
127  /*
128  if (ImGui::IsAnyItemActive())
129  spdlog::info("An item is ACTIVE");
130  if (ImGui::IsAnyItemFocused())
131  spdlog::info("An item is FOCUSED");
132  if (ImGui::IsAnyItemHovered())
133  spdlog::info("An item is HOVERED");
134  */
135 
138 
140  try {
141  std::vector<std::unique_ptr<gui_element>> &elements = available_screens.at(selected_screen);
142  render_screen(elements);
143  } catch (std::out_of_range &ex) {
144  spdlog::error("screen_manager.cpp - Failed to find screen key in available_screens map."
145  " Cannot display selected screen");
146  selected_screen = 0;
148  return;
149  }
150 
152  render_nav_bar();
153 }
void render_active_screen()
void render_status_bar()
void render_nav_bar()
called nav bar, render current input mode at the bottom of the screen
float rt_content_width
float rt_line_height

◆ set_err_screen_content()

void screen_manager::set_err_screen_content ( )

◆ set_selected_screen()

void screen_manager::set_selected_screen ( uint8_t  screen)

Definition at line 159 of file screen_manager.cpp.

159  {
160  /* not tested - for now disabled for easier testing
161  if (app_workspace::get_instance()->has_user()) {
162  if (app_workspace::get_instance()->userspace->get_role() == 0) {
163  if (!is_screen_available_to_user(patient_screens, PATIENT_SCREEN_CNT, screen)) {
164  spdlog::debug("User doesn't have permission to access screen {0}", screen);
165  return;
166  }
167  } else if (app_workspace::get_instance()->userspace->get_role() == 1) {
168  if (!is_screen_available_to_user(employee_screens, EMPLOYEE_SCREEN_CNT, screen)) {
169  spdlog::debug("User doesn't have permission to access screen {0}", screen);
170  return;
171  }
172  } else if (app_workspace::get_instance()->userspace->get_role() == 2) {
173  // no action for admin, admin has permission for all screens
174  } else {
175  spdlog::error("User role not recognized when setting screen");
176  return;
177  }
178  } else {
179  spdlog::debug("No user login, only available screen is 1");
180  if (this->selected_screen != 1) this->selected_screen = 1;
181  return;
182  }
183  */
184 
185  if (app_workspace::get_instance()->is_debug_screens()) {
186  if (screen > DEBUG_SCREENS) {
187  spdlog::debug("Discarding screen select request.");
188  return;
189  }
190  } else {
191  if (screen > REAL_SCREENS) {
192  spdlog::debug("Discarding screen select request.");
193  return;
194  }
195  }
196 
197  spdlog::info("Setting screen to {0}", screen);
199  this->selected_screen = screen;
200 }
void push_screen_to_previous()

Member Data Documentation

◆ activated

gui_element* screen_manager::activated

Definition at line 31 of file screen_manager.h.

◆ focused

gui_element* screen_manager::focused

Definition at line 30 of file screen_manager.h.


The documentation for this class was generated from the following files: