ESPHome  2024.6.6
graphical_display_menu.cpp
Go to the documentation of this file.
2 #include "esphome/core/hal.h"
3 #include "esphome/core/helpers.h"
4 #include "esphome/core/log.h"
5 #include <cstdlib>
7 
8 namespace esphome {
9 namespace graphical_display_menu {
10 
11 static const char *const TAG = "graphical_display_menu";
12 
14  if (this->display_ != nullptr) {
15  display::display_writer_t writer = [this](display::Display &it) { this->draw_menu(); };
16  this->display_page_ = make_unique<display::DisplayPage>(writer);
17  }
18 
19  if (!this->menu_item_value_.has_value()) {
20  this->menu_item_value_ = [](const MenuItemValueArguments *it) {
21  std::string label = " ";
22  if (it->is_item_selected && it->is_menu_editing) {
23  label.append(">");
24  label.append(it->item->get_value_text());
25  label.append("<");
26  } else {
27  label.append("(");
28  label.append(it->item->get_value_text());
29  label.append(")");
30  }
31  return label;
32  };
33  }
34 
36 }
37 
39  ESP_LOGCONFIG(TAG, "Graphical Display Menu");
40  ESP_LOGCONFIG(TAG, "Has Display: %s", YESNO(this->display_ != nullptr));
41  ESP_LOGCONFIG(TAG, "Popup Mode: %s", YESNO(this->display_ != nullptr));
42  ESP_LOGCONFIG(TAG, "Advanced Drawing Mode: %s", YESNO(this->display_ == nullptr));
43  ESP_LOGCONFIG(TAG, "Has Font: %s", YESNO(this->font_ != nullptr));
44  ESP_LOGCONFIG(TAG, "Mode: %s", this->mode_ == display_menu_base::MENU_MODE_ROTARY ? "Rotary" : "Joystick");
45  ESP_LOGCONFIG(TAG, "Active: %s", YESNO(this->active_));
46  ESP_LOGCONFIG(TAG, "Menu items:");
47  for (size_t i = 0; i < this->displayed_item_->items_size(); i++) {
48  auto *item = this->displayed_item_->get_item(i);
49  ESP_LOGCONFIG(TAG, " %i: %s (Type: %s, Immediate Edit: %s)", i, item->get_text().c_str(),
50  LOG_STR_ARG(display_menu_base::menu_item_type_to_string(item->get_type())),
51  YESNO(item->get_immediate_edit()));
52  }
53 }
54 
55 void GraphicalDisplayMenu::set_display(display::Display *display) { this->display_ = display; }
56 
58 
59 void GraphicalDisplayMenu::set_foreground_color(Color foreground_color) { this->foreground_color_ = foreground_color; }
60 void GraphicalDisplayMenu::set_background_color(Color background_color) { this->background_color_ = background_color; }
61 
63  if (this->display_ != nullptr) {
65  this->display_->show_page(this->display_page_.get());
66  this->display_->clear();
67  } else {
68  this->update();
69  }
70 }
71 
73  if (this->previous_display_page_ != nullptr) {
75  this->display_->clear();
76  this->update();
77  this->previous_display_page_ = nullptr;
78  } else {
79  this->update();
80  }
81 }
82 
84  this->update();
85 
86  // If we're in advanced drawing mode we won't have a display and will instead require the update callback to do
87  // our drawing
88  if (this->display_ != nullptr) {
89  draw_menu();
90  }
91 }
92 
94  if (this->display_ == nullptr) {
95  ESP_LOGE(TAG, "draw_menu() called without a display_. This is only available when using the menu in pop up mode");
96  return;
97  }
98  display::Rect bounds(0, 0, this->display_->get_width(), this->display_->get_height());
99  this->draw_menu_internal_(this->display_, &bounds);
100 }
101 
103  this->draw_menu_internal_(display, bounds);
104 }
105 
107  int16_t total_height = 0;
108  int16_t max_width = 0;
109  int y_padding = 2;
110  bool scroll_menu_items = false;
111  std::vector<display::Rect> menu_dimensions;
112  int number_items_fit_to_screen = 0;
113  const int max_item_index = this->displayed_item_->items_size() - 1;
114 
115  for (size_t i = 0; i <= max_item_index; i++) {
116  const auto *item = this->displayed_item_->get_item(i);
117  const bool selected = i == this->cursor_index_;
118  const display::Rect item_dimensions = this->measure_item(display, item, bounds, selected);
119 
120  menu_dimensions.push_back(item_dimensions);
121  total_height += item_dimensions.h + (i == 0 ? 0 : y_padding);
122  max_width = std::max(max_width, item_dimensions.w);
123 
124  if (total_height <= bounds->h) {
125  number_items_fit_to_screen++;
126  } else {
127  // Scroll the display if the selected item or the item immediately after it overflows
128  if ((selected) || (i == this->cursor_index_ + 1)) {
129  scroll_menu_items = true;
130  }
131  }
132  }
133 
134  // Determine what items to draw
135  int first_item_index = 0;
136  int last_item_index = max_item_index;
137 
138  if (number_items_fit_to_screen <= 1) {
139  // If only one item can fit to the bounds draw the current cursor item
140  last_item_index = std::min(last_item_index, this->cursor_index_ + 1);
141  first_item_index = this->cursor_index_;
142  } else {
143  if (scroll_menu_items) {
144  // Attempt to draw the item after the current item (+1 for equality check in the draw loop)
145  last_item_index = std::min(last_item_index, this->cursor_index_ + 1);
146 
147  // Go back through the measurements to determine how many prior items we can fit
148  int height_left_to_use = bounds->h;
149  for (int i = last_item_index; i >= 0; i--) {
150  const display::Rect item_dimensions = menu_dimensions[i];
151  height_left_to_use -= (item_dimensions.h + y_padding);
152 
153  if (height_left_to_use <= 0) {
154  // Ran out of space - this is our first item to draw
155  first_item_index = i;
156  break;
157  }
158  }
159  const int items_to_draw = last_item_index - first_item_index;
160  // Dont't draw last item partially if it is the selected item
161  if ((this->cursor_index_ == last_item_index) && (number_items_fit_to_screen <= items_to_draw) &&
162  (first_item_index < max_item_index)) {
163  first_item_index++;
164  }
165  }
166  }
167 
168  // Render the items into the view port
169  display->start_clipping(*bounds);
170 
171  display->filled_rectangle(bounds->x, bounds->y, max_width, total_height, this->background_color_);
172  auto y_offset = bounds->y;
173  for (size_t i = first_item_index; i <= last_item_index; i++) {
174  const auto *item = this->displayed_item_->get_item(i);
175  const bool selected = i == this->cursor_index_;
176  display::Rect dimensions = menu_dimensions[i];
177 
178  dimensions.y = y_offset;
179  dimensions.x = bounds->x;
180  this->draw_item(display, item, &dimensions, selected);
181 
182  y_offset += dimensions.h + y_padding;
183  }
184 
185  display->end_clipping();
186 }
187 
189  const display::Rect *bounds, const bool selected) {
190  display::Rect dimensions(0, 0, 0, 0);
191 
192  if (selected) {
193  // TODO: Support selection glyph
194  dimensions.w += 0;
195  dimensions.h += 0;
196  }
197 
198  std::string label = item->get_text();
199  if (item->has_value()) {
200  // Append to label
201  MenuItemValueArguments args(item, selected, this->editing_);
202  label.append(this->menu_item_value_.value(&args));
203  }
204 
205  int x1;
206  int y1;
207  int width;
208  int height;
209  display->get_text_bounds(0, 0, label.c_str(), this->font_, display::TextAlign::TOP_LEFT, &x1, &y1, &width, &height);
210 
211  dimensions.w = std::min((int16_t) width, bounds->w);
212  dimensions.h = std::min((int16_t) height, bounds->h);
213 
214  return dimensions;
215 }
216 
218  const display::Rect *bounds, const bool selected) {
219  const auto background_color = selected ? this->foreground_color_ : this->background_color_;
220  const auto foreground_color = selected ? this->background_color_ : this->foreground_color_;
221 
222  // int background_width = std::max(bounds->width, available_width);
223  int background_width = bounds->w;
224 
225  display->filled_rectangle(bounds->x, bounds->y, background_width, bounds->h, background_color);
226 
227  std::string label = item->get_text();
228  if (item->has_value()) {
229  MenuItemValueArguments args(item, selected, this->editing_);
230  label.append(this->menu_item_value_.value(&args));
231  }
232 
233  display->print(bounds->x, bounds->y, this->font_, foreground_color, display::TextAlign::TOP_LEFT, label.c_str(),
234  background_color);
235 }
236 
237 void GraphicalDisplayMenu::draw_item(const display_menu_base::MenuItem *item, const uint8_t row, const bool selected) {
238  ESP_LOGE(TAG, "draw_item(MenuItem *item, uint8_t row, bool selected) called. The graphical_display_menu specific "
239  "draw_item should be called.");
240 }
241 
243 
244 } // namespace graphical_display_menu
245 } // namespace esphome
void get_text_bounds(int x, int y, const char *text, BaseFont *font, TextAlign align, int *x1, int *y1, int *width, int *height)
Get the text bounds of the given string.
Definition: display.cpp:405
virtual bool has_value() const
Definition: menu_item.h:53
int16_t x
X coordinate of corner.
Definition: rect.h:12
void filled_rectangle(int x1, int y1, int width, int height, Color color=COLOR_ON)
Fill a rectangle with the top left point at [x1,y1] and the bottom right point at [x1+width...
Definition: display.cpp:104
void draw_menu_internal_(display::Display *display, const display::Rect *bounds)
const DisplayPage * get_active_page() const
Definition: display.h:570
int16_t h
Height of region.
Definition: rect.h:15
virtual int get_width()
Get the calculated width of the display in pixels with rotation applied.
Definition: display.h:215
int16_t y
Y coordinate of corner.
Definition: rect.h:13
void draw_item(const display_menu_base::MenuItem *item, uint8_t row, bool selected) override
std::function< void(Display &)> display_writer_t
Definition: display.h:180
virtual void setup()
Where the component&#39;s initialization should happen.
Definition: component.cpp:48
void start_clipping(Rect rect)
Set the clipping rectangle for further drawing.
Definition: display.cpp:539
void clear()
Clear the entire screen by filling it with OFF pixels.
Definition: display.cpp:16
void print(int x, int y, BaseFont *font, Color color, TextAlign align, const char *text, Color background=COLOR_OFF)
Print text with the anchor point at [x,y] with font.
Definition: display.cpp:337
TemplatableValue< std::string, const MenuItemValueArguments * > menu_item_value_
std::string get_text() const
Definition: menu_item.h:51
void end_clipping()
Reset the invalidation region.
Definition: display.cpp:546
virtual int get_height()
Get the calculated height of the display in pixels with rotation applied.
Definition: display.h:217
std::unique_ptr< display::DisplayPage > display_page_
uint8_t h
Definition: bl0939.h:21
virtual display::Rect measure_item(display::Display *display, const display_menu_base::MenuItem *item, const display::Rect *bounds, bool selected)
This is a workaround until we can figure out a way to get the tflite-micro idf component code availab...
Definition: a01nyub.cpp:7
void show_page(DisplayPage *page)
Definition: display.cpp:496
int16_t w
Width of region.
Definition: rect.h:14
const LogString * menu_item_type_to_string(MenuItemType type)
Returns a string representation of a menu item type suitable for logging.
Definition: menu_item.cpp:8